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,
You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING. If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
#include <config.h>
#include <rmsdef.h>
#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.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
#include "lisp.h"
#include "buffer.h"
#include "commands.h"
-
+#include "charset.h"
+#include "coding.h"
#include "regex.h"
-/* A search buffer, with a fastmap allocated and ready to go. */
-extern struct re_pattern_buffer searchbuf;
+/* 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))
extern int completion_ignore_case;
extern Lisp_Object Vcompletion_regexp_list;
+extern Lisp_Object Vfile_name_coding_system, Vdefault_file_name_coding_system;
Lisp_Object Vcompletion_ignored_extensions;
-Lisp_Object Qcompletion_ignored_extensions;
Lisp_Object Qcompletion_ignore_case;
Lisp_Object Qdirectory_files;
Lisp_Object Qfile_name_completion;
DEFUN ("directory-files", Fdirectory_files, Sdirectory_files, 1, 4, 0,
"Return a list of names of files in DIRECTORY.\n\
There are three optional arguments:\n\
-If FULL is non-nil, absolute pathnames of the files are returned.\n\
-If MATCH is non-nil, only pathnames containing that regexp are returned.\n\
+If FULL is non-nil, return absolute file names. Otherwise return names\n\
+ that are relative to the specified directory.\n\
+If MATCH is non-nil, mention only file names that match the regexp MATCH.\n\
If NOSORT is non-nil, the list is not sorted--its order is unpredictable.\n\
NOSORT is useful if you plan to sort the result yourself.")
- (dirname, full, match, nosort)
- Lisp_Object dirname, full, match, nosort;
+ (directory, full, match, nosort)
+ Lisp_Object directory, full, match, nosort;
{
DIR *d;
- int length;
+ int dirnamelen;
Lisp_Object list, name, dirfilename;
+ Lisp_Object encoded_directory;
Lisp_Object handler;
+ struct re_pattern_buffer *bufp;
+ int needsep = 0;
+ struct gcpro gcpro1, gcpro2;
/* If the file name has special constructs in it,
call the corresponding file handler. */
- handler = Ffind_file_name_handler (dirname, Qdirectory_files);
+ handler = Ffind_file_name_handler (directory, Qdirectory_files);
if (!NILP (handler))
{
Lisp_Object args[6];
args[0] = handler;
args[1] = Qdirectory_files;
- args[2] = dirname;
+ args[2] = directory;
args[3] = full;
args[4] = match;
args[5] = nosort;
return Ffuncall (6, args);
}
- {
- struct gcpro gcpro1, gcpro2;
-
- /* Because of file name handlers, these functions might call
+ /* 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;
- }
+ GCPRO1 (match);
+ directory = Fexpand_file_name (directory, Qnil);
+ UNGCPRO;
+ GCPRO2 (match, directory);
+ dirfilename = Fdirectory_file_name (directory);
+ UNGCPRO;
if (!NILP (match))
{
CHECK_STRING (match, 3);
/* MATCH might be a flawed regular expression. Rather than
- catching and signalling our own errors, we just call
+ catching and signaling our own errors, we just call
compile_pattern to do the work for us. */
+ /* Pass 1 for the MULTIBYTE arg
+ because we do make multibyte strings if the contents warrant. */
#ifdef VMS
- compile_pattern (match, &searchbuf, 0,
- buffer_defaults.downcase_table->contents);
+ bufp = compile_pattern (match, 0,
+ buffer_defaults.downcase_table, 0, 1);
#else
- compile_pattern (match, &searchbuf, 0, 0);
+ bufp = compile_pattern (match, 0, Qnil, 0, 1);
#endif
}
- /* Now searchbuf is the compiled form of MATCH; don't call anything
+ dirfilename = ENCODE_FILE (dirfilename);
+
+ encoded_directory = ENCODE_FILE (directory);
+
+ /* 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
+ an error is signaled 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));
+ report_file_error ("Opening directory", Fcons (directory, Qnil));
list = Qnil;
- length = XSTRING (dirname)->size;
+ dirnamelen = STRING_BYTES (XSTRING (directory));
+ re_match_object = Qt;
+
+ /* Decide whether we need to add a directory separator. */
+#ifndef VMS
+ if (dirnamelen == 0
+ || !IS_ANY_SEP (XSTRING (directory)->data[dirnamelen - 1]))
+ needsep = 1;
+#endif /* not VMS */
+
+ GCPRO2 (encoded_directory, list);
/* Loop reading blocks */
while (1)
{
DIRENTRY *dp = readdir (d);
- int len;
if (!dp) break;
- len = NAMLEN (dp);
if (DIRENTRY_NONEMPTY (dp))
{
+ int len;
+
+ len = NAMLEN (dp);
+ name = DECODE_FILE (make_string (dp->d_name, len));
+ len = STRING_BYTES (XSTRING (name));
+
if (NILP (match)
- || (0 <= re_search (&searchbuf, dp->d_name, len, 0, len, 0)))
+ || (0 <= re_search (bufp, XSTRING (name)->data, len, 0, len, 0)))
{
if (!NILP (full))
{
- int index = XSTRING (dirname)->size;
- int total = len + index;
-#ifndef VMS
- if (length == 0
- || XSTRING (dirname)->data[length - 1] != '/')
- total++;
-#endif /* VMS */
-
- name = make_uninit_string (total);
- 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);
+ int afterdirindex = dirnamelen;
+ int total = len + dirnamelen;
+ int nchars;
+ Lisp_Object fullname;
+
+ fullname = make_uninit_multibyte_string (total + needsep,
+ total + needsep);
+ bcopy (XSTRING (directory)->data, XSTRING (fullname)->data,
+ dirnamelen);
+ if (needsep)
+ XSTRING (fullname)->data[afterdirindex++] = DIRECTORY_SEP;
+ bcopy (XSTRING (name)->data,
+ XSTRING (fullname)->data + afterdirindex, len);
+ nchars = chars_in_text (XSTRING (fullname)->data,
+ afterdirindex + len);
+ XSTRING (fullname)->size = nchars;
+ if (nchars == STRING_BYTES (XSTRING (fullname)))
+ SET_STRING_BYTES (XSTRING (fullname), -1);
+ name = fullname;
}
- else
- name = make_string (dp->d_name, len);
list = Fcons (name, list);
}
}
}
closedir (d);
+ UNGCPRO;
if (!NILP (nosort))
return list;
return Fsort (Fnreverse (list), Qstring_lessp);
DEFUN ("file-name-completion", Ffile_name_completion, Sfile_name_completion,
2, 2, 0,
- "Complete file name FILE in directory DIR.\n\
+ "Complete file name FILE in directory DIRECTORY.\n\
Returns the longest string\n\
-common to all filenames in DIR that start with FILE.\n\
+common to all file names in DIRECTORY that start with FILE.\n\
If there is only one and FILE matches it exactly, returns t.\n\
Returns nil if DIR contains no name starting with FILE.")
- (file, dirname)
- Lisp_Object file, dirname;
+ (file, directory)
+ Lisp_Object file, directory;
{
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 (directory, Qfile_name_completion);
+ if (!NILP (handler))
+ return call3 (handler, Qfile_name_completion, file, directory);
/* If the file name has special constructs in it,
call the corresponding file handler. */
- handler = Ffind_file_name_handler (dirname, Qfile_name_completion);
+ handler = Ffind_file_name_handler (file, Qfile_name_completion);
if (!NILP (handler))
- return call3 (handler, Qfile_name_completion, file, dirname);
+ return call3 (handler, Qfile_name_completion, file, directory);
- return file_name_completion (file, dirname, 0, 0);
+ return file_name_completion (file, directory, 0, 0);
}
DEFUN ("file-name-all-completions", Ffile_name_all_completions,
Sfile_name_all_completions, 2, 2, 0,
- "Return a list of all completions of file name FILE in directory DIR.\n\
-These are all file names in directory DIR which begin with FILE.")
- (file, dirname)
- Lisp_Object file, dirname;
+ "Return a list of all completions of file name FILE in directory DIRECTORY.\n\
+These are all file names in directory DIRECTORY which begin with FILE.")
+ (file, directory)
+ Lisp_Object file, directory;
{
Lisp_Object handler;
+ /* If the directory name has special constructs in it,
+ call the corresponding file handler. */
+ handler = Ffind_file_name_handler (directory, Qfile_name_all_completions);
+ if (!NILP (handler))
+ return call3 (handler, Qfile_name_all_completions, file, directory);
+
/* If the file name has special constructs in it,
call the corresponding file handler. */
- handler = Ffind_file_name_handler (dirname, Qfile_name_all_completions);
+ handler = Ffind_file_name_handler (file, Qfile_name_all_completions);
if (!NILP (handler))
- return call3 (handler, Qfile_name_all_completions, file, dirname);
+ return call3 (handler, Qfile_name_all_completions, file, directory);
- return file_name_completion (file, dirname, 1, 0);
+ return file_name_completion (file, directory, 1, 0);
}
+static int file_name_completion_stat ();
+
Lisp_Object
file_name_completion (file, dirname, all_flag, ver_flag)
Lisp_Object file, dirname;
unsigned char *p1, *p2;
int matchcount = 0;
Lisp_Object bestmatch, tem, elt, name;
+ Lisp_Object encoded_file;
+ Lisp_Object encoded_dir;
struct stat st;
int directoryp;
int passcount;
int count = specpdl_ptr - specpdl;
- struct gcpro gcpro1, gcpro2, gcpro3;
+ struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
#ifdef VMS
extern DIRENTRY * readdirver ();
file = FILE_SYSTEM_CASE (file);
#endif
bestmatch = Qnil;
- GCPRO3 (file, dirname, bestmatch);
+ encoded_file = encoded_dir = Qnil;
+ GCPRO5 (file, dirname, bestmatch, encoded_file, encoded_dir);
dirname = Fexpand_file_name (dirname, Qnil);
+ /* Do completion on the encoded file name
+ because the other names in the directory are (we presume)
+ encoded likewise. We decode the completed string at the end. */
+ encoded_file = ENCODE_FILE (file);
+
+ encoded_dir = ENCODE_FILE (dirname);
+
/* 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 looking for all completions, start with passcount = 1,
for (passcount = !!all_flag; NILP (bestmatch) && passcount < 2; passcount++)
{
- if (!(d = opendir (XSTRING (Fdirectory_file_name (dirname))->data)))
+ d = opendir (XSTRING (Fdirectory_file_name (encoded_dir))->data);
+ if (!d)
report_file_error ("Opening directory", Fcons (dirname, Qnil));
/* Loop reading blocks */
if (!NILP (Vquit_flag) && NILP (Vinhibit_quit))
goto quit;
if (! DIRENTRY_NONEMPTY (dp)
- || len < XSTRING (file)->size
- || 0 <= scmp (dp->d_name, XSTRING (file)->data,
- XSTRING (file)->size))
+ || len < XSTRING (encoded_file)->size
+ || 0 <= scmp (dp->d_name, XSTRING (encoded_file)->data,
+ XSTRING (encoded_file)->size))
continue;
- if (file_name_completion_stat (dirname, dp, &st) < 0)
+ if (file_name_completion_stat (encoded_dir, dp, &st) < 0)
continue;
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 */
- if (!passcount && len > XSTRING (file)->size)
+ if (!passcount && len > XSTRING (encoded_file)->size)
/* and exit this for loop if a match is found */
for (tem = Vcompletion_ignored_extensions;
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;
{
Lisp_Object regexps;
Lisp_Object zero;
- XFASTINT (zero) = 0;
+ XSETFASTINT (zero, 0);
/* Ignore this element if it fails to match all the regexps. */
for (regexps = Vcompletion_regexp_list; CONSP (regexps);
name = make_string (dp->d_name, len);
if (all_flag)
{
+ name = DECODE_FILE (name);
bestmatch = Fcons (name, bestmatch);
}
else
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. */
+ /* This tests that the current file is an exact match
+ but BESTMATCH is not (it is too long). */
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. */
+ /* If there is more than one exact match aside from
+ case, and one of them is exact including case,
+ prefer that one. */
+ /* This == checks that, of current file and BESTMATCH,
+ either both or neither are exact. */
(((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)))
+ && !bcmp (p2, XSTRING (encoded_file)->data, XSTRING (encoded_file)->size)
+ && bcmp (p1, XSTRING (encoded_file)->data, XSTRING (encoded_file)->size)))
{
bestmatch = make_string (dp->d_name, len);
if (directoryp)
if (directoryp
&& compare == matchsize
&& bestmatchsize > matchsize
- && p1[matchsize] == '/')
+ && IS_ANY_SEP (p1[matchsize]))
matchsize++;
bestmatchsize = matchsize;
}
bestmatch = unbind_to (count, bestmatch);
if (all_flag || NILP (bestmatch))
- return bestmatch;
+ {
+ if (STRINGP (bestmatch))
+ bestmatch = DECODE_FILE (bestmatch);
+ return bestmatch;
+ }
if (matchcount == 1 && bestmatchsize == XSTRING (file)->size)
return Qt;
- return Fsubstring (bestmatch, make_number (0), make_number (bestmatchsize));
+ bestmatch = Fsubstring (bestmatch, make_number (0),
+ make_number (bestmatchsize));
+ /* Now that we got the right initial segment of BESTMATCH,
+ decode it from the coding system in use. */
+ bestmatch = DECODE_FILE (bestmatch);
+ return bestmatch;
+
quit:
if (d) closedir (d);
Vquit_flag = Qnil;
return Fsignal (Qquit, Qnil);
}
+static int
file_name_completion_stat (dirname, dp, st_addr)
Lisp_Object dirname;
DIRENTRY *dp;
int value;
char *fullname = (char *) alloca (len + pos + 2);
+#ifdef MSDOS
+#if __DJGPP__ > 1
+ /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
+ but aren't required here. Avoid computing the following fields:
+ st_inode, st_size and st_nlink for directories, and the execute bits
+ in st_mode for non-directory files with non-standard extensions. */
+
+ unsigned short save_djstat_flags = _djstat_flags;
+
+ _djstat_flags = _STAT_INODE | _STAT_EXEC_MAGIC | _STAT_DIRSIZE;
+#endif /* __DJGPP__ > 1 */
+#endif /* MSDOS */
+
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);
stat (fullname, st_addr);
return value;
#else
- return stat (fullname, st_addr);
-#endif
+ value = stat (fullname, st_addr);
+#ifdef MSDOS
+#if __DJGPP__ > 1
+ _djstat_flags = save_djstat_flags;
+#endif /* __DJGPP__ > 1 */
+#endif /* MSDOS */
+ return value;
+#endif /* S_IFLNK */
}
\f
#ifdef VMS
DEFUN ("file-name-all-versions", Ffile_name_all_versions,
Sfile_name_all_versions, 2, 2, 0,
- "Return a list of all versions of file name FILE in directory DIR.")
- (file, dirname)
- Lisp_Object file, dirname;
+ "Return a list of all versions of file name FILE in directory DIRECTORY.")
+ (file, directory)
+ Lisp_Object file, directory;
{
- return file_name_completion (file, dirname, 1, 1);
+ return file_name_completion (file, directory, 1, 1);
}
DEFUN ("file-version-limit", Ffile_version_limit, Sfile_version_limit, 1, 1, 0,
{
Lisp_Object values[12];
Lisp_Object dirname;
+ Lisp_Object encoded;
struct stat s;
struct stat sdir;
char modes[10];
if (!NILP (handler))
return call2 (handler, Qfile_attributes, filename);
- if (lstat (XSTRING (filename)->data, &s) < 0)
- return Qnil;
+ encoded = ENCODE_FILE (filename);
-#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 */
+ if (lstat (XSTRING (encoded)->data, &s) < 0)
+ return Qnil;
switch (s.st_mode & S_IFMT)
{
#endif
#ifdef BSD4_2 /* file gid will be dir gid */
dirname = Ffile_name_directory (filename);
- if (! NILP (dirname) && stat (XSTRING (dirname)->data, &sdir) == 0)
+ if (! NILP (dirname))
+ encoded = ENCODE_FILE (dirname);
+ if (! NILP (dirname) && stat (XSTRING (encoded)->data, &sdir) == 0)
values[9] = (sdir.st_gid != s.st_gid) ? Qt : Qnil;
else /* if we can't tell, assume worst */
values[9] = Qt;
#ifdef BSD4_3
#undef BSD4_2 /* ok, you can look again without throwing up */
#endif
- values[10] = make_number (s.st_ino);
+ /* Cast -1 to avoid warning if int is not as wide as VALBITS. */
+ if (s.st_ino & (((EMACS_INT) (-1)) << VALBITS))
+ /* To allow inode numbers larger than VALBITS, separate the bottom
+ 16 bits. */
+ values[10] = Fcons (make_number (s.st_ino >> 16),
+ make_number (s.st_ino & 0xffff));
+ else
+ /* But keep the most common cases as integers. */
+ values[10] = make_number (s.st_ino);
values[11] = make_number (s.st_dev);
return Flist (sizeof(values) / sizeof(values[0]), values);
}
\f
+void
syms_of_dired ()
{
Qdirectory_files = intern ("directory-files");
Qfile_name_all_completions = intern ("file-name-all-completions");
Qfile_attributes = intern ("file-attributes");
+ staticpro (&Qdirectory_files);
+ staticpro (&Qfile_name_completion);
+ staticpro (&Qfile_name_all_completions);
+ staticpro (&Qfile_attributes);
+
defsubr (&Sdirectory_files);
defsubr (&Sfile_name_completion);
#ifdef VMS
staticpro (&Qcompletion_ignore_case);
#endif /* VMS */
- Qcompletion_ignored_extensions = intern ("completion-ignored-extensions");
- staticpro (&Qcompletion_ignored_extensions);
DEFVAR_LISP ("completion-ignored-extensions", &Vcompletion_ignored_extensions,
"*Completion ignores filenames ending in any string in this list.\n\
This variable does not affect lists of possible completions,\n\
HCoop / bpt / emacs.git / blobdiff