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 2, 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 /* Returns a search buffer, with a fastmap allocated and ready to go.  */
  84 extern struct re_pattern_buffer *compile_pattern ();
  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 dirnamelen;
 117   Lisp_Object list, name, dirfilename;
 118   Lisp_Object handler;
 119   struct re_pattern_buffer *bufp;
 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 signaling our own errors, we just call
 156          compile_pattern to do the work for us.  */
 157 #ifdef VMS
 158       bufp = compile_pattern (match, 0,
 159                               buffer_defaults.downcase_table->contents, 0);
 160 #else
 161       bufp = compile_pattern (match, 0, 0, 0);
 162 #endif
 163     }
 164
 165   /* Now *bufp 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 signaled 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   dirnamelen = 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 (bufp, dp->d_name, len, 0, len, 0)))
 191             {
 192               if (!NILP (full))
 193                 {
 194                   int afterdirindex = dirnamelen;
 195                   int total = len + dirnamelen;
 196                   int needsep = 0;
 197
 198                   /* Decide whether we need to add a directory separator.  */
 199 #ifndef VMS
 200                   if (dirnamelen == 0
 201                       || !IS_ANY_SEP (XSTRING (dirname)->data[dirnamelen - 1]))
 202                     needsep = 1;
 203 #endif /* VMS */
 204
 205                   name = make_uninit_string (total + needsep);
 206                   bcopy (XSTRING (dirname)->data, XSTRING (name)->data,
 207                          dirnamelen);
 208                   if (needsep)
 209                     XSTRING (name)->data[afterdirindex++] = DIRECTORY_SEP;
 210                   bcopy (dp->d_name,
 211                          XSTRING (name)->data + afterdirindex, len);
 212                 }
 213               else
 214                 name = make_string (dp->d_name, len);
 215               list = Fcons (name, list);
 216             }
 217         }
 218     }
 219   closedir (d);
 220   if (!NILP (nosort))
 221     return list;
 222   return Fsort (Fnreverse (list), Qstring_lessp);
 223 }
 224 \f
 225 Lisp_Object file_name_completion ();
 226
 227 DEFUN ("file-name-completion", Ffile_name_completion, Sfile_name_completion,
 228   2, 2, 0,
 229   "Complete file name FILE in directory DIR.\n\
 230 Returns the longest string\n\
 231 common to all filenames in DIR that start with FILE.\n\
 232 If there is only one and FILE matches it exactly, returns t.\n\
 233 Returns nil if DIR contains no name starting with FILE.")
 234   (file, dirname)
 235      Lisp_Object file, dirname;
 236 {
 237   Lisp_Object handler;
 238
 239   /* If the directory name has special constructs in it,
 240      call the corresponding file handler.  */
 241   handler = Ffind_file_name_handler (dirname, Qfile_name_completion);
 242   if (!NILP (handler))
 243     return call3 (handler, Qfile_name_completion, file, dirname);
 244
 245   /* If the file name has special constructs in it,
 246      call the corresponding file handler.  */
 247   handler = Ffind_file_name_handler (file, 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 directory 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   /* If the file name has special constructs in it,
 270      call the corresponding file handler.  */
 271   handler = Ffind_file_name_handler (file, Qfile_name_all_completions);
 272   if (!NILP (handler))
 273     return call3 (handler, Qfile_name_all_completions, file, dirname);
 274
 275   return file_name_completion (file, dirname, 1, 0);
 276 }
 277
 278 Lisp_Object
 279 file_name_completion (file, dirname, all_flag, ver_flag)
 280      Lisp_Object file, dirname;
 281      int all_flag, ver_flag;
 282 {
 283   DIR *d;
 284   DIRENTRY *dp;
 285   int bestmatchsize, skip;
 286   register int compare, matchsize;
 287   unsigned char *p1, *p2;
 288   int matchcount = 0;
 289   Lisp_Object bestmatch, tem, elt, name;
 290   struct stat st;
 291   int directoryp;
 292   int passcount;
 293   int count = specpdl_ptr - specpdl;
 294   struct gcpro gcpro1, gcpro2, gcpro3;
 295
 296 #ifdef VMS
 297   extern DIRENTRY * readdirver ();
 298
 299   DIRENTRY *((* readfunc) ());
 300
 301   /* Filename completion on VMS ignores case, since VMS filesys does.  */
 302   specbind (Qcompletion_ignore_case, Qt);
 303
 304   readfunc = readdir;
 305   if (ver_flag)
 306     readfunc = readdirver;
 307   file = Fupcase (file);
 308 #else  /* not VMS */
 309   CHECK_STRING (file, 0);
 310 #endif /* not VMS */
 311
 312 #ifdef FILE_SYSTEM_CASE
 313   file = FILE_SYSTEM_CASE (file);
 314 #endif
 315   bestmatch = Qnil;
 316   GCPRO3 (file, dirname, bestmatch);
 317   dirname = Fexpand_file_name (dirname, Qnil);
 318
 319   /* With passcount = 0, ignore files that end in an ignored extension.
 320      If nothing found then try again with passcount = 1, don't ignore them.
 321      If looking for all completions, start with passcount = 1,
 322      so always take even the ignored ones.
 323
 324      ** It would not actually be helpful to the user to ignore any possible
 325      completions when making a list of them.**  */
 326
 327   for (passcount = !!all_flag; NILP (bestmatch) && passcount < 2; passcount++)
 328     {
 329       if (!(d = opendir (XSTRING (Fdirectory_file_name (dirname))->data)))
 330         report_file_error ("Opening directory", Fcons (dirname, Qnil));
 331
 332       /* Loop reading blocks */
 333       /* (att3b compiler bug requires do a null comparison this way) */
 334       while (1)
 335         {
 336           DIRENTRY *dp;
 337           int len;
 338
 339 #ifdef VMS
 340           dp = (*readfunc) (d);
 341 #else
 342           dp = readdir (d);
 343 #endif
 344           if (!dp) break;
 345
 346           len = NAMLEN (dp);
 347
 348           if (!NILP (Vquit_flag) && NILP (Vinhibit_quit))
 349             goto quit;
 350           if (! DIRENTRY_NONEMPTY (dp)
 351               || len < XSTRING (file)->size
 352               || 0 <= scmp (dp->d_name, XSTRING (file)->data,
 353                             XSTRING (file)->size))
 354             continue;
 355
 356           if (file_name_completion_stat (dirname, dp, &st) < 0)
 357             continue;
 358
 359           directoryp = ((st.st_mode & S_IFMT) == S_IFDIR);
 360           tem = Qnil;
 361           if (directoryp)
 362             {
 363 #ifndef TRIVIAL_DIRECTORY_ENTRY
 364 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
 365 #endif
 366               /* "." and ".." are never interesting as completions, but are
 367                  actually in the way in a directory contains only one file.  */
 368               if (!passcount && TRIVIAL_DIRECTORY_ENTRY (dp->d_name))
 369                 continue;
 370             }
 371           else
 372             {
 373               /* Compare extensions-to-be-ignored against end of this file name */
 374               /* if name is not an exact match against specified string */
 375               if (!passcount && len > XSTRING (file)->size)
 376                 /* and exit this for loop if a match is found */
 377                 for (tem = Vcompletion_ignored_extensions;
 378                      CONSP (tem); tem = XCONS (tem)->cdr)
 379                   {
 380                     elt = XCONS (tem)->car;
 381                     if (!STRINGP (elt)) continue;
 382                     skip = len - XSTRING (elt)->size;
 383                     if (skip < 0) continue;
 384
 385                     if (0 <= scmp (dp->d_name + skip,
 386                                    XSTRING (elt)->data,
 387                                    XSTRING (elt)->size))
 388                       continue;
 389                     break;
 390                   }
 391             }
 392
 393           /* If an ignored-extensions match was found,
 394              don't process this name as a completion.  */
 395           if (!passcount && CONSP (tem))
 396             continue;
 397
 398           if (!passcount)
 399             {
 400               Lisp_Object regexps;
 401               Lisp_Object zero;
 402               XSETFASTINT (zero, 0);
 403
 404               /* Ignore this element if it fails to match all the regexps.  */
 405               for (regexps = Vcompletion_regexp_list; CONSP (regexps);
 406                    regexps = XCONS (regexps)->cdr)
 407                 {
 408                   tem = Fstring_match (XCONS (regexps)->car, elt, zero);
 409                   if (NILP (tem))
 410                     break;
 411                 }
 412               if (CONSP (regexps))
 413                 continue;
 414             }
 415
 416           /* Update computation of how much all possible completions match */
 417
 418           matchcount++;
 419
 420           if (all_flag || NILP (bestmatch))
 421             {
 422               /* This is a possible completion */
 423               if (directoryp)
 424                 {
 425                   /* This completion is a directory; make it end with '/' */
 426                   name = Ffile_name_as_directory (make_string (dp->d_name, len));
 427                 }
 428               else
 429                 name = make_string (dp->d_name, len);
 430               if (all_flag)
 431                 {
 432                   bestmatch = Fcons (name, bestmatch);
 433                 }
 434               else
 435                 {
 436                   bestmatch = name;
 437                   bestmatchsize = XSTRING (name)->size;
 438                 }
 439             }
 440           else
 441             {
 442               compare = min (bestmatchsize, len);
 443               p1 = XSTRING (bestmatch)->data;
 444               p2 = (unsigned char *) dp->d_name;
 445               matchsize = scmp(p1, p2, compare);
 446               if (matchsize < 0)
 447                 matchsize = compare;
 448               if (completion_ignore_case)
 449                 {
 450                   /* If this is an exact match except for case,
 451                      use it as the best match rather than one that is not
 452                      an exact match.  This way, we get the case pattern
 453                      of the actual match.  */
 454                   if ((matchsize == len
 455                        && matchsize + !!directoryp
 456                           < XSTRING (bestmatch)->size)
 457                       ||
 458                       /* If there is no exact match ignoring case,
 459                          prefer a match that does not change the case
 460                          of the input.  */
 461                       (((matchsize == len)
 462                         ==
 463                         (matchsize + !!directoryp
 464                          == XSTRING (bestmatch)->size))
 465                        /* If there is more than one exact match aside from
 466                           case, and one of them is exact including case,
 467                           prefer that one.  */
 468                        && !bcmp (p2, XSTRING (file)->data, XSTRING (file)->size)
 469                        && bcmp (p1, XSTRING (file)->data, XSTRING (file)->size)))
 470                     {
 471                       bestmatch = make_string (dp->d_name, len);
 472                       if (directoryp)
 473                         bestmatch = Ffile_name_as_directory (bestmatch);
 474                     }
 475                 }
 476
 477               /* If this dirname all matches, see if implicit following
 478                  slash does too.  */
 479               if (directoryp
 480                   && compare == matchsize
 481                   && bestmatchsize > matchsize
 482                   && IS_ANY_SEP (p1[matchsize]))
 483                 matchsize++;
 484               bestmatchsize = matchsize;
 485             }
 486         }
 487       closedir (d);
 488     }
 489
 490   UNGCPRO;
 491   bestmatch = unbind_to (count, bestmatch);
 492
 493   if (all_flag || NILP (bestmatch))
 494     return bestmatch;
 495   if (matchcount == 1 && bestmatchsize == XSTRING (file)->size)
 496     return Qt;
 497   return Fsubstring (bestmatch, make_number (0), make_number (bestmatchsize));
 498  quit:
 499   if (d) closedir (d);
 500   Vquit_flag = Qnil;
 501   return Fsignal (Qquit, Qnil);
 502 }
 503
 504 file_name_completion_stat (dirname, dp, st_addr)
 505      Lisp_Object dirname;
 506      DIRENTRY *dp;
 507      struct stat *st_addr;
 508 {
 509   int len = NAMLEN (dp);
 510   int pos = XSTRING (dirname)->size;
 511   int value;
 512   char *fullname = (char *) alloca (len + pos + 2);
 513
 514   bcopy (XSTRING (dirname)->data, fullname, pos);
 515 #ifndef VMS
 516   if (!IS_DIRECTORY_SEP (fullname[pos - 1]))
 517     fullname[pos++] = DIRECTORY_SEP;
 518 #endif
 519
 520   bcopy (dp->d_name, fullname + pos, len);
 521   fullname[pos + len] = 0;
 522
 523 #ifdef S_IFLNK
 524   /* We want to return success if a link points to a nonexistent file,
 525      but we want to return the status for what the link points to,
 526      in case it is a directory.  */
 527   value = lstat (fullname, st_addr);
 528   stat (fullname, st_addr);
 529   return value;
 530 #else
 531   return stat (fullname, st_addr);
 532 #endif
 533 }
 534 \f
 535 #ifdef VMS
 536
 537 DEFUN ("file-name-all-versions", Ffile_name_all_versions,
 538   Sfile_name_all_versions, 2, 2, 0,
 539   "Return a list of all versions of file name FILE in directory DIR.")
 540   (file, dirname)
 541      Lisp_Object file, dirname;
 542 {
 543   return file_name_completion (file, dirname, 1, 1);
 544 }
 545
 546 DEFUN ("file-version-limit", Ffile_version_limit, Sfile_version_limit, 1, 1, 0,
 547   "Return the maximum number of versions allowed for FILE.\n\
 548 Returns nil if the file cannot be opened or if there is no version limit.")
 549   (filename)
 550      Lisp_Object filename;
 551 {
 552   Lisp_Object retval;
 553   struct FAB    fab;
 554   struct RAB    rab;
 555   struct XABFHC xabfhc;
 556   int status;
 557
 558   filename = Fexpand_file_name (filename, Qnil);
 559   fab      = cc$rms_fab;
 560   xabfhc   = cc$rms_xabfhc;
 561   fab.fab$l_fna = XSTRING (filename)->data;
 562   fab.fab$b_fns = strlen (fab.fab$l_fna);
 563   fab.fab$l_xab = (char *) &xabfhc;
 564   status = sys$open (&fab, 0, 0);
 565   if (status != RMS$_NORMAL)    /* Probably non-existent file */
 566     return Qnil;
 567   sys$close (&fab, 0, 0);
 568   if (xabfhc.xab$w_verlimit == 32767)
 569     return Qnil;                /* No version limit */
 570   else
 571     return make_number (xabfhc.xab$w_verlimit);
 572 }
 573
 574 #endif /* VMS */
 575 \f
 576 Lisp_Object
 577 make_time (time)
 578      int time;
 579 {
 580   return Fcons (make_number (time >> 16),
 581                 Fcons (make_number (time & 0177777), Qnil));
 582 }
 583
 584 DEFUN ("file-attributes", Ffile_attributes, Sfile_attributes, 1, 1, 0,
 585   "Return a list of attributes of file FILENAME.\n\
 586 Value is nil if specified file cannot be opened.\n\
 587 Otherwise, list elements are:\n\
 588  0. t for directory, string (name linked to) for symbolic link, or nil.\n\
 589  1. Number of links to file.\n\
 590  2. File uid.\n\
 591  3. File gid.\n\
 592  4. Last access time, as a list of two integers.\n\
 593   First integer has high-order 16 bits of time, second has low 16 bits.\n\
 594  5. Last modification time, likewise.\n\
 595  6. Last status change time, likewise.\n\
 596  7. Size in bytes (-1, if number is out of range).\n\
 597  8. File modes, as a string of ten letters or dashes as in ls -l.\n\
 598  9. t iff file's gid would change if file were deleted and recreated.\n\
 599 10. inode number.\n\
 600 11. Device number.\n\
 601 \n\
 602 If file does not exist, returns nil.")
 603   (filename)
 604      Lisp_Object filename;
 605 {
 606   Lisp_Object values[12];
 607   Lisp_Object dirname;
 608   struct stat s;
 609   struct stat sdir;
 610   char modes[10];
 611   Lisp_Object handler;
 612
 613   filename = Fexpand_file_name (filename, Qnil);
 614
 615   /* If the file name has special constructs in it,
 616      call the corresponding file handler.  */
 617   handler = Ffind_file_name_handler (filename, Qfile_attributes);
 618   if (!NILP (handler))
 619     return call2 (handler, Qfile_attributes, filename);
 620
 621   if (lstat (XSTRING (filename)->data, &s) < 0)
 622     return Qnil;
 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 #ifdef WINDOWSNT
 658   values[9] = Qnil;     /* sorry, no group IDs on NT */
 659 #else  /* not WINDOWSNT */
 660   values[9] = (s.st_gid != getegid ()) ? Qt : Qnil;
 661 #endif /* not WINDOWSNT */
 662 #endif  /* BSD4_2 (or BSD4_3) */
 663 #ifdef BSD4_3
 664 #undef BSD4_2 /* ok, you can look again without throwing up */
 665 #endif
 666 #ifdef WINDOWSNT
 667   /* Fill in the inode and device values specially...see nt.c.  */
 668   if (!get_inode_and_device_vals (filename, &values[10], &values[11])) {
 669       return Qnil;
 670   }
 671 #else  /* not WINDOWSNT */
 672   values[10] = make_number (s.st_ino);
 673   values[11] = make_number (s.st_dev);
 674 #endif /* not WINDOWSNT */
 675   return Flist (sizeof(values) / sizeof(values[0]), values);
 676 }
 677 \f
 678 syms_of_dired ()
 679 {
 680   Qdirectory_files = intern ("directory-files");
 681   Qfile_name_completion = intern ("file-name-completion");
 682   Qfile_name_all_completions = intern ("file-name-all-completions");
 683   Qfile_attributes = intern ("file-attributes");
 684
 685   defsubr (&Sdirectory_files);
 686   defsubr (&Sfile_name_completion);
 687 #ifdef VMS
 688   defsubr (&Sfile_name_all_versions);
 689   defsubr (&Sfile_version_limit);
 690 #endif /* VMS */
 691   defsubr (&Sfile_name_all_completions);
 692   defsubr (&Sfile_attributes);
 693
 694 #ifdef VMS
 695   Qcompletion_ignore_case = intern ("completion-ignore-case");
 696   staticpro (&Qcompletion_ignore_case);
 697 #endif /* VMS */
 698
 699   DEFVAR_LISP ("completion-ignored-extensions", &Vcompletion_ignored_extensions,
 700     "*Completion ignores filenames ending in any string in this list.\n\
 701 This variable does not affect lists of possible completions,\n\
 702 but does affect the commands that actually do completions.");
 703   Vcompletion_ignored_extensions = Qnil;
 704 }