1 /* Lisp functions for making directory listings.
2 Copyright (C) 1985, 1986, 1992, 1993, 1994 Free Software Foundation, Inc.
4 This file is part of XEmacs.
6 XEmacs is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 2, or (at your option) any
11 XEmacs is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with XEmacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 /* Synched up with: FSF 19.30. */
36 Lisp_Object Vcompletion_ignored_extensions;
37 Lisp_Object Qdirectory_files;
38 Lisp_Object Qfile_name_completion;
39 Lisp_Object Qfile_name_all_completions;
40 Lisp_Object Qfile_attributes;
43 close_directory_unwind (Lisp_Object unwind_obj)
45 DIR *d = (DIR *)get_opaque_ptr (unwind_obj);
47 free_opaque_ptr (unwind_obj);
51 DEFUN ("directory-files", Fdirectory_files, 1, 5, 0, /*
52 Return a list of names of files in DIRECTORY.
53 There are four optional arguments:
54 If FULL is non-nil, absolute pathnames of the files are returned.
55 If MATCH is non-nil, only pathnames containing that regexp are returned.
56 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
57 NOSORT is useful if you plan to sort the result yourself.
58 If FILES-ONLY is the symbol t, then only the "files" in the directory
59 will be returned; subdirectories will be excluded. If FILES-ONLY is not
60 nil and not t, then only the subdirectories will be returned. Otherwise,
61 if FILES-ONLY is nil (the default) then both files and subdirectories will
64 (dirname, full, match, nosort, files_only))
66 /* This function can GC */
68 Lisp_Object list = Qnil;
71 struct re_pattern_buffer *bufp = NULL;
72 int speccount = specpdl_depth ();
73 char *statbuf, *statbuf_tail;
75 struct gcpro gcpro1, gcpro2;
76 GCPRO2 (dirname, list);
78 /* If the file name has special constructs in it,
79 call the corresponding file handler. */
80 handler = Ffind_file_name_handler (dirname, Qdirectory_files);
84 if (!NILP (files_only))
85 return call6 (handler, Qdirectory_files, dirname, full, match, nosort,
88 return call5 (handler, Qdirectory_files, dirname, full, match,
92 /* #### why do we do Fexpand_file_name after file handlers here,
93 but earlier everywhere else? */
94 dirname = Fexpand_file_name (dirname, Qnil);
95 dirname = Ffile_name_as_directory (dirname);
96 dirnamelen = XSTRING_LENGTH (dirname);
98 statbuf = (char *)alloca (dirnamelen + MAXNAMLEN + 1);
99 memcpy (statbuf, XSTRING_DATA (dirname), dirnamelen);
100 statbuf_tail = statbuf + dirnamelen;
102 /* XEmacs: this should come after Ffile_name_as_directory() to avoid
103 potential regexp cache smashage. It comes before the opendir()
104 because it might signal an error. */
107 CHECK_STRING (match);
109 /* MATCH might be a flawed regular expression. Rather than
110 catching and signalling our own errors, we just call
111 compile_pattern to do the work for us. */
112 bufp = compile_pattern (match, 0, 0, 0, ERROR_ME);
115 /* Now *bufp is the compiled form of MATCH; don't call anything
116 which might compile a new regexp until we're done with the loop! */
118 /* Do this opendir after anything which might signal an error.
119 NOTE: the above comment is old; previosly, there was no
120 unwind-protection in case of error, but now there is. */
121 d = opendir ((char *) XSTRING_DATA (dirname));
123 report_file_error ("Opening directory", list1 (dirname));
125 record_unwind_protect (close_directory_unwind, make_opaque_ptr ((void *)d));
127 /* Loop reading blocks */
130 DIRENTRY *dp = readdir (d);
137 if (DIRENTRY_NONEMPTY (dp)
139 || (0 <= re_search (bufp, dp->d_name, len, 0, len, 0))))
141 if (!NILP (files_only))
145 char *cur_statbuf = statbuf;
146 char *cur_statbuf_tail = statbuf_tail;
148 /* #### I don't think the code under `if' is necessary
149 anymore. The crashes in this function were reported
150 because MAXNAMLEN was used to remember the *whole*
151 statbuf, instead of using MAXPATHLEN. This should be
152 tested after 21.0 is released. */
154 /* We normally use the buffer created by alloca.
155 However, if the file name we get too big, we'll use a
156 malloced buffer, and free it. It is undefined how
157 stat() will react to this, but we avoid a buffer
161 cur_statbuf = (char *)xmalloc (dirnamelen + len + 1);
162 memcpy (cur_statbuf, statbuf, dirnamelen);
163 cur_statbuf_tail = cur_statbuf + dirnamelen;
165 memcpy (cur_statbuf_tail, dp->d_name, len);
166 cur_statbuf_tail[len] = 0;
168 if (stat (cur_statbuf, &st) < 0)
171 dir_p = ((st.st_mode & S_IFMT) == S_IFDIR);
173 if (cur_statbuf != statbuf)
176 if (EQ (files_only, Qt) && dir_p)
178 else if (!EQ (files_only, Qt) && !dir_p)
183 name = concat2 (dirname, make_ext_string ((Bufbyte *)dp->d_name,
184 len, FORMAT_FILENAME));
186 name = make_ext_string ((Bufbyte *)dp->d_name,
187 len, FORMAT_FILENAME);
189 list = Fcons (name, list);
192 unbind_to (speccount, Qnil); /* This will close the dir */
195 RETURN_UNGCPRO (list);
197 RETURN_UNGCPRO (Fsort (Fnreverse (list), Qstring_lessp));
200 static Lisp_Object file_name_completion (Lisp_Object file,
202 int all_flag, int ver_flag);
204 DEFUN ("file-name-completion", Ffile_name_completion, 2, 2, 0, /*
205 Complete file name FILE in directory DIR.
206 Returns the longest string common to all filenames in DIR
207 that start with FILE.
208 If there is only one and FILE matches it exactly, returns t.
209 Returns nil if DIR contains no name starting with FILE.
211 Filenames which end with any member of `completion-ignored-extensions'
212 are not considered as possible completions for FILE unless there is no
213 other possible completion. `completion-ignored-extensions' is not applied
214 to the names of directories.
218 /* This function can GC. GC checked 1996.04.06. */
221 /* If the directory name has special constructs in it,
222 call the corresponding file handler. */
223 handler = Ffind_file_name_handler (dirname, Qfile_name_completion);
225 return call3 (handler, Qfile_name_completion, file, dirname);
227 /* If the file name has special constructs in it,
228 call the corresponding file handler. */
229 handler = Ffind_file_name_handler (file, Qfile_name_completion);
231 return call3 (handler, Qfile_name_completion, file, dirname);
233 return file_name_completion (file, dirname, 0, 0);
236 DEFUN ("file-name-all-completions", Ffile_name_all_completions, 2, 2, 0, /*
237 Return a list of all completions of file name FILE in directory DIR.
238 These are all file names in directory DIR which begin with FILE.
240 Filenames which end with any member of `completion-ignored-extensions'
241 are not considered as possible completions for FILE unless there is no
242 other possible completion. `completion-ignored-extensions' is not applied
243 to the names of directories.
247 /* This function can GC. GC checked 1997.06.04. */
252 dirname = Fexpand_file_name (dirname, Qnil);
253 /* If the file name has special constructs in it,
254 call the corresponding file handler. */
255 handler = Ffind_file_name_handler (dirname, Qfile_name_all_completions);
258 return call3 (handler, Qfile_name_all_completions, file,
261 return file_name_completion (file, dirname, 1, 0);
265 file_name_completion_stat (Lisp_Object dirname, DIRENTRY *dp,
266 struct stat *st_addr)
268 Bytecount len = NAMLEN (dp);
269 Bytecount pos = XSTRING_LENGTH (dirname);
271 char *fullname = (char *) alloca (len + pos + 2);
273 memcpy (fullname, XSTRING_DATA (dirname), pos);
274 if (!IS_DIRECTORY_SEP (fullname[pos - 1]))
275 fullname[pos++] = DIRECTORY_SEP;
277 memcpy (fullname + pos, dp->d_name, len);
278 fullname[pos + len] = 0;
281 /* We want to return success if a link points to a nonexistent file,
282 but we want to return the status for what the link points to,
283 in case it is a directory. */
284 value = lstat (fullname, st_addr);
285 if (S_ISLNK (st_addr->st_mode))
286 stat (fullname, st_addr);
288 value = stat (fullname, st_addr);
294 file_name_completion_unwind (Lisp_Object locative)
297 Lisp_Object obj = XCAR (locative);
301 d = (DIR *)get_opaque_ptr (obj);
303 free_opaque_ptr (obj);
305 free_cons (XCONS (locative));
310 file_name_completion (Lisp_Object file, Lisp_Object dirname, int all_flag,
313 /* This function can GC */
316 Lisp_Object bestmatch = Qnil;
317 Charcount bestmatchsize = 0;
320 int speccount = specpdl_depth ();
321 Charcount file_name_length;
322 Lisp_Object locative;
323 struct gcpro gcpro1, gcpro2, gcpro3;
325 GCPRO3 (file, dirname, bestmatch);
330 /* Filename completion on Windows ignores case, since Windows
332 specbind (Qcompletion_ignore_case, Qt);
333 #endif /* WINDOWSNT */
335 #ifdef FILE_SYSTEM_CASE
336 file = FILE_SYSTEM_CASE (file);
338 dirname = Fexpand_file_name (dirname, Qnil);
339 file_name_length = XSTRING_CHAR_LENGTH (file);
341 /* With passcount = 0, ignore files that end in an ignored extension.
342 If nothing found then try again with passcount = 1, don't ignore them.
343 If looking for all completions, start with passcount = 1,
344 so always take even the ignored ones.
346 ** It would not actually be helpful to the user to ignore any possible
347 completions when making a list of them.** */
349 /* We cannot use close_directory_unwind() because we change the
350 directory. The old code used to just avoid signaling errors, and
351 call closedir, but it was wrong, because it made sane handling of
352 QUIT impossible and, besides, various utility functions like
353 regexp_ignore_completion_p can signal errors. */
354 locative = noseeum_cons (Qnil, Qnil);
355 record_unwind_protect (file_name_completion_unwind, locative);
357 for (passcount = !!all_flag; NILP (bestmatch) && passcount < 2; passcount++)
359 d = opendir ((char *) XSTRING_DATA (Fdirectory_file_name (dirname)));
361 report_file_error ("Opening directory", list1 (dirname));
362 XCAR (locative) = make_opaque_ptr ((void *)d);
364 /* Loop reading blocks */
369 /* scmp() works in characters, not bytes, so we have to compute
373 int ignored_extension_p = 0;
379 /* #### This is a bad idea, because d_name can contain
380 control characters, which can make XEmacs crash. This
381 should be handled properly with FORMAT_FILENAME. */
382 d_name = (Bufbyte *) dp->d_name;
384 cclen = bytecount_to_charcount (d_name, len);
388 if (! DIRENTRY_NONEMPTY (dp)
389 || cclen < file_name_length
390 || 0 <= scmp (d_name, XSTRING_DATA (file), file_name_length))
393 if (file_name_completion_stat (dirname, dp, &st) < 0)
396 directoryp = ((st.st_mode & S_IFMT) == S_IFDIR);
399 #ifndef TRIVIAL_DIRECTORY_ENTRY
400 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
402 /* "." and ".." are never interesting as completions, but are
403 actually in the way in a directory containing only one file. */
404 if (!passcount && TRIVIAL_DIRECTORY_ENTRY (dp->d_name))
409 /* Compare extensions-to-be-ignored against end of this file name */
410 /* if name is not an exact match against specified string. */
411 if (!passcount && cclen > file_name_length)
414 /* and exit this for loop if a match is found */
415 EXTERNAL_LIST_LOOP (tem, Vcompletion_ignored_extensions)
417 Lisp_Object elt = XCAR (tem);
422 skip = cclen - XSTRING_CHAR_LENGTH (elt);
423 if (skip < 0) continue;
425 if (0 > scmp (charptr_n_addr (d_name, skip),
427 XSTRING_CHAR_LENGTH (elt)))
429 ignored_extension_p = 1;
436 /* If an ignored-extensions match was found,
437 don't process this name as a completion. */
438 if (!passcount && ignored_extension_p)
441 if (!passcount && regexp_ignore_completion_p (d_name, Qnil, 0, cclen))
444 /* Update computation of how much all possible completions match */
447 if (all_flag || NILP (bestmatch))
449 Lisp_Object name = Qnil;
450 struct gcpro ngcpro1;
452 /* This is a possible completion */
453 name = make_string (d_name, len);
454 if (directoryp) /* Completion is a directory; end it with '/' */
455 name = Ffile_name_as_directory (name);
458 bestmatch = Fcons (name, bestmatch);
463 bestmatchsize = XSTRING_CHAR_LENGTH (name);
469 Charcount compare = min (bestmatchsize, cclen);
470 Bufbyte *p1 = XSTRING_DATA (bestmatch);
471 Bufbyte *p2 = d_name;
472 Charcount matchsize = scmp (p1, p2, compare);
476 if (completion_ignore_case)
478 /* If this is an exact match except for case,
479 use it as the best match rather than one that is not
480 an exact match. This way, we get the case pattern
481 of the actual match. */
482 if ((matchsize == cclen
483 && matchsize + !!directoryp
484 < XSTRING_CHAR_LENGTH (bestmatch))
486 /* If there is no exact match ignoring case,
487 prefer a match that does not change the case
489 (((matchsize == cclen)
491 (matchsize + !!directoryp
492 == XSTRING_CHAR_LENGTH (bestmatch)))
493 /* If there is more than one exact match aside from
494 case, and one of them is exact including case,
496 && 0 > scmp_1 (p2, XSTRING_DATA (file),
498 && 0 <= scmp_1 (p1, XSTRING_DATA (file),
499 file_name_length, 0)))
501 bestmatch = make_string (d_name, len);
503 bestmatch = Ffile_name_as_directory (bestmatch);
507 /* If this dirname all matches,
508 see if implicit following slash does too. */
510 && compare == matchsize
511 && bestmatchsize > matchsize
512 && IS_ANY_SEP (charptr_emchar_n (p1, matchsize)))
514 bestmatchsize = matchsize;
518 free_opaque_ptr (XCAR (locative));
519 XCAR (locative) = Qnil;
522 unbind_to (speccount, Qnil);
526 if (all_flag || NILP (bestmatch))
528 if (matchcount == 1 && bestmatchsize == file_name_length)
530 return Fsubstring (bestmatch, Qzero, make_int (bestmatchsize));
534 static Lisp_Object user_name_completion (Lisp_Object user,
538 DEFUN ("user-name-completion", Fuser_name_completion, 1, 1, 0, /*
539 Complete user name USER.
541 Returns the longest string common to all user names that start
542 with USER. If there is only one and USER matches it exactly,
543 returns t. Returns nil if there is no user name starting with USER.
547 return user_name_completion (user, 0, NULL);
550 DEFUN ("user-name-completion-1", Fuser_name_completion_1, 1, 1, 0, /*
551 Complete user name USER.
553 This function is identical to `user-name-completion', except that
554 the cons of the completion and an indication of whether the
555 completion was unique is returned.
557 The car of the returned value is the longest string common to all
558 user names that start with USER. If there is only one and USER
559 matches it exactly, the car is t. The car is nil if there is no
560 user name starting with USER. The cdr of the result is non-nil
561 if and only if the completion returned in the car was unique.
566 Lisp_Object completed;
568 completed = user_name_completion (user, 0, &uniq);
569 return Fcons (completed, uniq ? Qt : Qnil);
572 DEFUN ("user-name-all-completions", Fuser_name_all_completions, 1, 1, 0, /*
573 Return a list of all completions of user name USER.
574 These are all user names which begin with USER.
578 return user_name_completion (user, 1, NULL);
582 user_name_completion_unwind (Lisp_Object locative)
584 Lisp_Object obj1 = XCAR (locative);
585 Lisp_Object obj2 = XCDR (locative);
590 if (!NILP (obj1) && !NILP (obj2))
592 /* clean up if interrupted building cache */
593 cache = *(char ***)get_opaque_ptr (obj1);
594 clen = *(int *)get_opaque_ptr (obj2);
595 free_opaque_ptr (obj1);
596 free_opaque_ptr (obj2);
597 for (i = 0; i < clen; i++)
602 free_cons (XCONS (locative));
608 static char **user_cache;
609 static int user_cache_len;
610 static int user_cache_max;
611 static long user_cache_time;
613 #define USER_CACHE_REBUILD (24*60*60) /* 1 day, in seconds */
616 user_name_completion (Lisp_Object user, int all_flag, int *uniq)
618 /* This function can GC */
621 Lisp_Object bestmatch = Qnil;
622 Charcount bestmatchsize = 0;
623 int speccount = specpdl_depth ();
626 Charcount user_name_length;
627 Lisp_Object locative;
629 struct gcpro gcpro1, gcpro2;
631 GCPRO2 (user, bestmatch);
635 user_name_length = XSTRING_CHAR_LENGTH (user);
637 /* Cache user name lookups because it tends to be quite slow.
638 * Rebuild the cache occasionally to catch changes */
641 EMACS_SECS (t) - user_cache_time > USER_CACHE_REBUILD)
643 for (i = 0; i < user_cache_len; i++)
644 free (user_cache[i]);
651 if (user_cache == NULL || user_cache_max <= 0)
655 cache = (char **) malloc (cmax*sizeof (char *));
658 locative = noseeum_cons (Qnil, Qnil);
659 XCAR (locative) = make_opaque_ptr ((void *) &cache);
660 XCDR (locative) = make_opaque_ptr ((void *) &clen);
661 record_unwind_protect (user_name_completion_unwind, locative);
662 /* #### may need to slow down interrupts around call to getpwent
663 * below. at least the call to getpwnam in Fuser_full_name
664 * is documented as needing it on irix. */
665 while ((pw = getpwent ()))
670 cache = (char **) realloc (cache, cmax*sizeof (char *));
675 cache[clen++] = strdup (pw->pw_name);
677 free_opaque_ptr (XCAR (locative));
678 free_opaque_ptr (XCDR (locative));
679 XCAR (locative) = Qnil;
680 XCDR (locative) = Qnil;
682 unbind_to (speccount, Qnil); /* free locative cons, endpwent() */
684 user_cache_max = cmax;
685 user_cache_len = clen;
687 user_cache_time = EMACS_SECS (t);
690 for (i = 0; i < user_cache_len; i++)
693 /* scmp() works in chars, not bytes, so we have to compute this: */
697 d_name = (Bufbyte *) user_cache[i];
698 len = strlen (d_name);
699 cclen = bytecount_to_charcount (d_name, len);
703 if (cclen < user_name_length ||
704 0 <= scmp (d_name, XSTRING_DATA (user), user_name_length))
707 matchcount++; /* count matching completions */
709 if (all_flag || NILP (bestmatch))
711 Lisp_Object name = Qnil;
712 struct gcpro ngcpro1;
714 /* This is a possible completion */
715 name = make_string (d_name, len);
718 bestmatch = Fcons (name, bestmatch);
723 bestmatchsize = XSTRING_CHAR_LENGTH (name);
729 Charcount compare = min (bestmatchsize, cclen);
730 Bufbyte *p1 = XSTRING_DATA (bestmatch);
731 Bufbyte *p2 = d_name;
732 Charcount matchsize = scmp (p1, p2, compare);
736 if (completion_ignore_case)
738 /* If this is an exact match except for case,
739 use it as the best match rather than one that is not
740 an exact match. This way, we get the case pattern
741 of the actual match. */
742 if ((matchsize == cclen
743 && matchsize < XSTRING_CHAR_LENGTH (bestmatch))
745 /* If there is no exact match ignoring case,
746 prefer a match that does not change the case
748 (((matchsize == cclen)
750 (matchsize == XSTRING_CHAR_LENGTH (bestmatch)))
751 /* If there is more than one exact match aside from
752 case, and one of them is exact including case,
754 && 0 > scmp_1 (p2, XSTRING_DATA (user),
756 && 0 <= scmp_1 (p1, XSTRING_DATA (user),
757 user_name_length, 0)))
759 bestmatch = make_string (d_name, len);
763 bestmatchsize = matchsize;
770 *uniq = (matchcount == 1);
772 if (all_flag || NILP (bestmatch))
774 if (matchcount == 1 && bestmatchsize == user_name_length)
776 return Fsubstring (bestmatch, Qzero, make_int (bestmatchsize));
781 make_directory_hash_table (CONST char *path)
784 Lisp_Object hash = make_lisp_hashtable (100, HASHTABLE_NONWEAK,
786 if ((d = opendir (path)))
790 while ((dp = readdir (d)))
792 Bytecount len = NAMLEN (dp);
793 if (DIRENTRY_NONEMPTY (dp))
794 Fputhash (make_ext_string ((Bufbyte *) dp->d_name, len,
795 FORMAT_FILENAME), Qt, hash);
803 wasteful_word_to_lisp (unsigned int item)
805 /* Compatibility: in other versions, file-attributes returns a LIST
806 of two 16 bit integers... */
807 Lisp_Object cons = word_to_lisp (item);
808 XCDR (cons) = Fcons (XCDR (cons), Qnil);
812 DEFUN ("file-attributes", Ffile_attributes, 1, 1, 0, /*
813 Return a list of attributes of file FILENAME.
814 Value is nil if specified file cannot be opened.
815 Otherwise, list elements are:
816 0. t for directory, string (name linked to) for symbolic link, or nil.
817 1. Number of links to file.
820 4. Last access time, as a list of two integers.
821 First integer has high-order 16 bits of time, second has low 16 bits.
822 5. Last modification time, likewise.
823 6. Last status change time, likewise.
824 7. Size in bytes. (-1, if number is out of range).
825 8. File modes, as a string of ten letters or dashes as in ls -l.
826 9. t iff file's gid would change if file were deleted and recreated.
830 If file does not exist, returns nil.
834 /* This function can GC. GC checked 1997.06.04. */
835 Lisp_Object values[12];
836 Lisp_Object dirname = Qnil;
840 struct gcpro gcpro1, gcpro2;
842 GCPRO2 (filename, dirname);
843 filename = Fexpand_file_name (filename, Qnil);
845 /* If the file name has special constructs in it,
846 call the corresponding file handler. */
847 handler = Ffind_file_name_handler (filename, Qfile_attributes);
851 return call2 (handler, Qfile_attributes, filename);
854 if (lstat ((char *) XSTRING_DATA (filename), &s) < 0)
861 dirname = Ffile_name_directory (filename);
866 char *tmpnam = (char *) XSTRING_DATA (Ffile_name_nondirectory (filename));
867 int l = strlen (tmpnam);
870 && S_ISREG (s.st_mode)
871 && (stricmp (&tmpnam[l - 4], ".com") == 0 ||
872 stricmp (&tmpnam[l - 4], ".exe") == 0 ||
873 stricmp (&tmpnam[l - 4], ".bat") == 0))
875 s.st_mode |= S_IEXEC;
880 switch (s.st_mode & S_IFMT)
890 values[0] = Ffile_symlink_p (filename);
894 values[1] = make_int (s.st_nlink);
895 values[2] = make_int (s.st_uid);
896 values[3] = make_int (s.st_gid);
897 values[4] = wasteful_word_to_lisp (s.st_atime);
898 values[5] = wasteful_word_to_lisp (s.st_mtime);
899 values[6] = wasteful_word_to_lisp (s.st_ctime);
900 values[7] = make_int ((EMACS_INT) s.st_size);
901 /* If the size is out of range, give back -1. */
902 /* #### Fix when Emacs gets bignums! */
903 if (XINT (values[7]) != s.st_size)
904 values[7] = make_int (-1);
905 filemodestring (&s, modes);
906 values[8] = make_string ((Bufbyte *) modes, 10);
907 #if defined (BSD4_2) || defined (BSD4_3) /* file gid will be dir gid */
911 if (!NILP (dirname) && stat ((char *) XSTRING_DATA (dirname), &sdir) == 0)
912 values[9] = (sdir.st_gid != s.st_gid) ? Qt : Qnil;
913 else /* if we can't tell, assume worst */
916 #else /* file gid will be egid */
917 values[9] = (s.st_gid != getegid ()) ? Qt : Qnil;
918 #endif /* BSD4_2 or BSD4_3 */
919 values[10] = make_int (s.st_ino);
920 values[11] = make_int (s.st_dev);
922 return Flist (countof (values), values);
926 /************************************************************************/
928 /************************************************************************/
933 defsymbol (&Qdirectory_files, "directory-files");
934 defsymbol (&Qfile_name_completion, "file-name-completion");
935 defsymbol (&Qfile_name_all_completions, "file-name-all-completions");
936 defsymbol (&Qfile_attributes, "file-attributes");
938 DEFSUBR (Fdirectory_files);
939 DEFSUBR (Ffile_name_completion);
940 DEFSUBR (Ffile_name_all_completions);
941 DEFSUBR (Fuser_name_completion);
942 DEFSUBR (Fuser_name_completion_1);
943 DEFSUBR (Fuser_name_all_completions);
944 DEFSUBR (Ffile_attributes);
950 DEFVAR_LISP ("completion-ignored-extensions", &Vcompletion_ignored_extensions /*
951 *Completion ignores filenames ending in any string in this list.
952 This variable does not affect lists of possible completions,
953 but does affect the commands that actually do completions.
954 It is used by the functions `file-name-completion' and
955 `file-name-all-completions'.
957 Vcompletion_ignored_extensions = Qnil;