src/dired.c

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