src/dired.c

   1 /* Lisp functions for making directory listings.
   2    Copyright (C) 1985, 1986, 1993, 1994 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Emacs.
   5
   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 1, or (at your option)
   9 any later version.
  10
  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.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Emacs; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20
  21 #include <config.h>
  22
  23 #include <stdio.h>
  24 #include <sys/types.h>
  25 #include <sys/stat.h>
  26
  27 #ifdef VMS
  28 #include <string.h>
  29 #include <rms.h>
  30 #include <rmsdef.h>
  31 #endif
  32
  33 /* The d_nameln member of a struct dirent includes the '\0' character
  34    on some systems, but not on others.  What's worse, you can't tell
  35    at compile-time which one it will be, since it really depends on
  36    the sort of system providing the filesystem you're reading from,
  37    not the system you are running on.  Paul Eggert
  38    <eggert@bi.twinsun.com> says this occurs when Emacs is running on a
  39    SunOS 4.1.2 host, reading a directory that is remote-mounted from a
  40    Solaris 2.1 host and is in a native Solaris 2.1 filesystem.
  41
  42    Since applying strlen to the name always works, we'll just do that.  */
  43 #define NAMLEN(p) strlen (p->d_name)
  44
  45 #ifdef SYSV_SYSTEM_DIR
  46
  47 #include <dirent.h>
  48 #define DIRENTRY struct dirent
  49
  50 #else /* not SYSV_SYSTEM_DIR */
  51
  52 #ifdef NONSYSTEM_DIR_LIBRARY
  53 #include "ndir.h"
  54 #else /* not NONSYSTEM_DIR_LIBRARY */
  55 #ifdef MSDOS
  56 #include <dirent.h>
  57 #else
  58 #include <sys/dir.h>
  59 #endif
  60 #endif /* not NONSYSTEM_DIR_LIBRARY */
  61
  62 #ifndef MSDOS
  63 #define DIRENTRY struct direct
  64
  65 extern DIR *opendir ();
  66 extern struct direct *readdir ();
  67
  68 #endif /* not MSDOS */
  69 #endif /* not SYSV_SYSTEM_DIR */
  70
  71 #ifdef MSDOS
  72 #define DIRENTRY_NONEMPTY(p) ((p)->d_name[0] != 0)
  73 #else
  74 #define DIRENTRY_NONEMPTY(p) ((p)->d_ino)
  75 #endif
  76
  77 #include "lisp.h"
  78 #include "buffer.h"
  79 #include "commands.h"
  80
  81 #include "regex.h"
  82
  83 /* A search buffer, with a fastmap allocated and ready to go.  */
  84 extern struct re_pattern_buffer searchbuf;
  85
  86 #define min(a, b) ((a) < (b) ? (a) : (b))
  87
  88 /* if system does not have symbolic links, it does not have lstat.
  89    In that case, use ordinary stat instead.  */
  90
  91 #ifndef S_IFLNK
  92 #define lstat stat
  93 #endif
  94
  95 extern int completion_ignore_case;
  96 extern Lisp_Object Vcompletion_regexp_list;
  97
  98 Lisp_Object Vcompletion_ignored_extensions;
  99 Lisp_Object Qcompletion_ignored_extensions;
 100 Lisp_Object Qcompletion_ignore_case;
 101 Lisp_Object Qdirectory_files;
 102 Lisp_Object Qfile_name_completion;
 103 Lisp_Object Qfile_name_all_completions;
 104 Lisp_Object Qfile_attributes;
 105 \f
 106 DEFUN ("directory-files", Fdirectory_files, Sdirectory_files, 1, 4, 0,
 107   "Return a list of names of files in DIRECTORY.\n\
 108 There are three optional arguments:\n\
 109 If FULL is non-nil, absolute pathnames of the files are returned.\n\
 110 If MATCH is non-nil, only pathnames containing that regexp are returned.\n\
 111 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.\n\
 112  NOSORT is useful if you plan to sort the result yourself.")
 113   (dirname, full, match, nosort)
 114      Lisp_Object dirname, full, match, nosort;
 115 {
 116   DIR *d;
 117   int length;
 118   Lisp_Object list, name, dirfilename;
 119   Lisp_Object handler;
 120
 121   /* If the file name has special constructs in it,
 122      call the corresponding file handler.  */
 123   handler = Ffind_file_name_handler (dirname, Qdirectory_files);
 124   if (!NILP (handler))
 125     {
 126       Lisp_Object args[6];
 127
 128       args[0] = handler;
 129       args[1] = Qdirectory_files;
 130       args[2] = dirname;
 131       args[3] = full;
 132       args[4] = match;
 133       args[5] = nosort;
 134       return Ffuncall (6, args);
 135     }
 136
 137   {
 138     struct gcpro gcpro1, gcpro2;
 139
 140     /* Because of file name handlers, these functions might call
 141      Ffuncall, and cause a GC.  */
 142     GCPRO1 (match);
 143     dirname = Fexpand_file_name (dirname, Qnil);
 144     UNGCPRO;
 145     GCPRO2 (match, dirname);
 146     dirfilename = Fdirectory_file_name (dirname);
 147     UNGCPRO;
 148   }
 149
 150   if (!NILP (match))
 151     {
 152       CHECK_STRING (match, 3);
 153
 154       /* MATCH might be a flawed regular expression.  Rather than
 155          catching and signalling our own errors, we just call
 156          compile_pattern to do the work for us.  */
 157 #ifdef VMS
 158       compile_pattern (match, &searchbuf, 0,
 159                        buffer_defaults.downcase_table->contents);
 160 #else
 161       compile_pattern (match, &searchbuf, 0, 0);
 162 #endif
 163     }
 164
 165   /* Now searchbuf is the compiled form of MATCH; don't call anything
 166      which might compile a new regexp until we're done with the loop!  */
 167
 168   /* Do this opendir after anything which might signal an error; if
 169      an error is signalled while the directory stream is open, we
 170      have to make sure it gets closed, and setting up an
 171      unwind_protect to do so would be a pain.  */
 172   d = opendir (XSTRING (dirfilename)->data);
 173   if (! d)
 174     report_file_error ("Opening directory", Fcons (dirname, Qnil));
 175
 176   list = Qnil;
 177   length = XSTRING (dirname)->size;
 178
 179   /* Loop reading blocks */
 180   while (1)
 181     {
 182       DIRENTRY *dp = readdir (d);
 183       int len;
 184
 185       if (!dp) break;
 186       len = NAMLEN (dp);
 187       if (DIRENTRY_NONEMPTY (dp))
 188         {
 189           if (NILP (match)
 190               || (0 <= re_search (&searchbuf, dp->d_name, len, 0, len, 0)))
 191             {
 192               if (!NILP (full))
 193                 {
 194                   int index = XSTRING (dirname)->size;
 195                   int total = len + index;
 196 #ifndef VMS
 197                   if (length == 0
 198                       || XSTRING (dirname)->data[length - 1] != '/')
 199                     total++;
 200 #endif /* VMS */
 201
 202                   name = make_uninit_string (total);
 203                   bcopy (XSTRING (dirname)->data, XSTRING (name)->data,
 204                          index);
 205 #ifndef VMS
 206                   if (length == 0
 207                       || XSTRING (dirname)->data[length - 1] != '/')
 208                     XSTRING (name)->data[index++] = '/';
 209 #endif /* VMS */
 210                   bcopy (dp->d_name, XSTRING (name)->data + index, len);
 211                 }
 212               else
 213                 name = make_string (dp->d_name, len);
 214               list = Fcons (name, list);
 215             }
 216         }
 217     }
 218   closedir (d);
 219   if (!NILP (nosort))
 220     return list;
 221   return Fsort (Fnreverse (list), Qstring_lessp);
 222 }
 223 \f
 224 Lisp_Object file_name_completion ();
 225
 226 DEFUN ("file-name-completion", Ffile_name_completion, Sfile_name_completion,
 227   2, 2, 0,
 228   "Complete file name FILE in directory DIR.\n\
 229 Returns the longest string\n\
 230 common to all filenames in DIR that start with FILE.\n\
 231 If there is only one and FILE matches it exactly, returns t.\n\
 232 Returns nil if DIR contains no name starting with FILE.")
 233   (file, dirname)
 234      Lisp_Object file, dirname;
 235 {
 236   Lisp_Object handler;
 237   /* Don't waste time trying to complete a null string.
 238      Besides, this case happens when user is being asked for
 239      a directory name and has supplied one ending in a /.
 240      We would not want to add anything in that case
 241      even if there are some unique characters in that directory.  */
 242   if (STRINGP (file) && XSTRING (file)->size == 0)
 243     return file;
 244
 245   /* If the file name has special constructs in it,
 246      call the corresponding file handler.  */
 247   handler = Ffind_file_name_handler (dirname, Qfile_name_completion);
 248   if (!NILP (handler))
 249     return call3 (handler, Qfile_name_completion, file, dirname);
 250
 251   return file_name_completion (file, dirname, 0, 0);
 252 }
 253
 254 DEFUN ("file-name-all-completions", Ffile_name_all_completions,
 255   Sfile_name_all_completions, 2, 2, 0,
 256   "Return a list of all completions of file name FILE in directory DIR.\n\
 257 These are all file names in directory DIR which begin with FILE.")
 258   (file, dirname)
 259      Lisp_Object file, dirname;
 260 {
 261   Lisp_Object handler;
 262
 263   /* If the file name has special constructs in it,
 264      call the corresponding file handler.  */
 265   handler = Ffind_file_name_handler (dirname, Qfile_name_all_completions);
 266   if (!NILP (handler))
 267     return call3 (handler, Qfile_name_all_completions, file, dirname);
 268
 269   return file_name_completion (file, dirname, 1, 0);
 270 }
 271
 272 Lisp_Object
 273 file_name_completion (file, dirname, all_flag, ver_flag)
 274      Lisp_Object file, dirname;
 275      int all_flag, ver_flag;
 276 {
 277   DIR *d;
 278   DIRENTRY *dp;
 279   int bestmatchsize, skip;
 280   register int compare, matchsize;
 281   unsigned char *p1, *p2;
 282   int matchcount = 0;
 283   Lisp_Object bestmatch, tem, elt, name;
 284   struct stat st;
 285   int directoryp;
 286   int passcount;
 287   int count = specpdl_ptr - specpdl;
 288   struct gcpro gcpro1, gcpro2, gcpro3;
 289
 290 #ifdef VMS
 291   extern DIRENTRY * readdirver ();
 292
 293   DIRENTRY *((* readfunc) ());
 294
 295   /* Filename completion on VMS ignores case, since VMS filesys does.  */
 296   specbind (Qcompletion_ignore_case, Qt);
 297
 298   readfunc = readdir;
 299   if (ver_flag)
 300     readfunc = readdirver;
 301   file = Fupcase (file);
 302 #else  /* not VMS */
 303   CHECK_STRING (file, 0);
 304 #endif /* not VMS */
 305
 306 #ifdef FILE_SYSTEM_CASE
 307   file = FILE_SYSTEM_CASE (file);
 308 #endif
 309   bestmatch = Qnil;
 310   GCPRO3 (file, dirname, bestmatch);
 311   dirname = Fexpand_file_name (dirname, Qnil);
 312
 313   /* With passcount = 0, ignore files that end in an ignored extension.
 314      If nothing found then try again with passcount = 1, don't ignore them.
 315      If looking for all completions, start with passcount = 1,
 316      so always take even the ignored ones.
 317
 318      ** It would not actually be helpful to the user to ignore any possible
 319      completions when making a list of them.**  */
 320
 321   for (passcount = !!all_flag; NILP (bestmatch) && passcount < 2; passcount++)
 322     {
 323       if (!(d = opendir (XSTRING (Fdirectory_file_name (dirname))->data)))
 324         report_file_error ("Opening directory", Fcons (dirname, Qnil));
 325
 326       /* Loop reading blocks */
 327       /* (att3b compiler bug requires do a null comparison this way) */
 328       while (1)
 329         {
 330           DIRENTRY *dp;
 331           int len;
 332
 333 #ifdef VMS
 334           dp = (*readfunc) (d);
 335 #else
 336           dp = readdir (d);
 337 #endif
 338           if (!dp) break;
 339
 340           len = NAMLEN (dp);
 341
 342           if (!NILP (Vquit_flag) && NILP (Vinhibit_quit))
 343             goto quit;
 344           if (! DIRENTRY_NONEMPTY (dp)
 345               || len < XSTRING (file)->size
 346               || 0 <= scmp (dp->d_name, XSTRING (file)->data,
 347                             XSTRING (file)->size))
 348             continue;
 349
 350           if (file_name_completion_stat (dirname, dp, &st) < 0)
 351             continue;
 352
 353           directoryp = ((st.st_mode & S_IFMT) == S_IFDIR);
 354           tem = Qnil;
 355           if (!directoryp)
 356             {
 357               /* Compare extensions-to-be-ignored against end of this file name */
 358               /* if name is not an exact match against specified string */
 359               if (!passcount && len > XSTRING (file)->size)
 360                 /* and exit this for loop if a match is found */
 361                 for (tem = Vcompletion_ignored_extensions;
 362                      CONSP (tem); tem = XCONS (tem)->cdr)
 363                   {
 364                     elt = XCONS (tem)->car;
 365                     if (!STRINGP (elt)) continue;
 366                     skip = len - XSTRING (elt)->size;
 367                     if (skip < 0) continue;
 368
 369                     if (0 <= scmp (dp->d_name + skip,
 370                                    XSTRING (elt)->data,
 371                                    XSTRING (elt)->size))
 372                       continue;
 373                     break;
 374                   }
 375             }
 376
 377           /* If an ignored-extensions match was found,
 378              don't process this name as a completion.  */
 379           if (!passcount && CONSP (tem))
 380             continue;
 381
 382           if (!passcount)
 383             {
 384               Lisp_Object regexps;
 385               Lisp_Object zero;
 386               XFASTINT (zero) = 0;
 387
 388               /* Ignore this element if it fails to match all the regexps.  */
 389               for (regexps = Vcompletion_regexp_list; CONSP (regexps);
 390                    regexps = XCONS (regexps)->cdr)
 391                 {
 392                   tem = Fstring_match (XCONS (regexps)->car, elt, zero);
 393                   if (NILP (tem))
 394                     break;
 395                 }
 396               if (CONSP (regexps))
 397                 continue;
 398             }
 399
 400           /* Update computation of how much all possible completions match */
 401
 402           matchcount++;
 403
 404           if (all_flag || NILP (bestmatch))
 405             {
 406               /* This is a possible completion */
 407               if (directoryp)
 408                 {
 409                   /* This completion is a directory; make it end with '/' */
 410                   name = Ffile_name_as_directory (make_string (dp->d_name, len));
 411                 }
 412               else
 413                 name = make_string (dp->d_name, len);
 414               if (all_flag)
 415                 {
 416                   bestmatch = Fcons (name, bestmatch);
 417                 }
 418               else
 419                 {
 420                   bestmatch = name;
 421                   bestmatchsize = XSTRING (name)->size;
 422                 }
 423             }
 424           else
 425             {
 426               compare = min (bestmatchsize, len);
 427               p1 = XSTRING (bestmatch)->data;
 428               p2 = (unsigned char *) dp->d_name;
 429               matchsize = scmp(p1, p2, compare);
 430               if (matchsize < 0)
 431                 matchsize = compare;
 432               if (completion_ignore_case)
 433                 {
 434                   /* If this is an exact match except for case,
 435                      use it as the best match rather than one that is not
 436                      an exact match.  This way, we get the case pattern
 437                      of the actual match.  */
 438                   if ((matchsize == len
 439                        && matchsize + !!directoryp
 440                           < XSTRING (bestmatch)->size)
 441                       ||
 442                       /* If there is no exact match ignoring case,
 443                          prefer a match that does not change the case
 444                          of the input.  */
 445                       (((matchsize == len)
 446                         ==
 447                         (matchsize + !!directoryp
 448                          == XSTRING (bestmatch)->size))
 449                        /* If there is more than one exact match aside from
 450                           case, and one of them is exact including case,
 451                           prefer that one.  */
 452                        && !bcmp (p2, XSTRING (file)->data, XSTRING (file)->size)
 453                        && bcmp (p1, XSTRING (file)->data, XSTRING (file)->size)))
 454                     {
 455                       bestmatch = make_string (dp->d_name, len);
 456                       if (directoryp)
 457                         bestmatch = Ffile_name_as_directory (bestmatch);
 458                     }
 459                 }
 460
 461               /* If this dirname all matches, see if implicit following
 462                  slash does too.  */
 463               if (directoryp
 464                   && compare == matchsize
 465                   && bestmatchsize > matchsize
 466                   && p1[matchsize] == '/')
 467                 matchsize++;
 468               bestmatchsize = matchsize;
 469             }
 470         }
 471       closedir (d);
 472     }
 473
 474   UNGCPRO;
 475   bestmatch = unbind_to (count, bestmatch);
 476
 477   if (all_flag || NILP (bestmatch))
 478     return bestmatch;
 479   if (matchcount == 1 && bestmatchsize == XSTRING (file)->size)
 480     return Qt;
 481   return Fsubstring (bestmatch, make_number (0), make_number (bestmatchsize));
 482  quit:
 483   if (d) closedir (d);
 484   Vquit_flag = Qnil;
 485   return Fsignal (Qquit, Qnil);
 486 }
 487
 488 file_name_completion_stat (dirname, dp, st_addr)
 489      Lisp_Object dirname;
 490      DIRENTRY *dp;
 491      struct stat *st_addr;
 492 {
 493   int len = NAMLEN (dp);
 494   int pos = XSTRING (dirname)->size;
 495   int value;
 496   char *fullname = (char *) alloca (len + pos + 2);
 497
 498   bcopy (XSTRING (dirname)->data, fullname, pos);
 499 #ifndef VMS
 500   if (fullname[pos - 1] != '/')
 501     fullname[pos++] = '/';
 502 #endif
 503
 504   bcopy (dp->d_name, fullname + pos, len);
 505   fullname[pos + len] = 0;
 506
 507 #ifdef S_IFLNK
 508   /* We want to return success if a link points to a nonexistent file,
 509      but we want to return the status for what the link points to,
 510      in case it is a directory.  */
 511   value = lstat (fullname, st_addr);
 512   stat (fullname, st_addr);
 513   return value;
 514 #else
 515   return stat (fullname, st_addr);
 516 #endif
 517 }
 518 \f
 519 #ifdef VMS
 520
 521 DEFUN ("file-name-all-versions", Ffile_name_all_versions,
 522   Sfile_name_all_versions, 2, 2, 0,
 523   "Return a list of all versions of file name FILE in directory DIR.")
 524   (file, dirname)
 525      Lisp_Object file, dirname;
 526 {
 527   return file_name_completion (file, dirname, 1, 1);
 528 }
 529
 530 DEFUN ("file-version-limit", Ffile_version_limit, Sfile_version_limit, 1, 1, 0,
 531   "Return the maximum number of versions allowed for FILE.\n\
 532 Returns nil if the file cannot be opened or if there is no version limit.")
 533   (filename)
 534      Lisp_Object filename;
 535 {
 536   Lisp_Object retval;
 537   struct FAB    fab;
 538   struct RAB    rab;
 539   struct XABFHC xabfhc;
 540   int status;
 541
 542   filename = Fexpand_file_name (filename, Qnil);
 543   fab      = cc$rms_fab;
 544   xabfhc   = cc$rms_xabfhc;
 545   fab.fab$l_fna = XSTRING (filename)->data;
 546   fab.fab$b_fns = strlen (fab.fab$l_fna);
 547   fab.fab$l_xab = (char *) &xabfhc;
 548   status = sys$open (&fab, 0, 0);
 549   if (status != RMS$_NORMAL)    /* Probably non-existent file */
 550     return Qnil;
 551   sys$close (&fab, 0, 0);
 552   if (xabfhc.xab$w_verlimit == 32767)
 553     return Qnil;                /* No version limit */
 554   else
 555     return make_number (xabfhc.xab$w_verlimit);
 556 }
 557
 558 #endif /* VMS */
 559 \f
 560 Lisp_Object
 561 make_time (time)
 562      int time;
 563 {
 564   return Fcons (make_number (time >> 16),
 565                 Fcons (make_number (time & 0177777), Qnil));
 566 }
 567
 568 DEFUN ("file-attributes", Ffile_attributes, Sfile_attributes, 1, 1, 0,
 569   "Return a list of attributes of file FILENAME.\n\
 570 Value is nil if specified file cannot be opened.\n\
 571 Otherwise, list elements are:\n\
 572  0. t for directory, string (name linked to) for symbolic link, or nil.\n\
 573  1. Number of links to file.\n\
 574  2. File uid.\n\
 575  3. File gid.\n\
 576  4. Last access time, as a list of two integers.\n\
 577   First integer has high-order 16 bits of time, second has low 16 bits.\n\
 578  5. Last modification time, likewise.\n\
 579  6. Last status change time, likewise.\n\
 580  7. Size in bytes (-1, if number is out of range).\n\
 581  8. File modes, as a string of ten letters or dashes as in ls -l.\n\
 582  9. t iff file's gid would change if file were deleted and recreated.\n\
 583 10. inode number.\n\
 584 11. Device number.\n\
 585 \n\
 586 If file does not exist, returns nil.")
 587   (filename)
 588      Lisp_Object filename;
 589 {
 590   Lisp_Object values[12];
 591   Lisp_Object dirname;
 592   struct stat s;
 593   struct stat sdir;
 594   char modes[10];
 595   Lisp_Object handler;
 596
 597   filename = Fexpand_file_name (filename, Qnil);
 598
 599   /* If the file name has special constructs in it,
 600      call the corresponding file handler.  */
 601   handler = Ffind_file_name_handler (filename, Qfile_attributes);
 602   if (!NILP (handler))
 603     return call2 (handler, Qfile_attributes, filename);
 604
 605   if (lstat (XSTRING (filename)->data, &s) < 0)
 606     return Qnil;
 607
 608 #ifdef MSDOS
 609   {
 610     char *tmpnam = XSTRING (Ffile_name_nondirectory (filename))->data;
 611     int l = strlen (tmpnam);
 612
 613     if (l >= 5
 614         && S_ISREG (s.st_mode)
 615         && (stricmp (&tmpnam[l - 4], ".com") == 0
 616             || stricmp (&tmpnam[l - 4], ".exe") == 0
 617             || stricmp (&tmpnam[l - 4], ".bat") == 0))
 618       {
 619         s.st_mode |= S_IEXEC;
 620       }
 621   }
 622 #endif /* MSDOS */
 623
 624   switch (s.st_mode & S_IFMT)
 625     {
 626     default:
 627       values[0] = Qnil; break;
 628     case S_IFDIR:
 629       values[0] = Qt; break;
 630 #ifdef S_IFLNK
 631     case S_IFLNK:
 632       values[0] = Ffile_symlink_p (filename); break;
 633 #endif
 634     }
 635   values[1] = make_number (s.st_nlink);
 636   values[2] = make_number (s.st_uid);
 637   values[3] = make_number (s.st_gid);
 638   values[4] = make_time (s.st_atime);
 639   values[5] = make_time (s.st_mtime);
 640   values[6] = make_time (s.st_ctime);
 641   values[7] = make_number ((int) s.st_size);
 642   /* If the size is out of range, give back -1.  */
 643   if (XINT (values[7]) != s.st_size)
 644     XSETINT (values[7], -1);
 645   filemodestring (&s, modes);
 646   values[8] = make_string (modes, 10);
 647 #ifdef BSD4_3 /* Gross kludge to avoid lack of "#if defined(...)" in VMS */
 648 #define BSD4_2 /* A new meaning to the term `backwards compatibility' */
 649 #endif
 650 #ifdef BSD4_2                   /* file gid will be dir gid */
 651   dirname = Ffile_name_directory (filename);
 652   if (! NILP (dirname) && stat (XSTRING (dirname)->data, &sdir) == 0)
 653     values[9] = (sdir.st_gid != s.st_gid) ? Qt : Qnil;
 654   else                                  /* if we can't tell, assume worst */
 655     values[9] = Qt;
 656 #else                                   /* file gid will be egid */
 657   values[9] = (s.st_gid != getegid ()) ? Qt : Qnil;
 658 #endif  /* BSD4_2 (or BSD4_3) */
 659 #ifdef BSD4_3
 660 #undef BSD4_2 /* ok, you can look again without throwing up */
 661 #endif
 662   values[10] = make_number (s.st_ino);
 663   values[11] = make_number (s.st_dev);
 664   return Flist (sizeof(values) / sizeof(values[0]), values);
 665 }
 666 \f
 667 syms_of_dired ()
 668 {
 669   Qdirectory_files = intern ("directory-files");
 670   Qfile_name_completion = intern ("file-name-completion");
 671   Qfile_name_all_completions = intern ("file-name-all-completions");
 672   Qfile_attributes = intern ("file-attributes");
 673
 674   defsubr (&Sdirectory_files);
 675   defsubr (&Sfile_name_completion);
 676 #ifdef VMS
 677   defsubr (&Sfile_name_all_versions);
 678   defsubr (&Sfile_version_limit);
 679 #endif /* VMS */
 680   defsubr (&Sfile_name_all_completions);
 681   defsubr (&Sfile_attributes);
 682
 683 #ifdef VMS
 684   Qcompletion_ignore_case = intern ("completion-ignore-case");
 685   staticpro (&Qcompletion_ignore_case);
 686 #endif /* VMS */
 687
 688   Qcompletion_ignored_extensions = intern ("completion-ignored-extensions");
 689   staticpro (&Qcompletion_ignored_extensions);
 690   DEFVAR_LISP ("completion-ignored-extensions", &Vcompletion_ignored_extensions,
 691     "*Completion ignores filenames ending in any string in this list.\n\
 692 This variable does not affect lists of possible completions,\n\
 693 but does affect the commands that actually do completions.");
 694   Vcompletion_ignored_extensions = Qnil;
 695 }