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