/* Lisp functions for making directory listings.
- Copyright (C) 1985, 1986, 1992 Free Software Foundation, Inc.
+ Copyright (C) 1985, 1986, 1993, 1994 Free Software Foundation, Inc.
This file is part of GNU Emacs.
GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 1, or (at your option)
+the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Emacs is distributed in the hope that it will be useful,
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+#include <config.h>
+
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
-#include "config.h"
-
#ifdef VMS
#include <string.h>
#include <rms.h>
#include <rmsdef.h>
#endif
+/* The d_nameln member of a struct dirent includes the '\0' character
+ on some systems, but not on others. What's worse, you can't tell
+ at compile-time which one it will be, since it really depends on
+ the sort of system providing the filesystem you're reading from,
+ not the system you are running on. Paul Eggert
+ <eggert@bi.twinsun.com> says this occurs when Emacs is running on a
+ SunOS 4.1.2 host, reading a directory that is remote-mounted from a
+ Solaris 2.1 host and is in a native Solaris 2.1 filesystem.
+
+ Since applying strlen to the name always works, we'll just do that. */
+#define NAMLEN(p) strlen (p->d_name)
+
#ifdef SYSV_SYSTEM_DIR
#include <dirent.h>
#define DIRENTRY struct dirent
-#define NAMLEN(p) strlen (p->d_name)
-#else
+#else /* not SYSV_SYSTEM_DIR */
#ifdef NONSYSTEM_DIR_LIBRARY
#include "ndir.h"
#else /* not NONSYSTEM_DIR_LIBRARY */
+#ifdef MSDOS
+#include <dirent.h>
+#else
#include <sys/dir.h>
+#endif
#endif /* not NONSYSTEM_DIR_LIBRARY */
+#ifndef MSDOS
#define DIRENTRY struct direct
-#define NAMLEN(p) p->d_namlen
extern DIR *opendir ();
extern struct direct *readdir ();
+#endif /* not MSDOS */
+#endif /* not SYSV_SYSTEM_DIR */
+
+#ifdef MSDOS
+#define DIRENTRY_NONEMPTY(p) ((p)->d_name[0] != 0)
+#else
+#define DIRENTRY_NONEMPTY(p) ((p)->d_ino)
#endif
#include "lisp.h"
#include "regex.h"
+/* Returns a search buffer, with a fastmap allocated and ready to go. */
+extern struct re_pattern_buffer *compile_pattern ();
+
#define min(a, b) ((a) < (b) ? (a) : (b))
/* if system does not have symbolic links, it does not have lstat.
#define lstat stat
#endif
-extern Lisp_Object Ffind_file_name_handler ();
+extern int completion_ignore_case;
+extern Lisp_Object Vcompletion_regexp_list;
Lisp_Object Vcompletion_ignored_extensions;
-
Lisp_Object Qcompletion_ignore_case;
-
Lisp_Object Qdirectory_files;
Lisp_Object Qfile_name_completion;
Lisp_Object Qfile_name_all_completions;
Lisp_Object dirname, full, match, nosort;
{
DIR *d;
- int length;
- Lisp_Object list, name;
+ int dirnamelen;
+ Lisp_Object list, name, dirfilename;
Lisp_Object handler;
+ struct re_pattern_buffer *bufp;
/* If the file name has special constructs in it,
call the corresponding file handler. */
- handler = Ffind_file_name_handler (dirname);
+ handler = Ffind_file_name_handler (dirname, Qdirectory_files);
if (!NILP (handler))
{
Lisp_Object args[6];
return Ffuncall (6, args);
}
+ {
+ struct gcpro gcpro1, gcpro2;
+
+ /* Because of file name handlers, these functions might call
+ Ffuncall, and cause a GC. */
+ GCPRO1 (match);
+ dirname = Fexpand_file_name (dirname, Qnil);
+ UNGCPRO;
+ GCPRO2 (match, dirname);
+ dirfilename = Fdirectory_file_name (dirname);
+ UNGCPRO;
+ }
+
if (!NILP (match))
{
CHECK_STRING (match, 3);
catching and signalling our own errors, we just call
compile_pattern to do the work for us. */
#ifdef VMS
- compile_pattern (match, &searchbuf, 0,
- buffer_defaults.downcase_table->contents);
+ bufp = compile_pattern (match, 0,
+ buffer_defaults.downcase_table->contents, 0);
#else
- compile_pattern (match, &searchbuf, 0, 0);
+ bufp = compile_pattern (match, 0, 0, 0);
#endif
}
- dirname = Fexpand_file_name (dirname, Qnil);
- if (!(d = opendir (XSTRING (Fdirectory_file_name (dirname))->data)))
+ /* Now *bufp is the compiled form of MATCH; don't call anything
+ which might compile a new regexp until we're done with the loop! */
+
+ /* Do this opendir after anything which might signal an error; if
+ an error is signalled while the directory stream is open, we
+ have to make sure it gets closed, and setting up an
+ unwind_protect to do so would be a pain. */
+ d = opendir (XSTRING (dirfilename)->data);
+ if (! d)
report_file_error ("Opening directory", Fcons (dirname, Qnil));
list = Qnil;
- length = XSTRING (dirname)->size;
+ dirnamelen = XSTRING (dirname)->size;
/* Loop reading blocks */
while (1)
if (!dp) break;
len = NAMLEN (dp);
- if (dp->d_ino)
+ if (DIRENTRY_NONEMPTY (dp))
{
if (NILP (match)
- || (0 <= re_search (&searchbuf, dp->d_name, len, 0, len, 0)))
+ || (0 <= re_search (bufp, dp->d_name, len, 0, len, 0)))
{
if (!NILP (full))
{
- int index = XSTRING (dirname)->size;
- int total = len + index;
+ int afterdirindex = dirnamelen;
+ int total = len + dirnamelen;
+ int needsep = 0;
+
+ /* Decide whether we need to add a directory separator. */
#ifndef VMS
- if (length == 0
- || XSTRING (dirname)->data[length - 1] != '/')
- total++;
+ if (dirnamelen == 0
+ || !IS_ANY_SEP (XSTRING (dirname)->data[dirnamelen - 1]))
+ needsep = 1;
#endif /* VMS */
- name = make_uninit_string (total);
+ name = make_uninit_string (total + needsep);
bcopy (XSTRING (dirname)->data, XSTRING (name)->data,
- index);
-#ifndef VMS
- if (length == 0
- || XSTRING (dirname)->data[length - 1] != '/')
- XSTRING (name)->data[index++] = '/';
-#endif /* VMS */
- bcopy (dp->d_name, XSTRING (name)->data + index, len);
+ dirnamelen);
+ if (needsep)
+ XSTRING (name)->data[afterdirindex++] = DIRECTORY_SEP;
+ bcopy (dp->d_name,
+ XSTRING (name)->data + afterdirindex, len);
}
else
name = make_string (dp->d_name, len);
Lisp_Object file, dirname;
{
Lisp_Object handler;
- /* Don't waste time trying to complete a null string.
- Besides, this case happens when user is being asked for
- a directory name and has supplied one ending in a /.
- We would not want to add anything in that case
- even if there are some unique characters in that directory. */
- if (XTYPE (file) == Lisp_String && XSTRING (file)->size == 0)
- return file;
+
+ /* If the directory name has special constructs in it,
+ call the corresponding file handler. */
+ handler = Ffind_file_name_handler (dirname, Qfile_name_completion);
+ if (!NILP (handler))
+ return call3 (handler, Qfile_name_completion, file, dirname);
/* If the file name has special constructs in it,
call the corresponding file handler. */
- handler = Ffind_file_name_handler (dirname);
+ handler = Ffind_file_name_handler (file, Qfile_name_completion);
if (!NILP (handler))
return call3 (handler, Qfile_name_completion, file, dirname);
{
Lisp_Object handler;
+ /* If the directory name has special constructs in it,
+ call the corresponding file handler. */
+ handler = Ffind_file_name_handler (dirname, Qfile_name_all_completions);
+ if (!NILP (handler))
+ return call3 (handler, Qfile_name_all_completions, file, dirname);
+
/* If the file name has special constructs in it,
call the corresponding file handler. */
- handler = Ffind_file_name_handler (dirname);
+ handler = Ffind_file_name_handler (file, Qfile_name_all_completions);
if (!NILP (handler))
return call3 (handler, Qfile_name_all_completions, file, dirname);
int directoryp;
int passcount;
int count = specpdl_ptr - specpdl;
+ struct gcpro gcpro1, gcpro2, gcpro3;
+
#ifdef VMS
extern DIRENTRY * readdirver ();
CHECK_STRING (file, 0);
#endif /* not VMS */
- dirname = Fexpand_file_name (dirname, Qnil);
+#ifdef FILE_SYSTEM_CASE
+ file = FILE_SYSTEM_CASE (file);
+#endif
bestmatch = Qnil;
+ GCPRO3 (file, dirname, bestmatch);
+ dirname = Fexpand_file_name (dirname, Qnil);
/* With passcount = 0, ignore files that end in an ignored extension.
If nothing found then try again with passcount = 1, don't ignore them.
if (!NILP (Vquit_flag) && NILP (Vinhibit_quit))
goto quit;
- if (!dp->d_ino
+ if (! DIRENTRY_NONEMPTY (dp)
|| len < XSTRING (file)->size
|| 0 <= scmp (dp->d_name, XSTRING (file)->data,
XSTRING (file)->size))
directoryp = ((st.st_mode & S_IFMT) == S_IFDIR);
tem = Qnil;
- if (!directoryp)
+ if (directoryp)
+ {
+#ifndef TRIVIAL_DIRECTORY_ENTRY
+#define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
+#endif
+ /* "." and ".." are never interesting as completions, but are
+ actually in the way in a directory contains only one file. */
+ if (!passcount && TRIVIAL_DIRECTORY_ENTRY (dp->d_name))
+ continue;
+ }
+ else
{
/* Compare extensions-to-be-ignored against end of this file name */
/* if name is not an exact match against specified string */
CONSP (tem); tem = XCONS (tem)->cdr)
{
elt = XCONS (tem)->car;
- if (XTYPE (elt) != Lisp_String) continue;
+ if (!STRINGP (elt)) continue;
skip = len - XSTRING (elt)->size;
if (skip < 0) continue;
}
}
- /* Unless an ignored-extensions match was found,
- process this name as a completion */
- if (passcount || !CONSP (tem))
+ /* If an ignored-extensions match was found,
+ don't process this name as a completion. */
+ if (!passcount && CONSP (tem))
+ continue;
+
+ if (!passcount)
{
- /* Update computation of how much all possible completions match */
+ Lisp_Object regexps;
+ Lisp_Object zero;
+ XSETFASTINT (zero, 0);
- matchcount++;
+ /* Ignore this element if it fails to match all the regexps. */
+ for (regexps = Vcompletion_regexp_list; CONSP (regexps);
+ regexps = XCONS (regexps)->cdr)
+ {
+ tem = Fstring_match (XCONS (regexps)->car, elt, zero);
+ if (NILP (tem))
+ break;
+ }
+ if (CONSP (regexps))
+ continue;
+ }
- if (all_flag || NILP (bestmatch))
+ /* Update computation of how much all possible completions match */
+
+ matchcount++;
+
+ if (all_flag || NILP (bestmatch))
+ {
+ /* This is a possible completion */
+ if (directoryp)
{
- /* This is a possible completion */
- if (directoryp)
- {
- /* This completion is a directory; make it end with '/' */
- name = Ffile_name_as_directory (make_string (dp->d_name, len));
- }
- else
- name = make_string (dp->d_name, len);
- if (all_flag)
- {
- bestmatch = Fcons (name, bestmatch);
- }
- else
- {
- bestmatch = name;
- bestmatchsize = XSTRING (name)->size;
- }
+ /* This completion is a directory; make it end with '/' */
+ name = Ffile_name_as_directory (make_string (dp->d_name, len));
+ }
+ else
+ name = make_string (dp->d_name, len);
+ if (all_flag)
+ {
+ bestmatch = Fcons (name, bestmatch);
}
else
{
- compare = min (bestmatchsize, len);
- p1 = XSTRING (bestmatch)->data;
- p2 = (unsigned char *) dp->d_name;
- matchsize = scmp(p1, p2, compare);
- if (matchsize < 0)
- matchsize = compare;
- /* If this dirname all matches,
- see if implicit following slash does too. */
- if (directoryp
- && compare == matchsize
- && bestmatchsize > matchsize
- && p1[matchsize] == '/')
- matchsize++;
- bestmatchsize = min (matchsize, bestmatchsize);
+ bestmatch = name;
+ bestmatchsize = XSTRING (name)->size;
+ }
+ }
+ else
+ {
+ compare = min (bestmatchsize, len);
+ p1 = XSTRING (bestmatch)->data;
+ p2 = (unsigned char *) dp->d_name;
+ matchsize = scmp(p1, p2, compare);
+ if (matchsize < 0)
+ matchsize = compare;
+ if (completion_ignore_case)
+ {
+ /* If this is an exact match except for case,
+ use it as the best match rather than one that is not
+ an exact match. This way, we get the case pattern
+ of the actual match. */
+ if ((matchsize == len
+ && matchsize + !!directoryp
+ < XSTRING (bestmatch)->size)
+ ||
+ /* If there is no exact match ignoring case,
+ prefer a match that does not change the case
+ of the input. */
+ (((matchsize == len)
+ ==
+ (matchsize + !!directoryp
+ == XSTRING (bestmatch)->size))
+ /* If there is more than one exact match aside from
+ case, and one of them is exact including case,
+ prefer that one. */
+ && !bcmp (p2, XSTRING (file)->data, XSTRING (file)->size)
+ && bcmp (p1, XSTRING (file)->data, XSTRING (file)->size)))
+ {
+ bestmatch = make_string (dp->d_name, len);
+ if (directoryp)
+ bestmatch = Ffile_name_as_directory (bestmatch);
+ }
}
+
+ /* If this dirname all matches, see if implicit following
+ slash does too. */
+ if (directoryp
+ && compare == matchsize
+ && bestmatchsize > matchsize
+ && IS_ANY_SEP (p1[matchsize]))
+ matchsize++;
+ bestmatchsize = matchsize;
}
}
closedir (d);
}
- unbind_to (count, Qnil);
+ UNGCPRO;
+ bestmatch = unbind_to (count, bestmatch);
if (all_flag || NILP (bestmatch))
return bestmatch;
{
int len = NAMLEN (dp);
int pos = XSTRING (dirname)->size;
+ int value;
char *fullname = (char *) alloca (len + pos + 2);
bcopy (XSTRING (dirname)->data, fullname, pos);
#ifndef VMS
- if (fullname[pos - 1] != '/')
- fullname[pos++] = '/';
+ if (!IS_DIRECTORY_SEP (fullname[pos - 1]))
+ fullname[pos++] = DIRECTORY_SEP;
#endif
bcopy (dp->d_name, fullname + pos, len);
fullname[pos + len] = 0;
+#ifdef S_IFLNK
+ /* We want to return success if a link points to a nonexistent file,
+ but we want to return the status for what the link points to,
+ in case it is a directory. */
+ value = lstat (fullname, st_addr);
+ stat (fullname, st_addr);
+ return value;
+#else
return stat (fullname, st_addr);
+#endif
}
\f
#ifdef VMS
First integer has high-order 16 bits of time, second has low 16 bits.\n\
5. Last modification time, likewise.\n\
6. Last status change time, likewise.\n\
- 7. Size in bytes.\n\
+ 7. Size in bytes (-1, if number is out of range).\n\
8. File modes, as a string of ten letters or dashes as in ls -l.\n\
9. t iff file's gid would change if file were deleted and recreated.\n\
10. inode number.\n\
/* If the file name has special constructs in it,
call the corresponding file handler. */
- handler = Ffind_file_name_handler (filename);
+ handler = Ffind_file_name_handler (filename, Qfile_attributes);
if (!NILP (handler))
return call2 (handler, Qfile_attributes, filename);
if (lstat (XSTRING (filename)->data, &s) < 0)
return Qnil;
+#ifdef MSDOS
+ {
+ char *tmpnam = XSTRING (Ffile_name_nondirectory (filename))->data;
+ int l = strlen (tmpnam);
+
+ if (l >= 5
+ && S_ISREG (s.st_mode)
+ && (stricmp (&tmpnam[l - 4], ".com") == 0
+ || stricmp (&tmpnam[l - 4], ".exe") == 0
+ || stricmp (&tmpnam[l - 4], ".bat") == 0))
+ {
+ s.st_mode |= S_IEXEC;
+ }
+ }
+#endif /* MSDOS */
+
switch (s.st_mode & S_IFMT)
{
default:
values[4] = make_time (s.st_atime);
values[5] = make_time (s.st_mtime);
values[6] = make_time (s.st_ctime);
- /* perhaps we should set this to most-positive-fixnum if it is too large? */
- values[7] = make_number (s.st_size);
+ values[7] = make_number ((int) s.st_size);
+ /* If the size is out of range, give back -1. */
+ if (XINT (values[7]) != s.st_size)
+ XSETINT (values[7], -1);
filemodestring (&s, modes);
values[8] = make_string (modes, 10);
#ifdef BSD4_3 /* Gross kludge to avoid lack of "#if defined(...)" in VMS */
-#define BSD4_2 /* A new meaning to the term `backwards compatability' */
+#define BSD4_2 /* A new meaning to the term `backwards compatibility' */
#endif
#ifdef BSD4_2 /* file gid will be dir gid */
dirname = Ffile_name_directory (filename);
else /* if we can't tell, assume worst */
values[9] = Qt;
#else /* file gid will be egid */
+#ifdef WINDOWSNT
+ values[9] = Qnil; /* sorry, no group IDs on NT */
+#else /* not WINDOWSNT */
values[9] = (s.st_gid != getegid ()) ? Qt : Qnil;
+#endif /* not WINDOWSNT */
#endif /* BSD4_2 (or BSD4_3) */
#ifdef BSD4_3
#undef BSD4_2 /* ok, you can look again without throwing up */
#endif
+#ifdef WINDOWSNT
+ /* Fill in the inode and device values specially...see nt.c. */
+ if (!get_inode_and_device_vals (filename, &values[10], &values[11])) {
+ return Qnil;
+ }
+#else /* not WINDOWSNT */
values[10] = make_number (s.st_ino);
values[11] = make_number (s.st_dev);
+#endif /* not WINDOWSNT */
return Flist (sizeof(values) / sizeof(values[0]), values);
}
\f
HCoop / bpt / emacs.git / blobdiff