/* File IO for GNU Emacs.
- Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994 Free Software Foundation, Inc.
+ Copyright (C) 1985,86,87,88,93,94,95,96,97,98,1999 Free Software Foundation, Inc.
This file is part of GNU Emacs.
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>
+#if defined (USG5) || defined (BSD_SYSTEM) || defined (LINUX)
+#include <fcntl.h>
+#endif
+
+#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
# define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)
#endif
+#if !defined (S_ISFIFO) && defined (S_IFIFO)
+# define S_ISFIFO(m) (((m) & S_IFMT) == S_IFIFO)
+#endif
+
#if !defined (S_ISREG) && defined (S_IFREG)
# define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
#endif
#include <pwd.h>
#endif
-#ifdef MSDOS
-#include "msdos.h"
-#include <sys/param.h>
-#endif
-
#include <ctype.h>
#ifdef VMS
extern int errno;
#endif
-extern char *strerror ();
-
#ifdef APOLLO
#include <sys/time.h>
#endif
#include "lisp.h"
#include "intervals.h"
#include "buffer.h"
+#include "charset.h"
+#include "coding.h"
#include "window.h"
#ifdef WINDOWSNT
#include <fcntl.h>
#endif /* not WINDOWSNT */
+#ifdef MSDOS
+#include "msdos.h"
+#include <sys/param.h>
+#if __DJGPP__ >= 2
+#include <fcntl.h>
+#include <string.h>
+#endif
+#endif
+
+#ifdef DOS_NT
+#define CORRECT_DIR_SEPS(s) \
+ do { if ('/' == DIRECTORY_SEP) dostounix_filename (s); \
+ else unixtodos_filename (s); \
+ } while (0)
+/* On Windows, drive letters must be alphabetic - on DOS, the Netware
+ redirector allows the six letters between 'Z' and 'a' as well. */
+#ifdef MSDOS
+#define IS_DRIVE(x) ((x) >= 'A' && (x) <= 'z')
+#endif
+#ifdef WINDOWSNT
+#define IS_DRIVE(x) isalpha (x)
+#endif
+/* Need to lower-case the drive letter, or else expanded
+ filenames will sometimes compare inequal, because
+ `expand-file-name' doesn't always down-case the drive letter. */
+#define DRIVE_LETTER(x) (tolower (x))
+#endif
+
#ifdef VMS
#include <file.h>
#include <rmsdef.h>
#endif
#endif
+#include "commands.h"
+extern int use_dialog_box;
+
#ifndef O_WRONLY
#define O_WRONLY 1
#endif
#define O_RDONLY 0
#endif
+#ifndef S_ISLNK
+# define lstat stat
+#endif
+
#define min(a, b) ((a) < (b) ? (a) : (b))
#define max(a, b) ((a) > (b) ? (a) : (b))
a new file with the same mode as the original */
int auto_save_mode_bits;
-/* Alist of elements (REGEXP . HANDLER) for file names
+/* Coding system for file names, or nil if none. */
+Lisp_Object Vfile_name_coding_system;
+
+/* Coding system for file names used only when
+ Vfile_name_coding_system is nil. */
+Lisp_Object Vdefault_file_name_coding_system;
+
+/* Alist of elements (REGEXP . HANDLER) for file names
whose I/O is done with a special handler. */
Lisp_Object Vfile_name_handler_alist;
+/* Format for auto-save files */
+Lisp_Object Vauto_save_file_format;
+
+/* Lisp functions for translating file formats */
+Lisp_Object Qformat_decode, Qformat_annotate_function;
+
+/* Function to be called to decide a coding system of a reading file. */
+Lisp_Object Vset_auto_coding_function;
+
/* Functions to be called to process text properties in inserted file. */
Lisp_Object Vafter_insert_file_functions;
Zero means use var format. */
int vms_stmlf_recfm;
+/* On NT, specifies the directory separator character, used (eg.) when
+ expanding file names. This can be bound to / or \. */
+Lisp_Object Vdirectory_sep_char;
+
+extern Lisp_Object Vuser_login_name;
+
+#ifdef WINDOWSNT
+extern Lisp_Object Vw32_get_true_file_attributes;
+#endif
+
+extern int minibuf_level;
+
+extern int minibuffer_auto_raise;
+
/* These variables describe handlers that have "already" had a chance
to handle the current operation.
static Lisp_Object Vinhibit_file_name_handlers;
static Lisp_Object Vinhibit_file_name_operation;
-Lisp_Object Qfile_error, Qfile_already_exists;
-
+Lisp_Object Qfile_error, Qfile_already_exists, Qfile_date_error;
+Lisp_Object Qexcl;
Lisp_Object Qfile_name_history;
Lisp_Object Qcar_less_than_car;
+static int a_write P_ ((int, Lisp_Object, int, int,
+ Lisp_Object *, struct coding_system *));
+static int e_write P_ ((int, Lisp_Object, int, int, struct coding_system *));
+
+\f
+void
report_file_error (string, data)
char *string;
Lisp_Object data;
{
Lisp_Object errstring;
+ int errorno = errno;
- errstring = build_string (strerror (errno));
-
- /* System error messages are capitalized. Downcase the initial
- unless it is followed by a slash. */
- if (XSTRING (errstring)->data[1] != '/')
- XSTRING (errstring)->data[0] = DOWNCASE (XSTRING (errstring)->data[0]);
+ synchronize_system_messages_locale ();
+ errstring = code_convert_string_norecord (build_string (strerror (errorno)),
+ Vlocale_coding_system, 0);
while (1)
- Fsignal (Qfile_error,
- Fcons (build_string (string), Fcons (errstring, data)));
+ switch (errorno)
+ {
+ case EEXIST:
+ Fsignal (Qfile_already_exists, Fcons (errstring, data));
+ break;
+ default:
+ /* System error messages are capitalized. Downcase the initial
+ unless it is followed by a slash. */
+ if (XSTRING (errstring)->data[1] != '/')
+ XSTRING (errstring)->data[0] = DOWNCASE (XSTRING (errstring)->data[0]);
+
+ Fsignal (Qfile_error,
+ Fcons (build_string (string), Fcons (errstring, data)));
+ }
}
+Lisp_Object
close_file_unwind (fd)
Lisp_Object fd;
{
- close (XFASTINT (fd));
+ emacs_close (XFASTINT (fd));
+ return Qnil;
}
/* Restore point, having saved it as a marker. */
+static Lisp_Object
restore_point_unwind (location)
- Lisp_Object location;
+ Lisp_Object location;
{
- SET_PT (marker_position (location));
+ Fgoto_char (location);
Fset_marker (location, Qnil, Qnil);
+ return Qnil;
}
\f
Lisp_Object Qexpand_file_name;
Lisp_Object Qfile_exists_p;
Lisp_Object Qfile_executable_p;
Lisp_Object Qfile_readable_p;
-Lisp_Object Qfile_symlink_p;
Lisp_Object Qfile_writable_p;
+Lisp_Object Qfile_symlink_p;
+Lisp_Object Qaccess_file;
Lisp_Object Qfile_directory_p;
+Lisp_Object Qfile_regular_p;
Lisp_Object Qfile_accessible_directory_p;
Lisp_Object Qfile_modes;
Lisp_Object Qset_file_modes;
inhibited_handlers = Qnil;
for (chain = Vfile_name_handler_alist; CONSP (chain);
- chain = XCONS (chain)->cdr)
+ chain = XCDR (chain))
{
Lisp_Object elt;
- elt = XCONS (chain)->car;
+ elt = XCAR (chain);
if (CONSP (elt))
{
Lisp_Object string;
- string = XCONS (elt)->car;
+ string = XCAR (elt);
if (STRINGP (string) && fast_string_match (string, filename) >= 0)
{
Lisp_Object handler, tem;
- handler = XCONS (elt)->cdr;
+ handler = XCDR (elt);
tem = Fmemq (handler, inhibited_handlers);
if (NILP (tem))
return handler;
\f
DEFUN ("file-name-directory", Ffile_name_directory, Sfile_name_directory,
1, 1, 0,
- "Return the directory component in file name NAME.\n\
-Return nil if NAME does not include a directory.\n\
+ "Return the directory component in file name FILENAME.\n\
+Return nil if FILENAME does not include a directory.\n\
Otherwise return a directory spec.\n\
Given a Unix syntax file name, returns a string ending in slash;\n\
on VMS, perhaps instead a string ending in `:', `]' or `>'.")
- (file)
- Lisp_Object file;
+ (filename)
+ Lisp_Object filename;
{
register unsigned char *beg;
register unsigned char *p;
Lisp_Object handler;
- CHECK_STRING (file, 0);
+ CHECK_STRING (filename, 0);
/* If the file name has special constructs in it,
call the corresponding file handler. */
- handler = Ffind_file_name_handler (file, Qfile_name_directory);
+ handler = Ffind_file_name_handler (filename, Qfile_name_directory);
if (!NILP (handler))
- return call2 (handler, Qfile_name_directory, file);
+ return call2 (handler, Qfile_name_directory, filename);
#ifdef FILE_SYSTEM_CASE
- file = FILE_SYSTEM_CASE (file);
+ filename = FILE_SYSTEM_CASE (filename);
+#endif
+ beg = XSTRING (filename)->data;
+#ifdef DOS_NT
+ beg = strcpy (alloca (strlen (beg) + 1), beg);
#endif
- beg = XSTRING (file)->data;
- p = beg + XSTRING (file)->size;
+ p = beg + STRING_BYTES (XSTRING (filename));
- while (p != beg && !IS_ANY_SEP (p[-1])
+ while (p != beg && !IS_DIRECTORY_SEP (p[-1])
#ifdef VMS
&& p[-1] != ':' && p[-1] != ']' && p[-1] != '>'
#endif /* VMS */
+#ifdef DOS_NT
+ /* only recognise drive specifier at the beginning */
+ && !(p[-1] == ':'
+ /* handle the "/:d:foo" and "/:foo" cases correctly */
+ && ((p == beg + 2 && !IS_DIRECTORY_SEP (*beg))
+ || (p == beg + 4 && IS_DIRECTORY_SEP (*beg))))
+#endif
) p--;
if (p == beg)
return Qnil;
#ifdef DOS_NT
/* Expansion of "c:" to drive and default directory. */
- /* (NT does the right thing.) */
- if (p == beg + 2 && beg[1] == ':')
+ if (p[-1] == ':')
{
- int drive = (*beg) - 'a';
/* MAXPATHLEN+1 is guaranteed to be enough space for getdefdir. */
- unsigned char *res = alloca (MAXPATHLEN + 5);
- unsigned char *res1;
-#ifdef WINDOWSNT
- res1 = res;
- /* The NT version places the drive letter at the beginning already. */
-#else /* not WINDOWSNT */
- /* On MSDOG we must put the drive letter in by hand. */
- res1 = res + 2;
-#endif /* not WINDOWSNT */
- if (getdefdir (drive + 1, res))
+ unsigned char *res = alloca (MAXPATHLEN + 1);
+ unsigned char *r = res;
+
+ if (p == beg + 4 && IS_DIRECTORY_SEP (*beg) && beg[1] == ':')
{
-#ifdef MSDOS
- res[0] = drive + 'a';
- res[1] = ':';
-#endif /* MSDOS */
- if (IS_DIRECTORY_SEP (res[strlen (res) - 1]))
+ strncpy (res, beg, 2);
+ beg += 2;
+ r += 2;
+ }
+
+ if (getdefdir (toupper (*beg) - 'A' + 1, r))
+ {
+ if (!IS_DIRECTORY_SEP (res[strlen (res) - 1]))
strcat (res, "/");
beg = res;
p = beg + strlen (beg);
}
}
+ CORRECT_DIR_SEPS (beg);
#endif /* DOS_NT */
- return make_string (beg, p - beg);
+
+ if (STRING_MULTIBYTE (filename))
+ return make_string (beg, p - beg);
+ return make_unibyte_string (beg, p - beg);
}
-DEFUN ("file-name-nondirectory", Ffile_name_nondirectory, Sfile_name_nondirectory,
- 1, 1, 0,
- "Return file name NAME sans its directory.\n\
+DEFUN ("file-name-nondirectory", Ffile_name_nondirectory,
+ Sfile_name_nondirectory, 1, 1, 0,
+ "Return file name FILENAME sans its directory.\n\
For example, in a Unix-syntax file name,\n\
this is everything after the last slash,\n\
or the entire name if it contains no slash.")
- (file)
- Lisp_Object file;
+ (filename)
+ Lisp_Object filename;
{
register unsigned char *beg, *p, *end;
Lisp_Object handler;
- CHECK_STRING (file, 0);
+ CHECK_STRING (filename, 0);
/* If the file name has special constructs in it,
call the corresponding file handler. */
- handler = Ffind_file_name_handler (file, Qfile_name_nondirectory);
+ handler = Ffind_file_name_handler (filename, Qfile_name_nondirectory);
if (!NILP (handler))
- return call2 (handler, Qfile_name_nondirectory, file);
+ return call2 (handler, Qfile_name_nondirectory, filename);
- beg = XSTRING (file)->data;
- end = p = beg + XSTRING (file)->size;
+ beg = XSTRING (filename)->data;
+ end = p = beg + STRING_BYTES (XSTRING (filename));
- while (p != beg && !IS_ANY_SEP (p[-1])
+ while (p != beg && !IS_DIRECTORY_SEP (p[-1])
#ifdef VMS
&& p[-1] != ':' && p[-1] != ']' && p[-1] != '>'
#endif /* VMS */
- ) p--;
+#ifdef DOS_NT
+ /* only recognise drive specifier at beginning */
+ && !(p[-1] == ':'
+ /* handle the "/:d:foo" case correctly */
+ && (p == beg + 2 || (p == beg + 4 && IS_DIRECTORY_SEP (*beg))))
+#endif
+ )
+ p--;
- return make_string (p, end - p);
+ if (STRING_MULTIBYTE (filename))
+ return make_string (p, end - p);
+ return make_unibyte_string (p, end - p);
}
-DEFUN ("unhandled-file-name-directory", Funhandled_file_name_directory, Sunhandled_file_name_directory, 1, 1, 0,
+DEFUN ("unhandled-file-name-directory", Funhandled_file_name_directory,
+ Sunhandled_file_name_directory, 1, 1, 0,
"Return a directly usable directory name somehow associated with FILENAME.\n\
A `directly usable' directory name is one that may be used without the\n\
intervention of any file handler.\n\
If FILENAME is a directly usable file itself, return\n\
-(file-name-directory FILENAME).\n\
+\(file-name-directory FILENAME).\n\
The `call-process' and `start-process' functions use this function to\n\
get a current directory to run processes in.")
(filename)
strcpy (out, in);
+ if (size < 0)
+ {
+ out[0] = '.';
+ out[1] = '/';
+ out[2] = 0;
+ return out;
+ }
+
#ifdef VMS
/* Is it already a directory string? */
if (in[size] == ':' || in[size] == ']' || in[size] == '>')
}
#else /* not VMS */
/* For Unix syntax, Append a slash if necessary */
- if (!IS_ANY_SEP (out[size]))
+ if (!IS_DIRECTORY_SEP (out[size]))
{
out[size + 1] = DIRECTORY_SEP;
out[size + 2] = '\0';
}
+#ifdef DOS_NT
+ CORRECT_DIR_SEPS (out);
+#endif
#endif /* not VMS */
return out;
}
if (!NILP (handler))
return call2 (handler, Qfile_name_as_directory, file);
- buf = (char *) alloca (XSTRING (file)->size + 10);
+ buf = (char *) alloca (STRING_BYTES (XSTRING (file)) + 10);
return build_string (file_name_as_directory (buf, XSTRING (file)->data));
}
\f
* On VMS:
* xyzzy:[mukesh.emacs] => xyzzy:[mukesh]emacs.dir.1
* xyzzy:[mukesh] => xyzzy:[000000]mukesh.dir.1
- * On UNIX, it's simple: just make sure there is a terminating /
+ * On UNIX, it's simple: just make sure there isn't a terminating /
* Value is nonzero if the string output is different from the input.
*/
+int
directory_file_name (src, dst)
char *src, *dst;
{
nam.nam$b_nop |= NAM$M_SYNCHK;
/* We call SYS$PARSE to handle such things as [--] for us. */
- if (SYS$PARSE(&fab, 0, 0) == RMS$_NORMAL)
+ if (SYS$PARSE (&fab, 0, 0) == RMS$_NORMAL)
{
slen = nam.nam$b_esl;
if (esa[slen - 1] == ';' && esa[slen - 2] == '.')
then translate the device and recurse. */
if (dst[slen - 1] == ':'
&& dst[slen - 2] != ':' /* skip decnet nodes */
- && strcmp(src + slen, "[000000]") == 0)
+ && strcmp (src + slen, "[000000]") == 0)
{
dst[slen - 1] = '\0';
if ((ptr = egetenv (dst))
/* Process as Unix format: just remove any final slash.
But leave "/" unchanged; do not change it to "". */
strcpy (dst, src);
- if (slen > 1
+#ifdef APOLLO
+ /* Handle // as root for apollo's. */
+ if ((slen > 2 && dst[slen - 1] == '/')
+ || (slen > 1 && dst[0] != '/' && dst[slen - 1] == '/'))
+ dst[slen - 1] = 0;
+#else
+ if (slen > 1
&& IS_DIRECTORY_SEP (dst[slen - 1])
- && !IS_DEVICE_SEP (dst[slen - 2]))
+#ifdef DOS_NT
+ && !IS_ANY_SEP (dst[slen - 2])
+#endif
+ )
dst[slen - 1] = 0;
+#endif
+#ifdef DOS_NT
+ CORRECT_DIR_SEPS (dst);
+#endif
return 1;
}
DEFUN ("directory-file-name", Fdirectory_file_name, Sdirectory_file_name,
1, 1, 0,
- "Returns the file name of the directory named DIR.\n\
-This is the name of the file that holds the data for the directory DIR.\n\
+ "Returns the file name of the directory named DIRECTORY.\n\
+This is the name of the file that holds the data for the directory DIRECTORY.\n\
This operation exists because a directory is also a file, but its name as\n\
a directory is different from its name as a file.\n\
In Unix-syntax, this function just removes the final slash.\n\
/* 20 extra chars is insufficient for VMS, since we might perform a
logical name translation. an equivalence string can be up to 255
chars long, so grab that much extra space... - sss */
- buf = (char *) alloca (XSTRING (directory)->size + 20 + 255);
+ buf = (char *) alloca (STRING_BYTES (XSTRING (directory)) + 20 + 255);
#else
- buf = (char *) alloca (XSTRING (directory)->size + 20);
+ buf = (char *) alloca (STRING_BYTES (XSTRING (directory)) + 20);
#endif
directory_file_name (XSTRING (directory)->data, buf);
return build_string (buf);
}
+static char make_temp_name_tbl[64] =
+{
+ 'A','B','C','D','E','F','G','H',
+ 'I','J','K','L','M','N','O','P',
+ 'Q','R','S','T','U','V','W','X',
+ 'Y','Z','a','b','c','d','e','f',
+ 'g','h','i','j','k','l','m','n',
+ 'o','p','q','r','s','t','u','v',
+ 'w','x','y','z','0','1','2','3',
+ '4','5','6','7','8','9','-','_'
+};
+static unsigned make_temp_name_count, make_temp_name_count_initialized_p;
+
DEFUN ("make-temp-name", Fmake_temp_name, Smake_temp_name, 1, 1, 0,
"Generate temporary file name (string) starting with PREFIX (a string).\n\
The Emacs process number forms part of the result,\n\
-so there is no danger of generating a name being used by another process.")
+so there is no danger of generating a name being used by another process.\n\
+\n\
+In addition, this function makes an attempt to choose a name\n\
+which has no existing file. To make this work,\n\
+PREFIX should be an absolute file name.\n\
+\n\
+There is a race condition between calling `make-temp-name' and creating the\n\
+file which opens all kinds of security holes. For that reason, you should\n\
+probably use `make-temp-file' instead.")
(prefix)
Lisp_Object prefix;
{
Lisp_Object val;
- val = concat2 (prefix, build_string ("XXXXXX"));
- mktemp (XSTRING (val)->data);
- return val;
+ int len;
+ int pid;
+ unsigned char *p, *data;
+ char pidbuf[20];
+ int pidlen;
+
+ CHECK_STRING (prefix, 0);
+
+ /* VAL is created by adding 6 characters to PREFIX. The first
+ three are the PID of this process, in base 64, and the second
+ three are incremented if the file already exists. This ensures
+ 262144 unique file names per PID per PREFIX. */
+
+ pid = (int) getpid ();
+
+#ifdef HAVE_LONG_FILE_NAMES
+ sprintf (pidbuf, "%d", pid);
+ pidlen = strlen (pidbuf);
+#else
+ pidbuf[0] = make_temp_name_tbl[pid & 63], pid >>= 6;
+ pidbuf[1] = make_temp_name_tbl[pid & 63], pid >>= 6;
+ pidbuf[2] = make_temp_name_tbl[pid & 63], pid >>= 6;
+ pidlen = 3;
+#endif
+
+ len = XSTRING (prefix)->size;
+ val = make_uninit_string (len + 3 + pidlen);
+ data = XSTRING (val)->data;
+ bcopy(XSTRING (prefix)->data, data, len);
+ p = data + len;
+
+ bcopy (pidbuf, p, pidlen);
+ p += pidlen;
+
+ /* Here we try to minimize useless stat'ing when this function is
+ invoked many times successively with the same PREFIX. We achieve
+ this by initializing count to a random value, and incrementing it
+ afterwards.
+
+ We don't want make-temp-name to be called while dumping,
+ because then make_temp_name_count_initialized_p would get set
+ and then make_temp_name_count would not be set when Emacs starts. */
+
+ if (!make_temp_name_count_initialized_p)
+ {
+ make_temp_name_count = (unsigned) time (NULL);
+ make_temp_name_count_initialized_p = 1;
+ }
+
+ while (1)
+ {
+ struct stat ignored;
+ unsigned num = make_temp_name_count;
+
+ p[0] = make_temp_name_tbl[num & 63], num >>= 6;
+ p[1] = make_temp_name_tbl[num & 63], num >>= 6;
+ p[2] = make_temp_name_tbl[num & 63], num >>= 6;
+
+ /* Poor man's congruential RN generator. Replace with
+ ++make_temp_name_count for debugging. */
+ make_temp_name_count += 25229;
+ make_temp_name_count %= 225307;
+
+ if (stat (data, &ignored) < 0)
+ {
+ /* We want to return only if errno is ENOENT. */
+ if (errno == ENOENT)
+ return val;
+ else
+ /* The error here is dubious, but there is little else we
+ can do. The alternatives are to return nil, which is
+ as bad as (and in many cases worse than) throwing the
+ error, or to ignore the error, which will likely result
+ in looping through 225307 stat's, which is not only
+ dog-slow, but also useless since it will fallback to
+ the errow below, anyway. */
+ report_file_error ("Cannot create temporary name for prefix `%s'",
+ Fcons (prefix, Qnil));
+ /* not reached */
+ }
+ }
+
+ error ("Cannot create temporary name for prefix `%s'",
+ XSTRING (prefix)->data);
+ return Qnil;
}
+
\f
DEFUN ("expand-file-name", Fexpand_file_name, Sexpand_file_name, 1, 2, 0,
- "Convert FILENAME to absolute, and canonicalize it.\n\
-Second arg DEFAULT is directory to start with if FILENAME is relative\n\
- (does not start with slash); if DEFAULT is nil or missing,\n\
+ "Convert filename NAME to absolute, and canonicalize it.\n\
+Second arg DEFAULT-DIRECTORY is directory to start with if NAME is relative\n\
+ (does not start with slash); if DEFAULT-DIRECTORY is nil or missing,\n\
the current buffer's value of default-directory is used.\n\
-Path components that are `.' are removed, and \n\
-path components followed by `..' are removed, along with the `..' itself;\n\
+File name components that are `.' are removed, and \n\
+so are file name components followed by `..', along with the `..' itself;\n\
note that these simplifications are done without checking the resulting\n\
-paths in the file system.\n\
+file names in the file system.\n\
An initial `~/' expands to your home directory.\n\
An initial `~USER/' expands to USER's home directory.\n\
See also the function `substitute-in-file-name'.")
- (name, defalt)
- Lisp_Object name, defalt;
+ (name, default_directory)
+ Lisp_Object name, default_directory;
{
unsigned char *nm;
-
+
register unsigned char *newdir, *p, *o;
int tlen;
unsigned char *target;
int dots = 0;
#endif /* VMS */
#ifdef DOS_NT
- /* Demacs 1.1.2 91/10/20 Manabu Higashida */
- int drive = -1;
- int relpath = 0;
- unsigned char *tmp, *defdir;
+ int drive = 0;
+ int collapse_newdir = 1;
+ int is_escaped = 0;
#endif /* DOS_NT */
+ int length;
Lisp_Object handler;
-
+
CHECK_STRING (name, 0);
/* If the file name has special constructs in it,
call the corresponding file handler. */
handler = Ffind_file_name_handler (name, Qexpand_file_name);
if (!NILP (handler))
- return call3 (handler, Qexpand_file_name, name, defalt);
- if (!NILP (defalt))
+ return call3 (handler, Qexpand_file_name, name, default_directory);
+
+ /* Use the buffer's default-directory if DEFAULT_DIRECTORY is omitted. */
+ if (NILP (default_directory))
+ default_directory = current_buffer->directory;
+ if (! STRINGP (default_directory))
+ default_directory = build_string ("/");
+
+ if (!NILP (default_directory))
{
- handler = Ffind_file_name_handler (defalt, Qexpand_file_name);
+ handler = Ffind_file_name_handler (default_directory, Qexpand_file_name);
if (!NILP (handler))
- return call3 (handler, Qexpand_file_name, name, defalt);
+ return call3 (handler, Qexpand_file_name, name, default_directory);
}
- /* Use the buffer's default-directory if DEFALT is omitted. */
- if (NILP (defalt))
- defalt = current_buffer->directory;
- CHECK_STRING (defalt, 1);
-
- o = XSTRING (defalt)->data;
+ o = XSTRING (default_directory)->data;
- /* Make sure DEFALT is properly expanded.
+ /* Make sure DEFAULT_DIRECTORY is properly expanded.
It would be better to do this down below where we actually use
- defalt. Unfortunately, calling Fexpand_file_name recursively
+ default_directory. Unfortunately, calling Fexpand_file_name recursively
could invoke GC, and the strings might be relocated. This would
be annoying because we have pointers into strings lying around
that would need adjusting, and people would add new pointers to
Putting this call here avoids all that crud.
The EQ test avoids infinite recursion. */
- if (! NILP (defalt) && !EQ (defalt, name)
- /* This saves time in a common case. */
- && ! (XSTRING (defalt)->size >= 3
- && IS_DIRECTORY_SEP (XSTRING (defalt)->data[0])
- && IS_DEVICE_SEP (XSTRING (defalt)->data[1])))
+ if (! NILP (default_directory) && !EQ (default_directory, name)
+ /* Save time in some common cases - as long as default_directory
+ is not relative, it can be canonicalized with name below (if it
+ is needed at all) without requiring it to be expanded now. */
+#ifdef DOS_NT
+ /* Detect MSDOS file names with drive specifiers. */
+ && ! (IS_DRIVE (o[0]) && IS_DEVICE_SEP (o[1]) && IS_DIRECTORY_SEP (o[2]))
+#ifdef WINDOWSNT
+ /* Detect Windows file names in UNC format. */
+ && ! (IS_DIRECTORY_SEP (o[0]) && IS_DIRECTORY_SEP (o[1]))
+#endif
+#else /* not DOS_NT */
+ /* Detect Unix absolute file names (/... alone is not absolute on
+ DOS or Windows). */
+ && ! (IS_DIRECTORY_SEP (o[0]))
+#endif /* not DOS_NT */
+ )
{
struct gcpro gcpro1;
GCPRO1 (name);
- defalt = Fexpand_file_name (defalt, Qnil);
+ default_directory = Fexpand_file_name (default_directory, Qnil);
UNGCPRO;
}
#endif
nm = XSTRING (name)->data;
-
-#ifdef MSDOS
- /* First map all backslashes to slashes. */
- dostounix_filename (nm = strcpy (alloca (strlen (nm) + 1), nm));
-#endif
#ifdef DOS_NT
- /* Now strip drive name. */
- {
- unsigned char *colon = rindex (nm, ':');
- if (colon)
- if (nm == colon)
- nm++;
- else
- {
- drive = tolower (colon[-1]) - 'a';
- nm = colon + 1;
- if (!IS_DIRECTORY_SEP (*nm))
- {
- defdir = alloca (MAXPATHLEN + 1);
- relpath = getdefdir (drive + 1, defdir);
- }
- }
- }
+ /* We will force directory separators to be either all \ or /, so make
+ a local copy to modify, even if there ends up being no change. */
+ nm = strcpy (alloca (strlen (nm) + 1), nm);
+
+ /* Note if special escape prefix is present, but remove for now. */
+ if (nm[0] == '/' && nm[1] == ':')
+ {
+ is_escaped = 1;
+ nm += 2;
+ }
+
+ /* Find and remove drive specifier if present; this makes nm absolute
+ even if the rest of the name appears to be relative. Only look for
+ drive specifier at the beginning. */
+ if (IS_DRIVE (nm[0]) && IS_DEVICE_SEP (nm[1]))
+ {
+ drive = nm[0];
+ nm += 2;
+ }
+
+#ifdef WINDOWSNT
+ /* If we see "c://somedir", we want to strip the first slash after the
+ colon when stripping the drive letter. Otherwise, this expands to
+ "//somedir". */
+ if (drive && IS_DIRECTORY_SEP (nm[0]) && IS_DIRECTORY_SEP (nm[1]))
+ nm++;
+#endif /* WINDOWSNT */
#endif /* DOS_NT */
- /* If nm is absolute, flush ...// and detect /./ and /../.
- If no /./ or /../ we can return right away. */
+#ifdef WINDOWSNT
+ /* Discard any previous drive specifier if nm is now in UNC format. */
+ if (IS_DIRECTORY_SEP (nm[0]) && IS_DIRECTORY_SEP (nm[1]))
+ {
+ drive = 0;
+ }
+#endif
+
+ /* If nm is absolute, look for /./ or /../ sequences; if none are
+ found, we can probably return right away. We will avoid allocating
+ a new string if name is already fully expanded. */
if (
IS_DIRECTORY_SEP (nm[0])
+#ifdef MSDOS
+ && drive && !is_escaped
+#endif
+#ifdef WINDOWSNT
+ && (drive || IS_DIRECTORY_SEP (nm[1])) && !is_escaped
+#endif
#ifdef VMS
|| index (nm, ':')
#endif /* VMS */
p = nm;
while (*p)
{
- /* Since we know the path is absolute, we can assume that each
+ /* Since we know the name is absolute, we can assume that each
element starts with a "/". */
- /* "//" anywhere isn't necessarily hairy; we just start afresh
- with the second slash. */
- if (IS_DIRECTORY_SEP (p[0]) && IS_DIRECTORY_SEP (p[1])
-#ifdef APOLLO
- /* // at start of filename is meaningful on Apollo system */
- && nm != p
-#endif /* APOLLO */
-#ifdef WINDOWSNT
- /* \\ or // at the start of a pathname is meaningful on NT. */
- && nm != p
-#endif /* WINDOWSNT */
- )
- nm = p + 1;
-
- /* "~" is hairy as the start of any path element. */
- if (IS_DIRECTORY_SEP (p[0]) && p[1] == '~')
- nm = p + 1, lose = 1;
-
/* "." and ".." are hairy. */
if (IS_DIRECTORY_SEP (p[0])
&& p[1] == '.'
nm = brack + 1;
brack = 0;
}
- /* if /pathname/dev:, move nm to dev: */
+ /* if /name/dev:, move nm to dev: */
else if (slash)
nm = slash + 1;
/* if node::dev:, move colon following dev */
if (index (nm, '/'))
return build_string (sys_translate_unix (nm));
#endif /* VMS */
-#ifndef DOS_NT
+#ifdef DOS_NT
+ /* Make sure directories are all separated with / or \ as
+ desired, but avoid allocation of a new string when not
+ required. */
+ CORRECT_DIR_SEPS (nm);
+#ifdef WINDOWSNT
+ if (IS_DIRECTORY_SEP (nm[1]))
+ {
+ if (strcmp (nm, XSTRING (name)->data) != 0)
+ name = build_string (nm);
+ }
+ else
+#endif
+ /* drive must be set, so this is okay */
+ if (strcmp (nm - 2, XSTRING (name)->data) != 0)
+ {
+ name = make_string (nm - 2, p - nm + 2);
+ XSTRING (name)->data[0] = DRIVE_LETTER (drive);
+ XSTRING (name)->data[1] = ':';
+ }
+ return name;
+#else /* not DOS_NT */
if (nm == XSTRING (name)->data)
return name;
return build_string (nm);
}
}
- /* Now determine directory to start with and put it in newdir */
+ /* At this point, nm might or might not be an absolute file name. We
+ need to expand ~ or ~user if present, otherwise prefix nm with
+ default_directory if nm is not absolute, and finally collapse /./
+ and /foo/../ sequences.
+
+ We set newdir to be the appropriate prefix if one is needed:
+ - the relevant user directory if nm starts with ~ or ~user
+ - the specified drive's working dir (DOS/NT only) if nm does not
+ start with /
+ - the value of default_directory.
+
+ Note that these prefixes are not guaranteed to be absolute (except
+ for the working dir of a drive). Therefore, to ensure we always
+ return an absolute name, if the final prefix is not absolute we
+ append it to the current working directory. */
newdir = 0;
{
if (!(newdir = (unsigned char *) egetenv ("HOME")))
newdir = (unsigned char *) "";
+ nm++;
#ifdef DOS_NT
- dostounix_filename (newdir);
+ collapse_newdir = 0;
#endif
- nm++;
#ifdef VMS
nm++; /* Don't leave the slash in nm. */
#endif /* VMS */
bcopy ((char *) nm, o, p - nm);
o [p - nm] = 0;
-#ifdef WINDOWSNT
- newdir = (unsigned char *) egetenv ("HOME");
- dostounix_filename (newdir);
-#else /* not WINDOWSNT */
pw = (struct passwd *) getpwnam (o + 1);
if (pw)
{
nm = p + 1; /* skip the terminator */
#else
nm = p;
+#ifdef DOS_NT
+ collapse_newdir = 0;
+#endif
#endif /* VMS */
}
-#endif /* not WINDOWSNT */
/* If we don't find a user of that name, leave the name
unchanged; don't move nm forward to p. */
}
}
- if (!IS_ANY_SEP (nm[0])
-#ifdef VMS
- && !index (nm, ':')
-#endif /* not VMS */
#ifdef DOS_NT
- && drive == -1
-#endif /* DOS_NT */
- && !newdir)
+ /* On DOS and Windows, nm is absolute if a drive name was specified;
+ use the drive's current directory as the prefix if needed. */
+ if (!newdir && drive)
{
- newdir = XSTRING (defalt)->data;
+ /* Get default directory if needed to make nm absolute. */
+ if (!IS_DIRECTORY_SEP (nm[0]))
+ {
+ newdir = alloca (MAXPATHLEN + 1);
+ if (!getdefdir (toupper (drive) - 'A' + 1, newdir))
+ newdir = NULL;
+ }
+ if (!newdir)
+ {
+ /* Either nm starts with /, or drive isn't mounted. */
+ newdir = alloca (4);
+ newdir[0] = DRIVE_LETTER (drive);
+ newdir[1] = ':';
+ newdir[2] = '/';
+ newdir[3] = 0;
+ }
}
-
-#ifdef DOS_NT
- if (newdir == 0 && relpath)
- newdir = defdir;
#endif /* DOS_NT */
- if (newdir != 0)
- {
- /* Get rid of any slash at the end of newdir. */
- int length = strlen (newdir);
- /* Adding `length > 1 &&' makes ~ expand into / when homedir
- is the root dir. People disagree about whether that is right.
- Anyway, we can't take the risk of this change now. */
-#ifdef MSDOS
- if (newdir[1] != ':' && length > 1)
+
+ /* Finally, if no prefix has been specified and nm is not absolute,
+ then it must be expanded relative to default_directory. */
+
+ if (1
+#ifndef DOS_NT
+ /* /... alone is not absolute on DOS and Windows. */
+ && !IS_DIRECTORY_SEP (nm[0])
#endif
- if (IS_DIRECTORY_SEP (newdir[length - 1]))
+#ifdef WINDOWSNT
+ && !(IS_DIRECTORY_SEP (nm[0]) && IS_DIRECTORY_SEP (nm[1]))
+#endif
+#ifdef VMS
+ && !index (nm, ':')
+#endif
+ && !newdir)
+ {
+ newdir = XSTRING (default_directory)->data;
+#ifdef DOS_NT
+ /* Note if special escape prefix is present, but remove for now. */
+ if (newdir[0] == '/' && newdir[1] == ':')
{
- unsigned char *temp = (unsigned char *) alloca (length);
- bcopy (newdir, temp, length - 1);
- temp[length - 1] = 0;
- newdir = temp;
+ is_escaped = 1;
+ newdir += 2;
}
- tlen = length + 1;
+#endif
}
- else
- tlen = 0;
- /* Now concatenate the directory and name to new space in the stack frame */
- tlen += strlen (nm) + 1;
#ifdef DOS_NT
- /* Add reserved space for drive name. (The Microsoft x86 compiler
- produces incorrect code if the following two lines are combined.) */
- target = (unsigned char *) alloca (tlen + 2);
- target += 2;
-#else /* not DOS_NT */
- target = (unsigned char *) alloca (tlen);
-#endif /* not DOS_NT */
- *target = 0;
-
if (newdir)
{
-#ifndef VMS
- if (nm[0] == 0 || IS_DIRECTORY_SEP (nm[0]))
- strcpy (target, newdir);
- else
+ /* First ensure newdir is an absolute name. */
+ if (
+ /* Detect MSDOS file names with drive specifiers. */
+ ! (IS_DRIVE (newdir[0])
+ && IS_DEVICE_SEP (newdir[1]) && IS_DIRECTORY_SEP (newdir[2]))
+#ifdef WINDOWSNT
+ /* Detect Windows file names in UNC format. */
+ && ! (IS_DIRECTORY_SEP (newdir[0]) && IS_DIRECTORY_SEP (newdir[1]))
#endif
- file_name_as_directory (target, newdir);
- }
+ )
+ {
+ /* Effectively, let newdir be (expand-file-name newdir cwd).
+ Because of the admonition against calling expand-file-name
+ when we have pointers into lisp strings, we accomplish this
+ indirectly by prepending newdir to nm if necessary, and using
+ cwd (or the wd of newdir's drive) as the new newdir. */
+
+ if (IS_DRIVE (newdir[0]) && newdir[1] == ':')
+ {
+ drive = newdir[0];
+ newdir += 2;
+ }
+ if (!IS_DIRECTORY_SEP (nm[0]))
+ {
+ char * tmp = alloca (strlen (newdir) + strlen (nm) + 2);
+ file_name_as_directory (tmp, newdir);
+ strcat (tmp, nm);
+ nm = tmp;
+ }
+ newdir = alloca (MAXPATHLEN + 1);
+ if (drive)
+ {
+ if (!getdefdir (toupper (drive) - 'A' + 1, newdir))
+ newdir = "/";
+ }
+ else
+ getwd (newdir);
+ }
+
+ /* Strip off drive name from prefix, if present. */
+ if (IS_DRIVE (newdir[0]) && newdir[1] == ':')
+ {
+ drive = newdir[0];
+ newdir += 2;
+ }
+
+ /* Keep only a prefix from newdir if nm starts with slash
+ (//server/share for UNC, nothing otherwise). */
+ if (IS_DIRECTORY_SEP (nm[0]) && collapse_newdir)
+ {
+#ifdef WINDOWSNT
+ if (IS_DIRECTORY_SEP (newdir[0]) && IS_DIRECTORY_SEP (newdir[1]))
+ {
+ newdir = strcpy (alloca (strlen (newdir) + 1), newdir);
+ p = newdir + 2;
+ while (*p && !IS_DIRECTORY_SEP (*p)) p++;
+ p++;
+ while (*p && !IS_DIRECTORY_SEP (*p)) p++;
+ *p = 0;
+ }
+ else
+#endif
+ newdir = "";
+ }
+ }
+#endif /* DOS_NT */
+
+ if (newdir)
+ {
+ /* Get rid of any slash at the end of newdir, unless newdir is
+ just / or // (an incomplete UNC name). */
+ length = strlen (newdir);
+ if (length > 1 && IS_DIRECTORY_SEP (newdir[length - 1])
+#ifdef WINDOWSNT
+ && !(length == 2 && IS_DIRECTORY_SEP (newdir[0]))
+#endif
+ )
+ {
+ unsigned char *temp = (unsigned char *) alloca (length);
+ bcopy (newdir, temp, length - 1);
+ temp[length - 1] = 0;
+ newdir = temp;
+ }
+ tlen = length + 1;
+ }
+ else
+ tlen = 0;
+
+ /* Now concatenate the directory and name to new space in the stack frame */
+ tlen += strlen (nm) + 1;
+#ifdef DOS_NT
+ /* Reserve space for drive specifier and escape prefix, since either
+ or both may need to be inserted. (The Microsoft x86 compiler
+ produces incorrect code if the following two lines are combined.) */
+ target = (unsigned char *) alloca (tlen + 4);
+ target += 4;
+#else /* not DOS_NT */
+ target = (unsigned char *) alloca (tlen);
+#endif /* not DOS_NT */
+ *target = 0;
+
+ if (newdir)
+ {
+#ifndef VMS
+ if (nm[0] == 0 || IS_DIRECTORY_SEP (nm[0]))
+ {
+#ifdef DOS_NT
+ /* If newdir is effectively "C:/", then the drive letter will have
+ been stripped and newdir will be "/". Concatenating with an
+ absolute directory in nm produces "//", which will then be
+ incorrectly treated as a network share. Ignore newdir in
+ this case (keeping the drive letter). */
+ if (!(drive && nm[0] && IS_DIRECTORY_SEP (newdir[0])
+ && newdir[1] == '\0'))
+#endif
+ strcpy (target, newdir);
+ }
+ else
+#endif
+ file_name_as_directory (target, newdir);
+ }
strcat (target, nm);
#ifdef VMS
strcpy (target, sys_translate_unix (target));
#endif /* VMS */
+ /* ASSERT (IS_DIRECTORY_SEP (target[0])) if not VMS */
+
/* Now canonicalize by removing /. and /foo/.. if they appear. */
p = target;
{
*o++ = *p++;
}
-#ifdef WINDOWSNT
- else if (!strncmp (p, "\\\\", 2) || !strncmp (p, "//", 2))
-#else /* not WINDOWSNT */
- else if (!strncmp (p, "//", 2)
-#endif /* not WINDOWSNT */
-#ifdef APOLLO
- /* // at start of filename is meaningful in Apollo system */
- && o != target
-#endif /* APOLLO */
-#ifdef WINDOWSNT
- /* \\ at start of filename is meaningful in Windows-NT */
- && o != target
-#endif /* WINDOWSNT */
- )
- {
- o = target;
- p++;
- }
else if (IS_DIRECTORY_SEP (p[0])
&& p[1] == '.'
&& (IS_DIRECTORY_SEP (p[2])
*o++ = *p;
p += 2;
}
-#ifdef WINDOWSNT
- else if (!strncmp (p, "\\..", 3) || !strncmp (p, "/..", 3))
-#else /* not WINDOWSNT */
- else if (!strncmp (p, "/..", 3)
-#endif /* not WINDOWSNT */
+ else if (IS_DIRECTORY_SEP (p[0]) && p[1] == '.' && p[2] == '.'
/* `/../' is the "superroot" on certain file systems. */
&& o != target
&& (IS_DIRECTORY_SEP (p[3]) || p[3] == 0))
{
while (o != target && (--o) && !IS_DIRECTORY_SEP (*o))
;
-#ifdef APOLLO
- if (o == target + 1 && o[-1] == '/' && o[0] == '/')
- ++o;
- else
-#endif /* APOLLO */
-#ifdef WINDOWSNT
- if (o == target + 1 && (o[-1] == '/' && o[0] == '/')
- || (o[-1] == '\\' && o[0] == '\\'))
- ++o;
- else
-#endif /* WINDOWSNT */
- if (o == target && IS_ANY_SEP (*o))
+ /* Keep initial / only if this is the whole name. */
+ if (o == target && IS_ANY_SEP (*o) && p[3] == 0)
++o;
p += 3;
}
}
#ifdef DOS_NT
- /* at last, set drive name. */
- if (target[1] != ':'
+ /* At last, set drive name. */
#ifdef WINDOWSNT
- /* Allow network paths that look like "\\foo" */
- && !(IS_DIRECTORY_SEP (target[0]) && IS_DIRECTORY_SEP (target[1]))
+ /* Except for network file name. */
+ if (!(IS_DIRECTORY_SEP (target[0]) && IS_DIRECTORY_SEP (target[1])))
#endif /* WINDOWSNT */
- )
{
+ if (!drive) abort ();
target -= 2;
- target[0] = (drive < 0 ? getdisk () : drive) + 'a';
+ target[0] = DRIVE_LETTER (drive);
target[1] = ':';
}
+ /* Reinsert the escape prefix if required. */
+ if (is_escaped)
+ {
+ target -= 2;
+ target[0] = '/';
+ target[1] = ':';
+ }
+ CORRECT_DIR_SEPS (target);
#endif /* DOS_NT */
return make_string (target, o - target);
Lisp_Object name, defalt;
{
unsigned char *nm;
-
+
register unsigned char *newdir, *p, *o;
int tlen;
unsigned char *target;
int lbrack = 0, rbrack = 0;
int dots = 0;
#endif /* VMS */
-
+
CHECK_STRING (name, 0);
#ifdef VMS
#endif
nm = XSTRING (name)->data;
-
+
/* If nm is absolute, flush ...// and detect /./ and /../.
- If no /./ or /../ we can return right away. */
+ If no /./ or /../ we can return right away. */
if (
nm[0] == '/'
#ifdef VMS
{
if (p[0] == '/' && p[1] == '/'
#ifdef APOLLO
- /* // at start of filename is meaningful on Apollo system */
+ /* // at start of filename is meaningful on Apollo system. */
&& nm != p
#endif /* APOLLO */
)
nm = brack + 1;
brack = 0;
}
- /* if /pathname/dev:, move nm to dev: */
+ /* If /name/dev:, move nm to dev: */
else if (slash)
nm = slash + 1;
- /* if node::dev:, move colon following dev */
+ /* If node::dev:, move colon following dev */
else if (colon && colon[-1] == ':')
colon = p;
- /* if dev1:dev2:, move nm to dev2: */
+ /* If dev1:dev2:, move nm to dev2: */
else if (colon && colon[-1] != ':')
{
nm = colon + 1;
}
else if (!strncmp (p, "//", 2)
#ifdef APOLLO
- /* // at start of filename is meaningful in Apollo system */
+ /* // at start of filename is meaningful in Apollo system. */
&& o != target
#endif /* APOLLO */
)
If `/~' appears, all of FILENAME through that `/' is discarded.\n\n\
On VMS, `$' substitution is not done; this function does little and only\n\
duplicates what `expand-file-name' does.")
- (string)
- Lisp_Object string;
+ (filename)
+ Lisp_Object filename;
{
unsigned char *nm;
unsigned char *xnm;
Lisp_Object handler;
- CHECK_STRING (string, 0);
+ CHECK_STRING (filename, 0);
/* If the file name has special constructs in it,
call the corresponding file handler. */
- handler = Ffind_file_name_handler (string, Qsubstitute_in_file_name);
+ handler = Ffind_file_name_handler (filename, Qsubstitute_in_file_name);
if (!NILP (handler))
- return call2 (handler, Qsubstitute_in_file_name, string);
+ return call2 (handler, Qsubstitute_in_file_name, filename);
- nm = XSTRING (string)->data;
-#ifdef MSDOS
- dostounix_filename (nm = strcpy (alloca (strlen (nm) + 1), nm));
- substituted = !strcmp (nm, XSTRING (string)->data);
+ nm = XSTRING (filename)->data;
+#ifdef DOS_NT
+ nm = strcpy (alloca (strlen (nm) + 1), nm);
+ CORRECT_DIR_SEPS (nm);
+ substituted = (strcmp (nm, XSTRING (filename)->data) != 0);
#endif
- endp = nm + XSTRING (string)->size;
+ endp = nm + STRING_BYTES (XSTRING (filename));
- /* If /~ or // appears, discard everything through first slash. */
+ /* If /~ or // appears, discard everything through first slash. */
for (p = nm; p != endp; p++)
{
- if ((p[0] == '~' ||
-#ifdef APOLLO
- /* // at start of file name is meaningful in Apollo system */
- (p[0] == '/' && p - 1 != nm)
-#else /* not APOLLO */
-#ifdef WINDOWSNT
- (IS_DIRECTORY_SEP (p[0]) && p - 1 != nm)
-#else /* not WINDOWSNT */
- p[0] == '/'
-#endif /* not WINDOWSNT */
-#endif /* not APOLLO */
+ if ((p[0] == '~'
+#if defined (APOLLO) || defined (WINDOWSNT)
+ /* // at start of file name is meaningful in Apollo and
+ WindowsNT systems. */
+ || (IS_DIRECTORY_SEP (p[0]) && p - 1 != nm)
+#else /* not (APOLLO || WINDOWSNT) */
+ || IS_DIRECTORY_SEP (p[0])
+#endif /* not (APOLLO || WINDOWSNT) */
)
&& p != nm
&& (0
substituted = 1;
}
#ifdef DOS_NT
- if (p[0] && p[1] == ':')
+ /* see comment in expand-file-name about drive specifiers */
+ else if (IS_DRIVE (p[0]) && p[1] == ':'
+ && p > nm && IS_DIRECTORY_SEP (p[-1]))
{
nm = p;
substituted = 1;
}
if (!substituted)
- return string;
+ return filename;
/* If substitution required, recopy the string and do it */
/* Make space in stack frame for the new copy */
- xnm = (unsigned char *) alloca (XSTRING (string)->size + total + 1);
+ xnm = (unsigned char *) alloca (STRING_BYTES (XSTRING (filename)) + total + 1);
x = xnm;
/* Copy the rest of the name through, replacing $ constructs with values */
if (!o)
goto badvar;
- strcpy (x, o);
- x += strlen (o);
+ if (STRING_MULTIBYTE (filename))
+ {
+ /* If the original string is multibyte,
+ convert what we substitute into multibyte. */
+ while (*o)
+ {
+ int c = unibyte_char_to_multibyte (*o++);
+ x += CHAR_STRING (c, x);
+ }
+ }
+ else
+ {
+ strcpy (x, o);
+ x += strlen (o);
+ }
}
*x = 0;
- /* If /~ or // appears, discard everything through first slash. */
+ /* If /~ or // appears, discard everything through first slash. */
for (p = xnm; p != x; p++)
if ((p[0] == '~'
-#ifdef APOLLO
- /* // at start of file name is meaningful in Apollo system */
- || (p[0] == '/' && p - 1 != xnm)
-#else /* not APOLLO */
-#ifdef WINDOWSNT
+#if defined (APOLLO) || defined (WINDOWSNT)
|| (IS_DIRECTORY_SEP (p[0]) && p - 1 != xnm)
-#else /* not WINDOWSNT */
- || p[0] == '/'
-#endif /* not WINDOWSNT */
-#endif /* not APOLLO */
+#else /* not (APOLLO || WINDOWSNT) */
+ || IS_DIRECTORY_SEP (p[0])
+#endif /* not (APOLLO || WINDOWSNT) */
)
- && p != nm && IS_DIRECTORY_SEP (p[-1]))
+ && p != xnm && IS_DIRECTORY_SEP (p[-1]))
xnm = p;
#ifdef DOS_NT
- else if (p[0] && p[1] == ':')
- xnm = p;
+ else if (IS_DRIVE (p[0]) && p[1] == ':'
+ && p > xnm && IS_DIRECTORY_SEP (p[-1]))
+ xnm = p;
#endif
- return make_string (xnm, x - xnm);
+ if (STRING_MULTIBYTE (filename))
+ return make_string (xnm, x - xnm);
+ return make_unibyte_string (xnm, x - xnm);
badsubst:
error ("Bad format environment-variable substitution");
expand_and_dir_to_file (filename, defdir)
Lisp_Object filename, defdir;
{
- register Lisp_Object abspath;
+ register Lisp_Object absname;
- abspath = Fexpand_file_name (filename, defdir);
+ absname = Fexpand_file_name (filename, defdir);
#ifdef VMS
{
- register int c = XSTRING (abspath)->data[XSTRING (abspath)->size - 1];
+ register int c = XSTRING (absname)->data[STRING_BYTES (XSTRING (absname)) - 1];
if (c == ':' || c == ']' || c == '>')
- abspath = Fdirectory_file_name (abspath);
+ absname = Fdirectory_file_name (absname);
}
#else
- /* Remove final slash, if any (unless path is root).
+ /* Remove final slash, if any (unless this is the root dir).
stat behaves differently depending! */
- if (XSTRING (abspath)->size > 1
- && IS_DIRECTORY_SEP (XSTRING (abspath)->data[XSTRING (abspath)->size - 1])
- && !IS_DEVICE_SEP (XSTRING (abspath)->data[XSTRING (abspath)->size-2]))
+ if (XSTRING (absname)->size > 1
+ && IS_DIRECTORY_SEP (XSTRING (absname)->data[STRING_BYTES (XSTRING (absname)) - 1])
+ && !IS_DEVICE_SEP (XSTRING (absname)->data[STRING_BYTES (XSTRING (absname))-2]))
/* We cannot take shortcuts; they might be wrong for magic file names. */
- abspath = Fdirectory_file_name (abspath);
+ absname = Fdirectory_file_name (absname);
#endif
- return abspath;
+ return absname;
}
\f
+/* Signal an error if the file ABSNAME already exists.
+ If INTERACTIVE is nonzero, ask the user whether to proceed,
+ and bypass the error if the user says to go ahead.
+ QUERYSTRING is a name for the action that is being considered
+ to alter the file.
+
+ *STATPTR is used to store the stat information if the file exists.
+ If the file does not exist, STATPTR->st_mode is set to 0.
+ If STATPTR is null, we don't store into it.
+
+ If QUICK is nonzero, we ask for y or n, not yes or no. */
+
void
-barf_or_query_if_file_exists (absname, querystring, interactive)
+barf_or_query_if_file_exists (absname, querystring, interactive, statptr, quick)
Lisp_Object absname;
unsigned char *querystring;
int interactive;
+ struct stat *statptr;
+ int quick;
{
- register Lisp_Object tem;
+ register Lisp_Object tem, encoded_filename;
struct stat statbuf;
struct gcpro gcpro1;
+ encoded_filename = ENCODE_FILE (absname);
+
/* stat is a good way to tell whether the file exists,
regardless of what access permissions it has. */
- if (stat (XSTRING (absname)->data, &statbuf) >= 0)
+ if (stat (XSTRING (encoded_filename)->data, &statbuf) >= 0)
{
if (! interactive)
Fsignal (Qfile_already_exists,
Fcons (build_string ("File already exists"),
Fcons (absname, Qnil)));
GCPRO1 (absname);
- tem = do_yes_or_no_p (format1 ("File %s already exists; %s anyway? ",
- XSTRING (absname)->data, querystring));
+ tem = format1 ("File %s already exists; %s anyway? ",
+ XSTRING (absname)->data, querystring);
+ if (quick)
+ tem = Fy_or_n_p (tem);
+ else
+ tem = do_yes_or_no_p (tem);
UNGCPRO;
if (NILP (tem))
Fsignal (Qfile_already_exists,
Fcons (build_string ("File already exists"),
Fcons (absname, Qnil)));
+ if (statptr)
+ *statptr = statbuf;
+ }
+ else
+ {
+ if (statptr)
+ statptr->st_mode = 0;
}
return;
}
Fourth arg KEEP-TIME non-nil means give the new file the same\n\
last-modified time as the old one. (This works on only some systems.)\n\
A prefix arg makes KEEP-TIME non-nil.")
- (filename, newname, ok_if_already_exists, keep_date)
- Lisp_Object filename, newname, ok_if_already_exists, keep_date;
+ (file, newname, ok_if_already_exists, keep_date)
+ Lisp_Object file, newname, ok_if_already_exists, keep_date;
{
int ifd, ofd, n;
char buf[16 * 1024];
- struct stat st;
+ struct stat st, out_st;
Lisp_Object handler;
- struct gcpro gcpro1, gcpro2;
+ struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
int count = specpdl_ptr - specpdl;
int input_file_statable_p;
+ Lisp_Object encoded_file, encoded_newname;
- GCPRO2 (filename, newname);
- CHECK_STRING (filename, 0);
+ encoded_file = encoded_newname = Qnil;
+ GCPRO4 (file, newname, encoded_file, encoded_newname);
+ CHECK_STRING (file, 0);
CHECK_STRING (newname, 1);
- filename = Fexpand_file_name (filename, Qnil);
+
+ file = Fexpand_file_name (file, Qnil);
newname = Fexpand_file_name (newname, Qnil);
/* If the input file name has special constructs in it,
call the corresponding file handler. */
- handler = Ffind_file_name_handler (filename, Qcopy_file);
+ handler = Ffind_file_name_handler (file, Qcopy_file);
/* Likewise for output file name. */
if (NILP (handler))
handler = Ffind_file_name_handler (newname, Qcopy_file);
if (!NILP (handler))
- RETURN_UNGCPRO (call5 (handler, Qcopy_file, filename, newname,
+ RETURN_UNGCPRO (call5 (handler, Qcopy_file, file, newname,
ok_if_already_exists, keep_date));
+ encoded_file = ENCODE_FILE (file);
+ encoded_newname = ENCODE_FILE (newname);
+
if (NILP (ok_if_already_exists)
|| INTEGERP (ok_if_already_exists))
- barf_or_query_if_file_exists (newname, "copy to it",
- INTEGERP (ok_if_already_exists));
+ barf_or_query_if_file_exists (encoded_newname, "copy to it",
+ INTEGERP (ok_if_already_exists), &out_st, 0);
+ else if (stat (XSTRING (encoded_newname)->data, &out_st) < 0)
+ out_st.st_mode = 0;
- ifd = open (XSTRING (filename)->data, O_RDONLY);
+ ifd = emacs_open (XSTRING (encoded_file)->data, O_RDONLY, 0);
if (ifd < 0)
- report_file_error ("Opening input file", Fcons (filename, Qnil));
+ report_file_error ("Opening input file", Fcons (file, Qnil));
record_unwind_protect (close_file_unwind, make_number (ifd));
copyable by us. */
input_file_statable_p = (fstat (ifd, &st) >= 0);
+#if !defined (DOS_NT) || __DJGPP__ > 1
+ if (out_st.st_mode != 0
+ && st.st_dev == out_st.st_dev && st.st_ino == out_st.st_ino)
+ {
+ errno = 0;
+ report_file_error ("Input and output files are the same",
+ Fcons (file, Fcons (newname, Qnil)));
+ }
+#endif
+
#if defined (S_ISREG) && defined (S_ISLNK)
if (input_file_statable_p)
{
/* Get a better looking error message. */
errno = EISDIR;
#endif /* EISDIR */
- report_file_error ("Non-regular file", Fcons (filename, Qnil));
+ report_file_error ("Non-regular file", Fcons (file, Qnil));
}
}
#endif /* S_ISREG && S_ISLNK */
#ifdef VMS
/* Create the copy file with the same record format as the input file */
- ofd = sys_creat (XSTRING (newname)->data, 0666, ifd);
+ ofd = sys_creat (XSTRING (encoded_newname)->data, 0666, ifd);
#else
#ifdef MSDOS
/* System's default file type was set to binary by _fmode in emacs.c. */
- ofd = creat (XSTRING (newname)->data, S_IREAD | S_IWRITE);
+ ofd = creat (XSTRING (encoded_newname)->data, S_IREAD | S_IWRITE);
#else /* not MSDOS */
- ofd = creat (XSTRING (newname)->data, 0666);
+ ofd = creat (XSTRING (encoded_newname)->data, 0666);
#endif /* not MSDOS */
#endif /* VMS */
if (ofd < 0)
- report_file_error ("Opening output file", Fcons (newname, Qnil));
+ report_file_error ("Opening output file", Fcons (newname, Qnil));
record_unwind_protect (close_file_unwind, make_number (ofd));
immediate_quit = 1;
QUIT;
- while ((n = read (ifd, buf, sizeof buf)) > 0)
- if (write (ofd, buf, n) != n)
- report_file_error ("I/O error", Fcons (newname, Qnil));
+ while ((n = emacs_read (ifd, buf, sizeof buf)) > 0)
+ if (emacs_write (ofd, buf, n) != n)
+ report_file_error ("I/O error", Fcons (newname, Qnil));
immediate_quit = 0;
/* Closing the output clobbers the file times on some systems. */
- if (close (ofd) < 0)
+ if (emacs_close (ofd) < 0)
report_file_error ("I/O error", Fcons (newname, Qnil));
if (input_file_statable_p)
EMACS_TIME atime, mtime;
EMACS_SET_SECS_USECS (atime, st.st_atime, 0);
EMACS_SET_SECS_USECS (mtime, st.st_mtime, 0);
- if (set_file_times (XSTRING (newname)->data, atime, mtime))
- report_file_error ("I/O error", Fcons (newname, Qnil));
+ if (set_file_times (XSTRING (encoded_newname)->data,
+ atime, mtime))
+ Fsignal (Qfile_date_error,
+ Fcons (build_string ("Cannot set file date"),
+ Fcons (newname, Qnil)));
}
-#ifdef APOLLO
- if (!egetenv ("USE_DOMAIN_ACLS"))
-#endif
- chmod (XSTRING (newname)->data, st.st_mode & 07777);
+#ifndef MSDOS
+ chmod (XSTRING (encoded_newname)->data, st.st_mode & 07777);
+#else /* MSDOS */
+#if defined (__DJGPP__) && __DJGPP__ > 1
+ /* In DJGPP v2.0 and later, fstat usually returns true file mode bits,
+ and if it can't, it tells so. Otherwise, under MSDOS we usually
+ get only the READ bit, which will make the copied file read-only,
+ so it's better not to chmod at all. */
+ if ((_djstat_flags & _STFAIL_WRITEBIT) == 0)
+ chmod (XSTRING (encoded_newname)->data, st.st_mode & 07777);
+#endif /* DJGPP version 2 or newer */
+#endif /* MSDOS */
}
- close (ifd);
+ emacs_close (ifd);
/* Discard the unwind protects. */
specpdl_ptr = specpdl + count;
\f
DEFUN ("make-directory-internal", Fmake_directory_internal,
Smake_directory_internal, 1, 1, 0,
- "Create a directory. One argument, a file name string.")
- (dirname)
- Lisp_Object dirname;
+ "Create a new directory named DIRECTORY.")
+ (directory)
+ Lisp_Object directory;
{
unsigned char *dir;
Lisp_Object handler;
+ Lisp_Object encoded_dir;
- CHECK_STRING (dirname, 0);
- dirname = Fexpand_file_name (dirname, Qnil);
+ CHECK_STRING (directory, 0);
+ directory = Fexpand_file_name (directory, Qnil);
- handler = Ffind_file_name_handler (dirname, Qmake_directory_internal);
+ handler = Ffind_file_name_handler (directory, Qmake_directory_internal);
if (!NILP (handler))
- return call2 (handler, Qmake_directory_internal, dirname);
+ return call2 (handler, Qmake_directory_internal, directory);
+
+ encoded_dir = ENCODE_FILE (directory);
- dir = XSTRING (dirname)->data;
+ dir = XSTRING (encoded_dir)->data;
#ifdef WINDOWSNT
if (mkdir (dir) != 0)
#else
if (mkdir (dir, 0777) != 0)
#endif
- report_file_error ("Creating directory", Flist (1, &dirname));
+ report_file_error ("Creating directory", Flist (1, &directory));
return Qnil;
}
DEFUN ("delete-directory", Fdelete_directory, Sdelete_directory, 1, 1, "FDelete directory: ",
- "Delete a directory. One argument, a file name or directory name string.")
- (dirname)
- Lisp_Object dirname;
+ "Delete the directory named DIRECTORY.")
+ (directory)
+ Lisp_Object directory;
{
unsigned char *dir;
Lisp_Object handler;
+ Lisp_Object encoded_dir;
- CHECK_STRING (dirname, 0);
- dirname = Fdirectory_file_name (Fexpand_file_name (dirname, Qnil));
- dir = XSTRING (dirname)->data;
+ CHECK_STRING (directory, 0);
+ directory = Fdirectory_file_name (Fexpand_file_name (directory, Qnil));
- handler = Ffind_file_name_handler (dirname, Qdelete_directory);
+ handler = Ffind_file_name_handler (directory, Qdelete_directory);
if (!NILP (handler))
- return call2 (handler, Qdelete_directory, dirname);
+ return call2 (handler, Qdelete_directory, directory);
+
+ encoded_dir = ENCODE_FILE (directory);
+
+ dir = XSTRING (encoded_dir)->data;
if (rmdir (dir) != 0)
- report_file_error ("Removing directory", Flist (1, &dirname));
+ report_file_error ("Removing directory", Flist (1, &directory));
return Qnil;
}
DEFUN ("delete-file", Fdelete_file, Sdelete_file, 1, 1, "fDelete file: ",
- "Delete specified file. One argument, a file name string.\n\
+ "Delete file named FILENAME.\n\
If file has multiple names, it continues to exist with the other names.")
(filename)
Lisp_Object filename;
{
Lisp_Object handler;
+ Lisp_Object encoded_file;
+
CHECK_STRING (filename, 0);
filename = Fexpand_file_name (filename, Qnil);
if (!NILP (handler))
return call2 (handler, Qdelete_file, filename);
- if (0 > unlink (XSTRING (filename)->data))
+ encoded_file = ENCODE_FILE (filename);
+
+ if (0 > unlink (XSTRING (encoded_file)->data))
report_file_error ("Removing old name", Flist (1, &filename));
return Qnil;
}
unless optional third argument OK-IF-ALREADY-EXISTS is non-nil.\n\
A number as third arg means request confirmation if NEWNAME already exists.\n\
This is what happens in interactive use with M-x.")
- (filename, newname, ok_if_already_exists)
- Lisp_Object filename, newname, ok_if_already_exists;
+ (file, newname, ok_if_already_exists)
+ Lisp_Object file, newname, ok_if_already_exists;
{
#ifdef NO_ARG_ARRAY
Lisp_Object args[2];
#endif
Lisp_Object handler;
- struct gcpro gcpro1, gcpro2;
+ struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
+ Lisp_Object encoded_file, encoded_newname;
- GCPRO2 (filename, newname);
- CHECK_STRING (filename, 0);
+ encoded_file = encoded_newname = Qnil;
+ GCPRO4 (file, newname, encoded_file, encoded_newname);
+ CHECK_STRING (file, 0);
CHECK_STRING (newname, 1);
- filename = Fexpand_file_name (filename, Qnil);
+ file = Fexpand_file_name (file, Qnil);
newname = Fexpand_file_name (newname, Qnil);
/* If the file name has special constructs in it,
call the corresponding file handler. */
- handler = Ffind_file_name_handler (filename, Qrename_file);
+ handler = Ffind_file_name_handler (file, Qrename_file);
if (NILP (handler))
handler = Ffind_file_name_handler (newname, Qrename_file);
if (!NILP (handler))
RETURN_UNGCPRO (call4 (handler, Qrename_file,
- filename, newname, ok_if_already_exists));
+ file, newname, ok_if_already_exists));
+
+ encoded_file = ENCODE_FILE (file);
+ encoded_newname = ENCODE_FILE (newname);
if (NILP (ok_if_already_exists)
|| INTEGERP (ok_if_already_exists))
- barf_or_query_if_file_exists (newname, "rename to it",
- INTEGERP (ok_if_already_exists));
+ barf_or_query_if_file_exists (encoded_newname, "rename to it",
+ INTEGERP (ok_if_already_exists), 0, 0);
#ifndef BSD4_1
- if (0 > rename (XSTRING (filename)->data, XSTRING (newname)->data))
+ if (0 > rename (XSTRING (encoded_file)->data, XSTRING (encoded_newname)->data))
#else
-#ifdef WINDOWSNT
- if (!MoveFile (XSTRING (filename)->data, XSTRING (newname)->data))
-#else /* not WINDOWSNT */
- if (0 > link (XSTRING (filename)->data, XSTRING (newname)->data)
- || 0 > unlink (XSTRING (filename)->data))
-#endif /* not WINDOWSNT */
+ if (0 > link (XSTRING (encoded_file)->data, XSTRING (encoded_newname)->data)
+ || 0 > unlink (XSTRING (encoded_file)->data))
#endif
{
-#ifdef WINDOWSNT
- /* Why two? And why doesn't MS document what MoveFile will return? */
- if (GetLastError () == ERROR_FILE_EXISTS
- || GetLastError () == ERROR_ALREADY_EXISTS)
-#else /* not WINDOWSNT */
if (errno == EXDEV)
-#endif /* not WINDOWSNT */
{
- Fcopy_file (filename, newname,
+ Fcopy_file (file, newname,
/* We have already prompted if it was an integer,
so don't have copy-file prompt again. */
NILP (ok_if_already_exists) ? Qnil : Qt, Qt);
- Fdelete_file (filename);
+ Fdelete_file (file);
}
else
#ifdef NO_ARG_ARRAY
{
- args[0] = filename;
+ args[0] = file;
args[1] = newname;
report_file_error ("Renaming", Flist (2, args));
}
#else
- report_file_error ("Renaming", Flist (2, &filename));
+ report_file_error ("Renaming", Flist (2, &file));
#endif
}
UNGCPRO;
unless optional third argument OK-IF-ALREADY-EXISTS is non-nil.\n\
A number as third arg means request confirmation if NEWNAME already exists.\n\
This is what happens in interactive use with M-x.")
- (filename, newname, ok_if_already_exists)
- Lisp_Object filename, newname, ok_if_already_exists;
+ (file, newname, ok_if_already_exists)
+ Lisp_Object file, newname, ok_if_already_exists;
{
#ifdef NO_ARG_ARRAY
Lisp_Object args[2];
#endif
Lisp_Object handler;
- struct gcpro gcpro1, gcpro2;
+ Lisp_Object encoded_file, encoded_newname;
+ struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
- GCPRO2 (filename, newname);
- CHECK_STRING (filename, 0);
+ GCPRO4 (file, newname, encoded_file, encoded_newname);
+ encoded_file = encoded_newname = Qnil;
+ CHECK_STRING (file, 0);
CHECK_STRING (newname, 1);
- filename = Fexpand_file_name (filename, Qnil);
+ file = Fexpand_file_name (file, Qnil);
newname = Fexpand_file_name (newname, Qnil);
/* If the file name has special constructs in it,
call the corresponding file handler. */
- handler = Ffind_file_name_handler (filename, Qadd_name_to_file);
+ handler = Ffind_file_name_handler (file, Qadd_name_to_file);
+ if (!NILP (handler))
+ RETURN_UNGCPRO (call4 (handler, Qadd_name_to_file, file,
+ newname, ok_if_already_exists));
+
+ /* If the new name has special constructs in it,
+ call the corresponding file handler. */
+ handler = Ffind_file_name_handler (newname, Qadd_name_to_file);
if (!NILP (handler))
- RETURN_UNGCPRO (call4 (handler, Qadd_name_to_file, filename,
+ RETURN_UNGCPRO (call4 (handler, Qadd_name_to_file, file,
newname, ok_if_already_exists));
+ encoded_file = ENCODE_FILE (file);
+ encoded_newname = ENCODE_FILE (newname);
+
if (NILP (ok_if_already_exists)
|| INTEGERP (ok_if_already_exists))
- barf_or_query_if_file_exists (newname, "make it a new name",
- INTEGERP (ok_if_already_exists));
-#ifdef WINDOWSNT
- /* Windows does not support this operation. */
- report_file_error ("Adding new name", Flist (2, &filename));
-#else /* not WINDOWSNT */
+ barf_or_query_if_file_exists (encoded_newname, "make it a new name",
+ INTEGERP (ok_if_already_exists), 0, 0);
unlink (XSTRING (newname)->data);
- if (0 > link (XSTRING (filename)->data, XSTRING (newname)->data))
+ if (0 > link (XSTRING (encoded_file)->data, XSTRING (encoded_newname)->data))
{
#ifdef NO_ARG_ARRAY
- args[0] = filename;
+ args[0] = file;
args[1] = newname;
report_file_error ("Adding new name", Flist (2, args));
#else
- report_file_error ("Adding new name", Flist (2, &filename));
+ report_file_error ("Adding new name", Flist (2, &file));
#endif
}
-#endif /* not WINDOWSNT */
UNGCPRO;
return Qnil;
Lisp_Object args[2];
#endif
Lisp_Object handler;
- struct gcpro gcpro1, gcpro2;
+ Lisp_Object encoded_filename, encoded_linkname;
+ struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
- GCPRO2 (filename, linkname);
+ GCPRO4 (filename, linkname, encoded_filename, encoded_linkname);
+ encoded_filename = encoded_linkname = Qnil;
CHECK_STRING (filename, 0);
CHECK_STRING (linkname, 1);
/* If the link target has a ~, we must expand it to get
RETURN_UNGCPRO (call4 (handler, Qmake_symbolic_link, filename,
linkname, ok_if_already_exists));
+ /* If the new link name has special constructs in it,
+ call the corresponding file handler. */
+ handler = Ffind_file_name_handler (linkname, Qmake_symbolic_link);
+ if (!NILP (handler))
+ RETURN_UNGCPRO (call4 (handler, Qmake_symbolic_link, filename,
+ linkname, ok_if_already_exists));
+
+ encoded_filename = ENCODE_FILE (filename);
+ encoded_linkname = ENCODE_FILE (linkname);
+
if (NILP (ok_if_already_exists)
|| INTEGERP (ok_if_already_exists))
- barf_or_query_if_file_exists (linkname, "make it a link",
- INTEGERP (ok_if_already_exists));
- if (0 > symlink (XSTRING (filename)->data, XSTRING (linkname)->data))
+ barf_or_query_if_file_exists (encoded_linkname, "make it a link",
+ INTEGERP (ok_if_already_exists), 0, 0);
+ if (0 > symlink (XSTRING (encoded_filename)->data,
+ XSTRING (encoded_linkname)->data))
{
/* If we didn't complain already, silently delete existing file. */
if (errno == EEXIST)
{
- unlink (XSTRING (linkname)->data);
- if (0 <= symlink (XSTRING (filename)->data, XSTRING (linkname)->data))
+ unlink (XSTRING (encoded_linkname)->data);
+ if (0 <= symlink (XSTRING (encoded_filename)->data,
+ XSTRING (encoded_linkname)->data))
{
UNGCPRO;
return Qnil;
2, 2, "sDefine logical name: \nsDefine logical name %s as: ",
"Define the job-wide logical name NAME to have the value STRING.\n\
If STRING is nil or a null string, the logical name NAME is deleted.")
- (varname, string)
- Lisp_Object varname;
+ (name, string)
+ Lisp_Object name;
Lisp_Object string;
{
- CHECK_STRING (varname, 0);
+ CHECK_STRING (name, 0);
if (NILP (string))
- delete_logical_name (XSTRING (varname)->data);
+ delete_logical_name (XSTRING (name)->data);
else
{
CHECK_STRING (string, 1);
if (XSTRING (string)->size == 0)
- delete_logical_name (XSTRING (varname)->data);
+ delete_logical_name (XSTRING (name)->data);
else
- define_logical_name (XSTRING (varname)->data, XSTRING (string)->data);
+ define_logical_name (XSTRING (name)->data, XSTRING (string)->data);
}
return string;
Lisp_Object path, login;
{
int netresult;
-
+
CHECK_STRING (path, 0);
- CHECK_STRING (login, 0);
-
+ CHECK_STRING (login, 0);
+
netresult = netunam (XSTRING (path)->data, XSTRING (login)->data);
if (netresult == -1)
\f
DEFUN ("file-name-absolute-p", Ffile_name_absolute_p, Sfile_name_absolute_p,
1, 1, 0,
- "Return t if file FILENAME specifies an absolute path name.\n\
+ "Return t if file FILENAME specifies an absolute file name.\n\
On Unix, this is a name starting with a `/' or a `~'.")
(filename)
Lisp_Object filename;
&& ptr[1] != '.')
#endif /* VMS */
#ifdef DOS_NT
- || (*ptr != 0 && ptr[1] == ':' && (ptr[2] == '/' || ptr[2] == '\\'))
+ || (IS_DRIVE (*ptr) && ptr[1] == ':' && IS_DIRECTORY_SEP (ptr[2]))
#endif
)
return Qt;
check_executable (filename)
char *filename;
{
-#ifdef HAVE_EACCESS
- return (eaccess (filename, 1) >= 0);
+#ifdef DOS_NT
+ int len = strlen (filename);
+ char *suffix;
+ struct stat st;
+ if (stat (filename, &st) < 0)
+ return 0;
+#if defined (WINDOWSNT) || (defined (MSDOS) && __DJGPP__ > 1)
+ return ((st.st_mode & S_IEXEC) != 0);
+#else
+ return (S_ISREG (st.st_mode)
+ && len >= 5
+ && (stricmp ((suffix = filename + len-4), ".com") == 0
+ || stricmp (suffix, ".exe") == 0
+ || stricmp (suffix, ".bat") == 0)
+ || (st.st_mode & S_IFMT) == S_IFDIR);
+#endif /* not WINDOWSNT */
+#else /* not DOS_NT */
+#ifdef HAVE_EUIDACCESS
+ return (euidaccess (filename, 1) >= 0);
#else
/* Access isn't quite right because it uses the real uid
and we really want to test with the effective uid.
But Unix doesn't give us a right way to do it. */
return (access (filename, 1) >= 0);
#endif
+#endif /* not DOS_NT */
}
/* Return nonzero if file FILENAME exists and can be written. */
check_writable (filename)
char *filename;
{
-#ifdef HAVE_EACCESS
- return (eaccess (filename, 2) >= 0);
+#ifdef MSDOS
+ struct stat st;
+ if (stat (filename, &st) < 0)
+ return 0;
+ return (st.st_mode & S_IWRITE || (st.st_mode & S_IFMT) == S_IFDIR);
+#else /* not MSDOS */
+#ifdef HAVE_EUIDACCESS
+ return (euidaccess (filename, 2) >= 0);
#else
/* Access isn't quite right because it uses the real uid
and we really want to test with the effective uid.
but would lose for directories. */
return (access (filename, 2) >= 0);
#endif
+#endif /* not MSDOS */
}
DEFUN ("file-exists-p", Ffile_exists_p, Sfile_exists_p, 1, 1, 0,
(filename)
Lisp_Object filename;
{
- Lisp_Object abspath;
+ Lisp_Object absname;
Lisp_Object handler;
struct stat statbuf;
CHECK_STRING (filename, 0);
- abspath = Fexpand_file_name (filename, Qnil);
+ absname = Fexpand_file_name (filename, Qnil);
/* If the file name has special constructs in it,
call the corresponding file handler. */
- handler = Ffind_file_name_handler (abspath, Qfile_exists_p);
+ handler = Ffind_file_name_handler (absname, Qfile_exists_p);
if (!NILP (handler))
- return call2 (handler, Qfile_exists_p, abspath);
+ return call2 (handler, Qfile_exists_p, absname);
+
+ absname = ENCODE_FILE (absname);
- return (stat (XSTRING (abspath)->data, &statbuf) >= 0) ? Qt : Qnil;
+ return (stat (XSTRING (absname)->data, &statbuf) >= 0) ? Qt : Qnil;
}
DEFUN ("file-executable-p", Ffile_executable_p, Sfile_executable_p, 1, 1, 0,
Lisp_Object filename;
{
- Lisp_Object abspath;
+ Lisp_Object absname;
Lisp_Object handler;
CHECK_STRING (filename, 0);
- abspath = Fexpand_file_name (filename, Qnil);
+ absname = Fexpand_file_name (filename, Qnil);
/* If the file name has special constructs in it,
call the corresponding file handler. */
- handler = Ffind_file_name_handler (abspath, Qfile_executable_p);
+ handler = Ffind_file_name_handler (absname, Qfile_executable_p);
if (!NILP (handler))
- return call2 (handler, Qfile_executable_p, abspath);
+ return call2 (handler, Qfile_executable_p, absname);
- return (check_executable (XSTRING (abspath)->data) ? Qt : Qnil);
+ absname = ENCODE_FILE (absname);
+
+ return (check_executable (XSTRING (absname)->data) ? Qt : Qnil);
}
DEFUN ("file-readable-p", Ffile_readable_p, Sfile_readable_p, 1, 1, 0,
(filename)
Lisp_Object filename;
{
- Lisp_Object abspath;
+ Lisp_Object absname;
Lisp_Object handler;
int desc;
+ int flags;
+ struct stat statbuf;
CHECK_STRING (filename, 0);
- abspath = Fexpand_file_name (filename, Qnil);
+ absname = Fexpand_file_name (filename, Qnil);
/* If the file name has special constructs in it,
call the corresponding file handler. */
- handler = Ffind_file_name_handler (abspath, Qfile_readable_p);
+ handler = Ffind_file_name_handler (absname, Qfile_readable_p);
if (!NILP (handler))
- return call2 (handler, Qfile_readable_p, abspath);
+ return call2 (handler, Qfile_readable_p, absname);
- desc = open (XSTRING (abspath)->data, O_RDONLY);
+ absname = ENCODE_FILE (absname);
+
+#ifdef DOS_NT
+ /* Under MS-DOS and Windows, open does not work for directories. */
+ if (access (XSTRING (absname)->data, 0) == 0)
+ return Qt;
+ return Qnil;
+#else /* not DOS_NT */
+ flags = O_RDONLY;
+#if defined (S_ISFIFO) && defined (O_NONBLOCK)
+ /* Opening a fifo without O_NONBLOCK can wait.
+ We don't want to wait. But we don't want to mess wth O_NONBLOCK
+ except in the case of a fifo, on a system which handles it. */
+ desc = stat (XSTRING (absname)->data, &statbuf);
+ if (desc < 0)
+ return Qnil;
+ if (S_ISFIFO (statbuf.st_mode))
+ flags |= O_NONBLOCK;
+#endif
+ desc = emacs_open (XSTRING (absname)->data, flags, 0);
if (desc < 0)
return Qnil;
- close (desc);
+ emacs_close (desc);
return Qt;
+#endif /* not DOS_NT */
}
/* Having this before file-symlink-p mysteriously caused it to be forgotten
(filename)
Lisp_Object filename;
{
- Lisp_Object abspath, dir;
+ Lisp_Object absname, dir, encoded;
Lisp_Object handler;
struct stat statbuf;
CHECK_STRING (filename, 0);
- abspath = Fexpand_file_name (filename, Qnil);
+ absname = Fexpand_file_name (filename, Qnil);
/* If the file name has special constructs in it,
call the corresponding file handler. */
- handler = Ffind_file_name_handler (abspath, Qfile_writable_p);
+ handler = Ffind_file_name_handler (absname, Qfile_writable_p);
if (!NILP (handler))
- return call2 (handler, Qfile_writable_p, abspath);
+ return call2 (handler, Qfile_writable_p, absname);
- if (stat (XSTRING (abspath)->data, &statbuf) >= 0)
- return (check_writable (XSTRING (abspath)->data)
+ encoded = ENCODE_FILE (absname);
+ if (stat (XSTRING (encoded)->data, &statbuf) >= 0)
+ return (check_writable (XSTRING (encoded)->data)
? Qt : Qnil);
- dir = Ffile_name_directory (abspath);
+
+ dir = Ffile_name_directory (absname);
#ifdef VMS
if (!NILP (dir))
dir = Fdirectory_file_name (dir);
if (!NILP (dir))
dir = Fdirectory_file_name (dir);
#endif /* MSDOS */
+
+ dir = ENCODE_FILE (dir);
return (check_writable (!NILP (dir) ? (char *) XSTRING (dir)->data : "")
? Qt : Qnil);
}
\f
+DEFUN ("access-file", Faccess_file, Saccess_file, 2, 2, 0,
+ "Access file FILENAME, and get an error if that does not work.\n\
+The second argument STRING is used in the error message.\n\
+If there is no error, we return nil.")
+ (filename, string)
+ Lisp_Object filename, string;
+{
+ Lisp_Object handler, encoded_filename;
+ int fd;
+
+ CHECK_STRING (filename, 0);
+ CHECK_STRING (string, 1);
+
+ /* If the file name has special constructs in it,
+ call the corresponding file handler. */
+ handler = Ffind_file_name_handler (filename, Qaccess_file);
+ if (!NILP (handler))
+ return call3 (handler, Qaccess_file, filename, string);
+
+ encoded_filename = ENCODE_FILE (filename);
+
+ fd = emacs_open (XSTRING (encoded_filename)->data, O_RDONLY, 0);
+ if (fd < 0)
+ report_file_error (XSTRING (string)->data, Fcons (filename, Qnil));
+ emacs_close (fd);
+
+ return Qnil;
+}
+\f
DEFUN ("file-symlink-p", Ffile_symlink_p, Sfile_symlink_p, 1, 1, 0,
"Return non-nil if file FILENAME is the name of a symbolic link.\n\
The value is the name of the file to which it is linked.\n\
if (!NILP (handler))
return call2 (handler, Qfile_symlink_p, filename);
+ filename = ENCODE_FILE (filename);
+
bufsize = 100;
while (1)
{
}
val = make_string (buf, valsize);
xfree (buf);
+ val = DECODE_FILE (val);
return val;
#else /* not S_IFLNK */
return Qnil;
}
DEFUN ("file-directory-p", Ffile_directory_p, Sfile_directory_p, 1, 1, 0,
- "Return t if file FILENAME is the name of a directory as a file.\n\
-A directory name spec may be given instead; then the value is t\n\
-if the directory so specified exists and really is a directory.")
+ "Return t if FILENAME names an existing directory.\n\
+Symbolic links to directories count as directories.\n\
+See `file-symlink-p' to distinguish symlinks.")
(filename)
Lisp_Object filename;
{
- register Lisp_Object abspath;
+ register Lisp_Object absname;
struct stat st;
Lisp_Object handler;
- abspath = expand_and_dir_to_file (filename, current_buffer->directory);
+ absname = expand_and_dir_to_file (filename, current_buffer->directory);
/* If the file name has special constructs in it,
call the corresponding file handler. */
- handler = Ffind_file_name_handler (abspath, Qfile_directory_p);
+ handler = Ffind_file_name_handler (absname, Qfile_directory_p);
if (!NILP (handler))
- return call2 (handler, Qfile_directory_p, abspath);
+ return call2 (handler, Qfile_directory_p, absname);
- if (stat (XSTRING (abspath)->data, &st) < 0)
+ absname = ENCODE_FILE (absname);
+
+ if (stat (XSTRING (absname)->data, &st) < 0)
return Qnil;
return (st.st_mode & S_IFMT) == S_IFDIR ? Qt : Qnil;
}
(filename)
Lisp_Object filename;
{
- register Lisp_Object abspath;
+ register Lisp_Object absname;
struct stat st;
Lisp_Object handler;
- abspath = expand_and_dir_to_file (filename, current_buffer->directory);
+ absname = expand_and_dir_to_file (filename, current_buffer->directory);
/* If the file name has special constructs in it,
call the corresponding file handler. */
- handler = Ffind_file_name_handler (abspath, Qfile_directory_p);
+ handler = Ffind_file_name_handler (absname, Qfile_regular_p);
if (!NILP (handler))
- return call2 (handler, Qfile_directory_p, abspath);
+ return call2 (handler, Qfile_regular_p, absname);
+
+ absname = ENCODE_FILE (absname);
- if (stat (XSTRING (abspath)->data, &st) < 0)
+#ifdef WINDOWSNT
+ {
+ int result;
+ Lisp_Object tem = Vw32_get_true_file_attributes;
+
+ /* Tell stat to use expensive method to get accurate info. */
+ Vw32_get_true_file_attributes = Qt;
+ result = stat (XSTRING (absname)->data, &st);
+ Vw32_get_true_file_attributes = tem;
+
+ if (result < 0)
+ return Qnil;
+ return (st.st_mode & S_IFMT) == S_IFREG ? Qt : Qnil;
+ }
+#else
+ if (stat (XSTRING (absname)->data, &st) < 0)
return Qnil;
return (st.st_mode & S_IFMT) == S_IFREG ? Qt : Qnil;
+#endif
}
\f
DEFUN ("file-modes", Ffile_modes, Sfile_modes, 1, 1, 0,
- "Return mode bits of FILE, as an integer.")
+ "Return mode bits of file named FILENAME, as an integer.")
(filename)
Lisp_Object filename;
{
- Lisp_Object abspath;
+ Lisp_Object absname;
struct stat st;
Lisp_Object handler;
- abspath = expand_and_dir_to_file (filename, current_buffer->directory);
+ absname = expand_and_dir_to_file (filename, current_buffer->directory);
/* If the file name has special constructs in it,
call the corresponding file handler. */
- handler = Ffind_file_name_handler (abspath, Qfile_modes);
+ handler = Ffind_file_name_handler (absname, Qfile_modes);
if (!NILP (handler))
- return call2 (handler, Qfile_modes, abspath);
+ return call2 (handler, Qfile_modes, absname);
+
+ absname = ENCODE_FILE (absname);
- if (stat (XSTRING (abspath)->data, &st) < 0)
+ if (stat (XSTRING (absname)->data, &st) < 0)
return Qnil;
-#ifdef DOS_NT
- {
- int len;
- char *suffix;
- if (S_ISREG (st.st_mode)
- && (len = XSTRING (abspath)->size) >= 5
- && (stricmp ((suffix = XSTRING (abspath)->data + len-4), ".com") == 0
- || stricmp (suffix, ".exe") == 0
- || stricmp (suffix, ".bat") == 0))
- st.st_mode |= S_IEXEC;
- }
-#endif /* DOS_NT */
+#if defined (MSDOS) && __DJGPP__ < 2
+ if (check_executable (XSTRING (absname)->data))
+ st.st_mode |= S_IEXEC;
+#endif /* MSDOS && __DJGPP__ < 2 */
return make_number (st.st_mode & 07777);
}
DEFUN ("set-file-modes", Fset_file_modes, Sset_file_modes, 2, 2, 0,
- "Set mode bits of FILE to MODE (an integer).\n\
+ "Set mode bits of file named FILENAME to MODE (an integer).\n\
Only the 12 low bits of MODE are used.")
(filename, mode)
Lisp_Object filename, mode;
{
- Lisp_Object abspath;
+ Lisp_Object absname, encoded_absname;
Lisp_Object handler;
- abspath = Fexpand_file_name (filename, current_buffer->directory);
+ absname = Fexpand_file_name (filename, current_buffer->directory);
CHECK_NUMBER (mode, 1);
/* If the file name has special constructs in it,
call the corresponding file handler. */
- handler = Ffind_file_name_handler (abspath, Qset_file_modes);
+ handler = Ffind_file_name_handler (absname, Qset_file_modes);
if (!NILP (handler))
- return call3 (handler, Qset_file_modes, abspath, mode);
+ return call3 (handler, Qset_file_modes, absname, mode);
-#ifndef APOLLO
- if (chmod (XSTRING (abspath)->data, XINT (mode)) < 0)
- report_file_error ("Doing chmod", Fcons (abspath, Qnil));
-#else /* APOLLO */
- if (!egetenv ("USE_DOMAIN_ACLS"))
- {
- struct stat st;
- struct timeval tvp[2];
+ encoded_absname = ENCODE_FILE (absname);
- /* chmod on apollo also change the file's modtime; need to save the
- modtime and then restore it. */
- if (stat (XSTRING (abspath)->data, &st) < 0)
- {
- report_file_error ("Doing chmod", Fcons (abspath, Qnil));
- return (Qnil);
- }
-
- if (chmod (XSTRING (abspath)->data, XINT (mode)) < 0)
- report_file_error ("Doing chmod", Fcons (abspath, Qnil));
-
- /* reset the old accessed and modified times. */
- tvp[0].tv_sec = st.st_atime + 1; /* +1 due to an Apollo roundoff bug */
- tvp[0].tv_usec = 0;
- tvp[1].tv_sec = st.st_mtime + 1; /* +1 due to an Apollo roundoff bug */
- tvp[1].tv_usec = 0;
-
- if (utimes (XSTRING (abspath)->data, tvp) < 0)
- report_file_error ("Doing utimes", Fcons (abspath, Qnil));
- }
-#endif /* APOLLO */
+ if (chmod (XSTRING (encoded_absname)->data, XINT (mode)) < 0)
+ report_file_error ("Doing chmod", Fcons (absname, Qnil));
return Qnil;
}
Lisp_Object mode;
{
CHECK_NUMBER (mode, 0);
-
+
umask ((~ XINT (mode)) & 0777);
return Qnil;
(file1, file2)
Lisp_Object file1, file2;
{
- Lisp_Object abspath1, abspath2;
+ Lisp_Object absname1, absname2;
struct stat st;
int mtime1;
Lisp_Object handler;
CHECK_STRING (file1, 0);
CHECK_STRING (file2, 0);
- abspath1 = Qnil;
- GCPRO2 (abspath1, file2);
- abspath1 = expand_and_dir_to_file (file1, current_buffer->directory);
- abspath2 = expand_and_dir_to_file (file2, current_buffer->directory);
+ absname1 = Qnil;
+ GCPRO2 (absname1, file2);
+ absname1 = expand_and_dir_to_file (file1, current_buffer->directory);
+ absname2 = expand_and_dir_to_file (file2, current_buffer->directory);
UNGCPRO;
/* If the file name has special constructs in it,
call the corresponding file handler. */
- handler = Ffind_file_name_handler (abspath1, Qfile_newer_than_file_p);
+ handler = Ffind_file_name_handler (absname1, Qfile_newer_than_file_p);
if (NILP (handler))
- handler = Ffind_file_name_handler (abspath2, Qfile_newer_than_file_p);
+ handler = Ffind_file_name_handler (absname2, Qfile_newer_than_file_p);
if (!NILP (handler))
- return call3 (handler, Qfile_newer_than_file_p, abspath1, abspath2);
+ return call3 (handler, Qfile_newer_than_file_p, absname1, absname2);
+
+ GCPRO2 (absname1, absname2);
+ absname1 = ENCODE_FILE (absname1);
+ absname2 = ENCODE_FILE (absname2);
+ UNGCPRO;
- if (stat (XSTRING (abspath1)->data, &st) < 0)
+ if (stat (XSTRING (absname1)->data, &st) < 0)
return Qnil;
mtime1 = st.st_mtime;
- if (stat (XSTRING (abspath2)->data, &st) < 0)
+ if (stat (XSTRING (absname2)->data, &st) < 0)
return Qt;
return (mtime1 > st.st_mtime) ? Qt : Qnil;
Lisp_Object Qfind_buffer_file_type;
#endif /* DOS_NT */
+#ifndef READ_BUF_SIZE
+#define READ_BUF_SIZE (64 << 10)
+#endif
+
+extern void adjust_markers_for_delete P_ ((int, int, int, int));
+
+/* This function is called after Lisp functions to decide a coding
+ system are called, or when they cause an error. Before they are
+ called, the current buffer is set unibyte and it contains only a
+ newly inserted text (thus the buffer was empty before the
+ insertion).
+
+ The functions may set markers, overlays, text properties, or even
+ alter the buffer contents, change the current buffer.
+
+ Here, we reset all those changes by:
+ o set back the current buffer.
+ o move all markers and overlays to BEG.
+ o remove all text properties.
+ o set back the buffer multibyteness. */
+
+static Lisp_Object
+decide_coding_unwind (unwind_data)
+ Lisp_Object unwind_data;
+{
+ Lisp_Object multibyte, undo_list, buffer;
+
+ multibyte = XCAR (unwind_data);
+ unwind_data = XCDR (unwind_data);
+ undo_list = XCAR (unwind_data);
+ buffer = XCDR (unwind_data);
+
+ if (current_buffer != XBUFFER (buffer))
+ set_buffer_internal (XBUFFER (buffer));
+ adjust_markers_for_delete (BEG, BEG_BYTE, Z, Z_BYTE);
+ adjust_overlays_for_delete (BEG, Z - BEG);
+ BUF_INTERVALS (current_buffer) = 0;
+ TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
+
+ /* Now we are safe to change the buffer's multibyteness directly. */
+ current_buffer->enable_multibyte_characters = multibyte;
+ current_buffer->undo_list = undo_list;
+
+ return Qnil;
+}
+
DEFUN ("insert-file-contents", Finsert_file_contents, Sinsert_file_contents,
1, 5, 0,
"Insert contents of file FILENAME after point.\n\
-Returns list of absolute file name and length of data inserted.\n\
+Returns list of absolute file name and number of bytes inserted.\n\
If second argument VISIT is non-nil, the buffer's visited filename\n\
and last save file modtime are set, and it is marked unmodified.\n\
If visiting and the file does not exist, visiting is completed\n\
-before the error is signaled.\n\n\
+before the error is signaled.\n\
The optional third and fourth arguments BEG and END\n\
specify what portion of the file to insert.\n\
+These arguments count bytes in the file, not characters in the buffer.\n\
If VISIT is non-nil, BEG and END must be nil.\n\
+\n\
If optional fifth argument REPLACE is non-nil,\n\
it means replace the current buffer contents (in the accessible portion)\n\
with the file contents. This is better than simply deleting and inserting\n\
the whole thing because (1) it preserves some marker positions\n\
-and (2) it puts less data in the undo list.")
+and (2) it puts less data in the undo list.\n\
+When REPLACE is non-nil, the value is the number of characters actually read,\n\
+which is often less than the number of characters to be read.\n\
+\n\
+This does code conversion according to the value of\n\
+`coding-system-for-read' or `file-coding-system-alist',\n\
+and sets the variable `last-coding-system-used' to the coding system\n\
+actually used.")
(filename, visit, beg, end, replace)
Lisp_Object filename, visit, beg, end, replace;
{
struct stat st;
register int fd;
- register int inserted = 0;
+ int inserted = 0;
register int how_much;
+ register int unprocessed;
int count = specpdl_ptr - specpdl;
- struct gcpro gcpro1, gcpro2, gcpro3;
- Lisp_Object handler, val, insval;
+ struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
+ Lisp_Object handler, val, insval, orig_filename;
Lisp_Object p;
int total;
int not_regular = 0;
+ unsigned char read_buf[READ_BUF_SIZE];
+ struct coding_system coding;
+ unsigned char buffer[1 << 14];
+ int replace_handled = 0;
+ int set_coding_system = 0;
+ int coding_system_decided = 0;
if (current_buffer->base_buffer && ! NILP (visit))
error ("Cannot do file visiting in an indirect buffer");
val = Qnil;
p = Qnil;
+ orig_filename = Qnil;
- GCPRO3 (filename, val, p);
+ GCPRO4 (filename, val, p, orig_filename);
CHECK_STRING (filename, 0);
filename = Fexpand_file_name (filename, Qnil);
{
val = call6 (handler, Qinsert_file_contents, filename,
visit, beg, end, replace);
+ if (CONSP (val) && CONSP (XCDR (val)))
+ inserted = XINT (XCAR (XCDR (val)));
goto handled;
}
+ orig_filename = filename;
+ filename = ENCODE_FILE (filename);
+
fd = -1;
+#ifdef WINDOWSNT
+ {
+ Lisp_Object tem = Vw32_get_true_file_attributes;
+
+ /* Tell stat to use expensive method to get accurate info. */
+ Vw32_get_true_file_attributes = Qt;
+ total = stat (XSTRING (filename)->data, &st);
+ Vw32_get_true_file_attributes = tem;
+ }
+ if (total < 0)
+#else
#ifndef APOLLO
if (stat (XSTRING (filename)->data, &st) < 0)
#else
- if ((fd = open (XSTRING (filename)->data, O_RDONLY)) < 0
+ if ((fd = emacs_open (XSTRING (filename)->data, O_RDONLY, 0)) < 0
|| fstat (fd, &st) < 0)
#endif /* not APOLLO */
+#endif /* WINDOWSNT */
{
- if (fd >= 0) close (fd);
+ if (fd >= 0) emacs_close (fd);
badopen:
if (NILP (visit))
- report_file_error ("Opening input file", Fcons (filename, Qnil));
+ report_file_error ("Opening input file", Fcons (orig_filename, Qnil));
st.st_mtime = -1;
how_much = 0;
+ if (!NILP (Vcoding_system_for_read))
+ Fset (Qbuffer_file_coding_system, Vcoding_system_for_read);
goto notfound;
}
least signal an error. */
if (!S_ISREG (st.st_mode))
{
- if (NILP (visit))
+ not_regular = 1;
+
+ if (! NILP (visit))
+ goto notfound;
+
+ if (! NILP (replace) || ! NILP (beg) || ! NILP (end))
Fsignal (Qfile_error,
Fcons (build_string ("not a regular file"),
- Fcons (filename, Qnil)));
-
- not_regular = 1;
- goto notfound;
+ Fcons (orig_filename, Qnil)));
}
#endif
if (fd < 0)
- if ((fd = open (XSTRING (filename)->data, O_RDONLY)) < 0)
+ if ((fd = emacs_open (XSTRING (filename)->data, O_RDONLY, 0)) < 0)
goto badopen;
/* Replacement should preserve point as it preserves markers. */
record_unwind_protect (close_file_unwind, make_number (fd));
/* Supposedly happens on VMS. */
- if (st.st_size < 0)
+ if (! not_regular && st.st_size < 0)
error ("File size is negative");
+ /* Prevent redisplay optimizations. */
+ current_buffer->clip_changed = 1;
+
if (!NILP (beg) || !NILP (end))
if (!NILP (visit))
error ("Attempt to visit less than an entire file");
CHECK_NUMBER (end, 0);
else
{
- XSETINT (end, st.st_size);
- if (XINT (end) != st.st_size)
- error ("maximum buffer size exceeded");
+ if (! not_regular)
+ {
+ XSETINT (end, st.st_size);
+
+ /* Arithmetic overflow can occur if an Emacs integer cannot
+ represent the file size, or if the calculations below
+ overflow. The calculations below double the file size
+ twice, so check that it can be multiplied by 4 safely. */
+ if (XINT (end) != st.st_size
+ || ((int) st.st_size * 4) / 4 != st.st_size)
+ error ("Maximum buffer size exceeded");
+ }
}
+ if (BEG < Z)
+ {
+ /* Decide the coding system to use for reading the file now
+ because we can't use an optimized method for handling
+ `coding:' tag if the current buffer is not empty. */
+ Lisp_Object val;
+ val = Qnil;
+
+ if (!NILP (Vcoding_system_for_read))
+ val = Vcoding_system_for_read;
+ else if (! NILP (replace))
+ /* In REPLACE mode, we can use the same coding system
+ that was used to visit the file. */
+ val = current_buffer->buffer_file_coding_system;
+ else
+ {
+ /* Don't try looking inside a file for a coding system
+ specification if it is not seekable. */
+ if (! not_regular && ! NILP (Vset_auto_coding_function))
+ {
+ /* Find a coding system specified in the heading two
+ lines or in the tailing several lines of the file.
+ We assume that the 1K-byte and 3K-byte for heading
+ and tailing respectively are sufficient for this
+ purpose. */
+ int how_many, nread;
+
+ if (st.st_size <= (1024 * 4))
+ nread = emacs_read (fd, read_buf, 1024 * 4);
+ else
+ {
+ nread = emacs_read (fd, read_buf, 1024);
+ if (nread >= 0)
+ {
+ if (lseek (fd, st.st_size - (1024 * 3), 0) < 0)
+ report_file_error ("Setting file position",
+ Fcons (orig_filename, Qnil));
+ nread += emacs_read (fd, read_buf + nread, 1024 * 3);
+ }
+ }
+
+ if (nread < 0)
+ error ("IO error reading %s: %s",
+ XSTRING (orig_filename)->data, emacs_strerror (errno));
+ else if (nread > 0)
+ {
+ int count = specpdl_ptr - specpdl;
+ struct buffer *prev = current_buffer;
+
+ record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
+ temp_output_buffer_setup (" *code-converting-work*");
+ set_buffer_internal (XBUFFER (Vstandard_output));
+ current_buffer->enable_multibyte_characters = Qnil;
+ insert_1_both (read_buf, nread, nread, 0, 0, 0);
+ TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
+ val = call2 (Vset_auto_coding_function,
+ filename, make_number (nread));
+ set_buffer_internal (prev);
+ /* Discard the unwind protect for recovering the
+ current buffer. */
+ specpdl_ptr--;
+
+ /* Rewind the file for the actual read done later. */
+ if (lseek (fd, 0, 0) < 0)
+ report_file_error ("Setting file position",
+ Fcons (orig_filename, Qnil));
+ }
+ }
+
+ if (NILP (val))
+ {
+ /* If we have not yet decided a coding system, check
+ file-coding-system-alist. */
+ Lisp_Object args[6], coding_systems;
+
+ args[0] = Qinsert_file_contents, args[1] = orig_filename;
+ args[2] = visit, args[3] = beg, args[4] = end, args[5] = replace;
+ coding_systems = Ffind_operation_coding_system (6, args);
+ if (CONSP (coding_systems))
+ val = XCAR (coding_systems);
+ }
+ }
+
+ setup_coding_system (Fcheck_coding_system (val), &coding);
+
+ if (NILP (current_buffer->enable_multibyte_characters)
+ && ! NILP (val))
+ /* We must suppress all character code conversion except for
+ end-of-line conversion. */
+ setup_raw_text_coding_system (&coding);
+
+ coding_system_decided = 1;
+ }
+
+ /* Ensure we always set Vlast_coding_system_used. */
+ set_coding_system = 1;
+
/* If requested, replace the accessible part of the buffer
with the file contents. Avoid replacing text at the
beginning or end of the buffer that matches the file contents;
- that preserves markers pointing to the unchanged parts. */
-#ifdef DOS_NT
- /* On MSDOS, replace mode doesn't really work, except for binary files,
- and it's not worth supporting just for them. */
- if (!NILP (replace))
- {
- replace = Qnil;
- XSETFASTINT (beg, 0);
- XSETFASTINT (end, st.st_size);
- del_range_1 (BEGV, ZV, 0);
- }
-#else /* not DOS_NT */
- if (!NILP (replace))
+ that preserves markers pointing to the unchanged parts.
+
+ Here we implement this feature in an optimized way
+ for the case where code conversion is NOT needed.
+ The following if-statement handles the case of conversion
+ in a less optimal way.
+
+ If the code conversion is "automatic" then we try using this
+ method and hope for the best.
+ But if we discover the need for conversion, we give up on this method
+ and let the following if-statement handle the replace job. */
+ if (!NILP (replace)
+ && BEGV < ZV
+ && ! CODING_REQUIRE_DECODING (&coding)
+ && (coding.eol_type == CODING_EOL_UNDECIDED
+ || coding.eol_type == CODING_EOL_LF))
{
- unsigned char buffer[1 << 14];
- int same_at_start = BEGV;
- int same_at_end = ZV;
+ /* same_at_start and same_at_end count bytes,
+ because file access counts bytes
+ and BEG and END count bytes. */
+ int same_at_start = BEGV_BYTE;
+ int same_at_end = ZV_BYTE;
int overlap;
+ /* There is still a possibility we will find the need to do code
+ conversion. If that happens, we set this variable to 1 to
+ give up on handling REPLACE in the optimized way. */
+ int giveup_match_end = 0;
+
+ if (XINT (beg) != 0)
+ {
+ if (lseek (fd, XINT (beg), 0) < 0)
+ report_file_error ("Setting file position",
+ Fcons (orig_filename, Qnil));
+ }
immediate_quit = 1;
QUIT;
{
int nread, bufpos;
- nread = read (fd, buffer, sizeof buffer);
+ nread = emacs_read (fd, buffer, sizeof buffer);
if (nread < 0)
error ("IO error reading %s: %s",
- XSTRING (filename)->data, strerror (errno));
+ XSTRING (orig_filename)->data, emacs_strerror (errno));
else if (nread == 0)
break;
+
+ if (coding.type == coding_type_undecided)
+ detect_coding (&coding, buffer, nread);
+ if (CODING_REQUIRE_DECODING (&coding))
+ /* We found that the file should be decoded somehow.
+ Let's give up here. */
+ {
+ giveup_match_end = 1;
+ break;
+ }
+
+ if (coding.eol_type == CODING_EOL_UNDECIDED)
+ detect_eol (&coding, buffer, nread);
+ if (coding.eol_type != CODING_EOL_UNDECIDED
+ && coding.eol_type != CODING_EOL_LF)
+ /* We found that the format of eol should be decoded.
+ Let's give up here. */
+ {
+ giveup_match_end = 1;
+ break;
+ }
+
bufpos = 0;
- while (bufpos < nread && same_at_start < ZV
- && FETCH_CHAR (same_at_start) == buffer[bufpos])
+ while (bufpos < nread && same_at_start < ZV_BYTE
+ && FETCH_BYTE (same_at_start) == buffer[bufpos])
same_at_start++, bufpos++;
/* If we found a discrepancy, stop the scan.
- Otherwise loop around and scan the next bufferfull. */
+ Otherwise loop around and scan the next bufferful. */
if (bufpos != nread)
break;
}
immediate_quit = 0;
/* If the file matches the buffer completely,
there's no need to replace anything. */
- if (same_at_start - BEGV == st.st_size)
+ if (same_at_start - BEGV_BYTE == XINT (end))
{
- close (fd);
+ emacs_close (fd);
specpdl_ptr--;
/* Truncate the buffer to the size of the file. */
- del_range_1 (same_at_start, same_at_end, 0);
+ del_range_1 (same_at_start, same_at_end, 0, 0);
goto handled;
}
immediate_quit = 1;
QUIT;
/* Count how many chars at the end of the file
- match the text at the end of the buffer. */
- while (1)
+ match the text at the end of the buffer. But, if we have
+ already found that decoding is necessary, don't waste time. */
+ while (!giveup_match_end)
{
int total_read, nread, bufpos, curpos, trial;
/* At what file position are we now scanning? */
- curpos = st.st_size - (ZV - same_at_end);
+ curpos = XINT (end) - (ZV_BYTE - same_at_end);
/* If the entire file matches the buffer tail, stop the scan. */
if (curpos == 0)
break;
trial = min (curpos, sizeof buffer);
if (lseek (fd, curpos - trial, 0) < 0)
report_file_error ("Setting file position",
- Fcons (filename, Qnil));
+ Fcons (orig_filename, Qnil));
total_read = 0;
while (total_read < trial)
{
- nread = read (fd, buffer + total_read, trial - total_read);
+ nread = emacs_read (fd, buffer + total_read, trial - total_read);
if (nread <= 0)
error ("IO error reading %s: %s",
- XSTRING (filename)->data, strerror (errno));
+ XSTRING (orig_filename)->data, emacs_strerror (errno));
total_read += nread;
}
- /* Scan this bufferfull from the end, comparing with
+ /* Scan this bufferful from the end, comparing with
the Emacs buffer. */
bufpos = total_read;
/* Compare with same_at_start to avoid counting some buffer text
as matching both at the file's beginning and at the end. */
while (bufpos > 0 && same_at_end > same_at_start
- && FETCH_CHAR (same_at_end - 1) == buffer[bufpos - 1])
+ && FETCH_BYTE (same_at_end - 1) == buffer[bufpos - 1])
same_at_end--, bufpos--;
+
/* If we found a discrepancy, stop the scan.
- Otherwise loop around and scan the preceding bufferfull. */
+ Otherwise loop around and scan the preceding bufferful. */
if (bufpos != 0)
- break;
+ {
+ /* If this discrepancy is because of code conversion,
+ we cannot use this method; giveup and try the other. */
+ if (same_at_end > same_at_start
+ && FETCH_BYTE (same_at_end - 1) >= 0200
+ && ! NILP (current_buffer->enable_multibyte_characters)
+ && (CODING_MAY_REQUIRE_DECODING (&coding)))
+ giveup_match_end = 1;
+ break;
+ }
}
immediate_quit = 0;
+ if (! giveup_match_end)
+ {
+ int temp;
+
+ /* We win! We can handle REPLACE the optimized way. */
+
+ /* Extend the start of non-matching text area to multibyte
+ character boundary. */
+ if (! NILP (current_buffer->enable_multibyte_characters))
+ while (same_at_start > BEGV_BYTE
+ && ! CHAR_HEAD_P (FETCH_BYTE (same_at_start)))
+ same_at_start--;
+
+ /* Extend the end of non-matching text area to multibyte
+ character boundary. */
+ if (! NILP (current_buffer->enable_multibyte_characters))
+ while (same_at_end < ZV_BYTE
+ && ! CHAR_HEAD_P (FETCH_BYTE (same_at_end)))
+ same_at_end++;
+
+ /* Don't try to reuse the same piece of text twice. */
+ overlap = (same_at_start - BEGV_BYTE
+ - (same_at_end + st.st_size - ZV));
+ if (overlap > 0)
+ same_at_end += overlap;
+
+ /* Arrange to read only the nonmatching middle part of the file. */
+ XSETFASTINT (beg, XINT (beg) + (same_at_start - BEGV_BYTE));
+ XSETFASTINT (end, XINT (end) - (ZV_BYTE - same_at_end));
+
+ del_range_byte (same_at_start, same_at_end, 0);
+ /* Insert from the file at the proper position. */
+ temp = BYTE_TO_CHAR (same_at_start);
+ SET_PT_BOTH (temp, same_at_start);
+
+ /* If display currently starts at beginning of line,
+ keep it that way. */
+ if (XBUFFER (XWINDOW (selected_window)->buffer) == current_buffer)
+ XWINDOW (selected_window)->start_at_line_beg = Fbolp ();
+
+ replace_handled = 1;
+ }
+ }
+
+ /* If requested, replace the accessible part of the buffer
+ with the file contents. Avoid replacing text at the
+ beginning or end of the buffer that matches the file contents;
+ that preserves markers pointing to the unchanged parts.
+
+ Here we implement this feature for the case where code conversion
+ is needed, in a simple way that needs a lot of memory.
+ The preceding if-statement handles the case of no conversion
+ in a more optimized way. */
+ if (!NILP (replace) && ! replace_handled && BEGV < ZV)
+ {
+ int same_at_start = BEGV_BYTE;
+ int same_at_end = ZV_BYTE;
+ int overlap;
+ int bufpos;
+ /* Make sure that the gap is large enough. */
+ int bufsize = 2 * st.st_size;
+ unsigned char *conversion_buffer = (unsigned char *) xmalloc (bufsize);
+ int temp;
+
+ /* First read the whole file, performing code conversion into
+ CONVERSION_BUFFER. */
+
+ if (lseek (fd, XINT (beg), 0) < 0)
+ {
+ xfree (conversion_buffer);
+ report_file_error ("Setting file position",
+ Fcons (orig_filename, Qnil));
+ }
+
+ total = st.st_size; /* Total bytes in the file. */
+ how_much = 0; /* Bytes read from file so far. */
+ inserted = 0; /* Bytes put into CONVERSION_BUFFER so far. */
+ unprocessed = 0; /* Bytes not processed in previous loop. */
+
+ while (how_much < total)
+ {
+ /* try is reserved in some compilers (Microsoft C) */
+ int trytry = min (total - how_much, READ_BUF_SIZE - unprocessed);
+ unsigned char *destination = read_buf + unprocessed;
+ int this;
+
+ /* Allow quitting out of the actual I/O. */
+ immediate_quit = 1;
+ QUIT;
+ this = emacs_read (fd, destination, trytry);
+ immediate_quit = 0;
+
+ if (this < 0 || this + unprocessed == 0)
+ {
+ how_much = this;
+ break;
+ }
+
+ how_much += this;
+
+ if (CODING_MAY_REQUIRE_DECODING (&coding))
+ {
+ int require, result;
+
+ this += unprocessed;
+
+ /* If we are using more space than estimated,
+ make CONVERSION_BUFFER bigger. */
+ require = decoding_buffer_size (&coding, this);
+ if (inserted + require + 2 * (total - how_much) > bufsize)
+ {
+ bufsize = inserted + require + 2 * (total - how_much);
+ conversion_buffer = (unsigned char *) xrealloc (conversion_buffer, bufsize);
+ }
+
+ /* Convert this batch with results in CONVERSION_BUFFER. */
+ if (how_much >= total) /* This is the last block. */
+ coding.mode |= CODING_MODE_LAST_BLOCK;
+ result = decode_coding (&coding, read_buf,
+ conversion_buffer + inserted,
+ this, bufsize - inserted);
+
+ /* Save for next iteration whatever we didn't convert. */
+ unprocessed = this - coding.consumed;
+ bcopy (read_buf + coding.consumed, read_buf, unprocessed);
+ this = coding.produced;
+ }
+
+ inserted += this;
+ }
+
+ /* At this point, INSERTED is how many characters (i.e. bytes)
+ are present in CONVERSION_BUFFER.
+ HOW_MUCH should equal TOTAL,
+ or should be <= 0 if we couldn't read the file. */
+
+ if (how_much < 0)
+ {
+ xfree (conversion_buffer);
+
+ if (how_much == -1)
+ error ("IO error reading %s: %s",
+ XSTRING (orig_filename)->data, emacs_strerror (errno));
+ else if (how_much == -2)
+ error ("maximum buffer size exceeded");
+ }
+
+ /* Compare the beginning of the converted file
+ with the buffer text. */
+
+ bufpos = 0;
+ while (bufpos < inserted && same_at_start < same_at_end
+ && FETCH_BYTE (same_at_start) == conversion_buffer[bufpos])
+ same_at_start++, bufpos++;
+
+ /* If the file matches the buffer completely,
+ there's no need to replace anything. */
+
+ if (bufpos == inserted)
+ {
+ xfree (conversion_buffer);
+ emacs_close (fd);
+ specpdl_ptr--;
+ /* Truncate the buffer to the size of the file. */
+ del_range_byte (same_at_start, same_at_end, 0);
+ inserted = 0;
+ goto handled;
+ }
+
+ /* Extend the start of non-matching text area to multibyte
+ character boundary. */
+ if (! NILP (current_buffer->enable_multibyte_characters))
+ while (same_at_start > BEGV_BYTE
+ && ! CHAR_HEAD_P (FETCH_BYTE (same_at_start)))
+ same_at_start--;
+
+ /* Scan this bufferful from the end, comparing with
+ the Emacs buffer. */
+ bufpos = inserted;
+
+ /* Compare with same_at_start to avoid counting some buffer text
+ as matching both at the file's beginning and at the end. */
+ while (bufpos > 0 && same_at_end > same_at_start
+ && FETCH_BYTE (same_at_end - 1) == conversion_buffer[bufpos - 1])
+ same_at_end--, bufpos--;
+
+ /* Extend the end of non-matching text area to multibyte
+ character boundary. */
+ if (! NILP (current_buffer->enable_multibyte_characters))
+ while (same_at_end < ZV_BYTE
+ && ! CHAR_HEAD_P (FETCH_BYTE (same_at_end)))
+ same_at_end++;
+
/* Don't try to reuse the same piece of text twice. */
- overlap = same_at_start - BEGV - (same_at_end + st.st_size - ZV);
+ overlap = same_at_start - BEGV_BYTE - (same_at_end + inserted - ZV_BYTE);
if (overlap > 0)
same_at_end += overlap;
- /* Arrange to read only the nonmatching middle part of the file. */
- XSETFASTINT (beg, same_at_start - BEGV);
- XSETFASTINT (end, st.st_size - (ZV - same_at_end));
+ /* If display currently starts at beginning of line,
+ keep it that way. */
+ if (XBUFFER (XWINDOW (selected_window)->buffer) == current_buffer)
+ XWINDOW (selected_window)->start_at_line_beg = Fbolp ();
- del_range_1 (same_at_start, same_at_end, 0);
+ /* Replace the chars that we need to replace,
+ and update INSERTED to equal the number of bytes
+ we are taking from the file. */
+ inserted -= (Z_BYTE - same_at_end) + (same_at_start - BEG_BYTE);
+
+ if (same_at_end != same_at_start)
+ {
+ del_range_byte (same_at_start, same_at_end, 0);
+ temp = GPT;
+ same_at_start = GPT_BYTE;
+ }
+ else
+ {
+ temp = BYTE_TO_CHAR (same_at_start);
+ }
/* Insert from the file at the proper position. */
- SET_PT (same_at_start);
+ SET_PT_BOTH (temp, same_at_start);
+ insert_1 (conversion_buffer + same_at_start - BEG_BYTE, inserted,
+ 0, 0, 0);
+ /* Set `inserted' to the number of inserted characters. */
+ inserted = PT - temp;
+
+ free (conversion_buffer);
+ emacs_close (fd);
+ specpdl_ptr--;
+
+ goto handled;
}
-#endif /* not DOS_NT */
- total = XINT (end) - XINT (beg);
+ if (! not_regular)
+ {
+ register Lisp_Object temp;
- {
- register Lisp_Object temp;
+ total = XINT (end) - XINT (beg);
- /* Make sure point-max won't overflow after this insertion. */
- XSETINT (temp, total);
- if (total != XINT (temp))
- error ("maximum buffer size exceeded");
- }
+ /* Make sure point-max won't overflow after this insertion. */
+ XSETINT (temp, total);
+ if (total != XINT (temp))
+ error ("Maximum buffer size exceeded");
+ }
+ else
+ /* For a special file, all we can do is guess. */
+ total = READ_BUF_SIZE;
if (NILP (visit) && total > 0)
- prepare_to_modify_buffer (point, point);
+ prepare_to_modify_buffer (PT, PT, NULL);
- move_gap (point);
+ move_gap (PT);
if (GAP_SIZE < total)
make_gap (total - GAP_SIZE);
if (XINT (beg) != 0 || !NILP (replace))
{
if (lseek (fd, XINT (beg), 0) < 0)
- report_file_error ("Setting file position", Fcons (filename, Qnil));
+ report_file_error ("Setting file position",
+ Fcons (orig_filename, Qnil));
}
+ /* In the following loop, HOW_MUCH contains the total bytes read so
+ far for a regular file, and not changed for a special file. But,
+ before exiting the loop, it is set to a negative value if I/O
+ error occurs. */
how_much = 0;
- while (inserted < total)
+ /* Total bytes inserted. */
+ inserted = 0;
+ /* Here, we don't do code conversion in the loop. It is done by
+ code_convert_region after all data are read into the buffer. */
+ while (how_much < total)
{
/* try is reserved in some compilers (Microsoft C) */
- int trytry = min (total - inserted, 64 << 10);
+ int trytry = min (total - how_much, READ_BUF_SIZE);
int this;
+ /* For a special file, GAP_SIZE should be checked every time. */
+ if (not_regular && GAP_SIZE < trytry)
+ make_gap (total - GAP_SIZE);
+
/* Allow quitting out of the actual I/O. */
immediate_quit = 1;
QUIT;
- this = read (fd, &FETCH_CHAR (point + inserted - 1) + 1, trytry);
+ this = emacs_read (fd, BYTE_POS_ADDR (PT_BYTE + inserted - 1) + 1,
+ trytry);
immediate_quit = 0;
if (this <= 0)
break;
}
- GPT += this;
GAP_SIZE -= this;
+ GPT_BYTE += this;
+ ZV_BYTE += this;
+ Z_BYTE += this;
+ GPT += this;
ZV += this;
Z += this;
+
+ /* For a regular file, where TOTAL is the real size,
+ count HOW_MUCH to compare with it.
+ For a special file, where TOTAL is just a buffer size,
+ so don't bother counting in HOW_MUCH.
+ (INSERTED is where we count the number of characters inserted.) */
+ if (! not_regular)
+ how_much += this;
inserted += this;
}
-#ifdef DOS_NT
- /* Demacs 1.1.1 91/10/16 HIRANO Satoshi, MW July 1993 */
- /* Determine file type from name and remove LFs from CR-LFs if the file
- is deemed to be a text file. */
- {
- current_buffer->buffer_file_type
- = call1 (Qfind_buffer_file_type, filename);
- if (NILP (current_buffer->buffer_file_type))
+ if (GAP_SIZE > 0)
+ /* Put an anchor to ensure multi-byte form ends at gap. */
+ *GPT_ADDR = 0;
+
+ emacs_close (fd);
+
+ /* Discard the unwind protect for closing the file. */
+ specpdl_ptr--;
+
+ if (how_much < 0)
+ error ("IO error reading %s: %s",
+ XSTRING (orig_filename)->data, emacs_strerror (errno));
+
+ if (! coding_system_decided)
+ {
+ /* The coding system is not yet decided. Decide it by an
+ optimized method for handling `coding:' tag.
+
+ Note that we can get here only if the buffer was empty
+ before the insertion. */
+ Lisp_Object val;
+ val = Qnil;
+
+ if (!NILP (Vcoding_system_for_read))
+ val = Vcoding_system_for_read;
+ else
+ {
+ /* Since we are sure that the current buffer was empty
+ before the insertion, we can toggle
+ enable-multibyte-characters directly here without taking
+ care of marker adjustment and byte combining problem. By
+ this way, we can run Lisp program safely before decoding
+ the inserted text. */
+ Lisp_Object unwind_data;
+ int count = specpdl_ptr - specpdl;
+
+ unwind_data = Fcons (current_buffer->enable_multibyte_characters,
+ Fcons (current_buffer->undo_list,
+ Fcurrent_buffer ()));
+ current_buffer->enable_multibyte_characters = Qnil;
+ current_buffer->undo_list = Qt;
+ record_unwind_protect (decide_coding_unwind, unwind_data);
+
+ if (inserted > 0 && ! NILP (Vset_auto_coding_function))
+ {
+ val = call2 (Vset_auto_coding_function,
+ filename, make_number (inserted));
+ }
+
+ if (NILP (val))
+ {
+ /* If the coding system is not yet decided, check
+ file-coding-system-alist. */
+ Lisp_Object args[6], coding_systems;
+
+ args[0] = Qinsert_file_contents, args[1] = orig_filename;
+ args[2] = visit, args[3] = beg, args[4] = end, args[5] = Qnil;
+ coding_systems = Ffind_operation_coding_system (6, args);
+ if (CONSP (coding_systems))
+ val = XCAR (coding_systems);
+ }
+
+ unbind_to (count, Qnil);
+ inserted = Z_BYTE - BEG_BYTE;
+ }
+
+ /* The following kludgy code is to avoid some compiler bug.
+ We can't simply do
+ setup_coding_system (val, &coding);
+ on some system. */
{
- int reduced_size
- = inserted - crlf_to_lf (inserted, &FETCH_CHAR (point - 1) + 1);
- ZV -= reduced_size;
- Z -= reduced_size;
- GPT -= reduced_size;
- GAP_SIZE += reduced_size;
- inserted -= reduced_size;
+ struct coding_system temp_coding;
+ setup_coding_system (val, &temp_coding);
+ bcopy (&temp_coding, &coding, sizeof coding);
}
- }
-#endif /* DOS_NT */
-
- if (inserted > 0)
- {
- record_insert (point, inserted);
- /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
- offset_intervals (current_buffer, point, inserted);
- MODIFF++;
+ if (NILP (current_buffer->enable_multibyte_characters)
+ && ! NILP (val))
+ /* We must suppress all character code conversion except for
+ end-of-line conversion. */
+ setup_raw_text_coding_system (&coding);
}
- close (fd);
-
- /* Discard the unwind protect for closing the file. */
- specpdl_ptr--;
+ if (inserted > 0 || coding.type == coding_type_ccl)
+ {
+ if (CODING_MAY_REQUIRE_DECODING (&coding))
+ {
+ /* Here, we don't have to consider byte combining (see the
+ comment below) because code_convert_region takes care of
+ it. */
+ code_convert_region (PT, PT_BYTE, PT + inserted, PT_BYTE + inserted,
+ &coding, 0, 0);
+ inserted = (NILP (current_buffer->enable_multibyte_characters)
+ ? coding.produced : coding.produced_char);
+ }
+ else if (!NILP (current_buffer->enable_multibyte_characters))
+ {
+ int inserted_byte = inserted;
+
+ /* There's a possibility that we must combine bytes at the
+ head (resp. the tail) of the just inserted text with the
+ bytes before (resp. after) the gap to form a single
+ character. */
+ inserted = multibyte_chars_in_text (GPT_ADDR - inserted, inserted);
+ adjust_after_insert (PT, PT_BYTE,
+ PT + inserted_byte, PT_BYTE + inserted_byte,
+ inserted);
+ }
+ else
+ adjust_after_insert (PT, PT_BYTE, PT + inserted, PT_BYTE + inserted,
+ inserted);
+ }
- if (how_much < 0)
- error ("IO error reading %s: %s",
- XSTRING (filename)->data, strerror (errno));
+#ifdef DOS_NT
+ /* Use the conversion type to determine buffer-file-type
+ (find-buffer-file-type is now used to help determine the
+ conversion). */
+ if ((coding.eol_type == CODING_EOL_UNDECIDED
+ || coding.eol_type == CODING_EOL_LF)
+ && ! CODING_REQUIRE_DECODING (&coding))
+ current_buffer->buffer_file_type = Qt;
+ else
+ current_buffer->buffer_file_type = Qnil;
+#endif
notfound:
handled:
if (NILP (handler))
{
current_buffer->modtime = st.st_mtime;
- current_buffer->filename = filename;
+ current_buffer->filename = orig_filename;
}
SAVE_MODIFF = MODIFF;
#ifdef CLASH_DETECTION
if (NILP (handler))
{
- if (!NILP (current_buffer->filename))
- unlock_file (current_buffer->filename);
+ if (!NILP (current_buffer->file_truename))
+ unlock_file (current_buffer->file_truename);
unlock_file (filename);
}
#endif /* CLASH_DETECTION */
if (not_regular)
Fsignal (Qfile_error,
Fcons (build_string ("not a regular file"),
- Fcons (filename, Qnil)));
+ Fcons (orig_filename, Qnil)));
/* If visiting nonexistent file, return nil. */
if (current_buffer->modtime == -1)
- report_file_error ("Opening input file", Fcons (filename, Qnil));
+ report_file_error ("Opening input file", Fcons (orig_filename, Qnil));
+ }
+
+ /* Decode file format */
+ if (inserted > 0)
+ {
+ insval = call3 (Qformat_decode,
+ Qnil, make_number (inserted), visit);
+ CHECK_NUMBER (insval, 0);
+ inserted = XFASTINT (insval);
+ }
+
+ if (set_coding_system)
+ Vlast_coding_system_used = coding.symbol;
+
+ /* Call after-change hooks for the inserted text, aside from the case
+ of normal visiting (not with REPLACE), which is done in a new buffer
+ "before" the buffer is changed. */
+ if (inserted > 0 && total > 0
+ && (NILP (visit) || !NILP (replace)))
+ {
+ signal_after_change (PT, 0, inserted);
+ update_compositions (PT, PT, CHECK_BORDER);
}
- if (inserted > 0 && NILP (visit) && total > 0)
- signal_after_change (point, 0, inserted);
-
if (inserted > 0)
{
p = Vafter_insert_file_functions;
}
}
+ /* ??? Retval needs to be dealt with in all cases consistently. */
if (NILP (val))
- val = Fcons (filename,
+ val = Fcons (orig_filename,
Fcons (make_number (inserted),
Qnil));
RETURN_UNGCPRO (unbind_to (count, val));
}
\f
-static Lisp_Object build_annotations ();
+static Lisp_Object build_annotations P_ ((Lisp_Object, Lisp_Object,
+ Lisp_Object));
/* If build_annotations switched buffers, switch back to BUF.
- Kill the temporary buffer that was selected in the meantime. */
+ Kill the temporary buffer that was selected in the meantime.
+
+ Since this kill only the last temporary buffer, some buffers remain
+ not killed if build_annotations switched buffers more than once.
+ -- K.Handa */
-static Lisp_Object
+static Lisp_Object
build_annotations_unwind (buf)
Lisp_Object buf;
{
return Qnil;
}
-DEFUN ("write-region", Fwrite_region, Swrite_region, 3, 5,
- "r\nFWrite region to file: ",
+DEFUN ("write-region", Fwrite_region, Swrite_region, 3, 7,
+ "r\nFWrite region to file: \ni\ni\ni\np",
"Write current region into specified file.\n\
When called from a program, takes three arguments:\n\
START, END and FILENAME. START and END are buffer positions.\n\
VISIT is also the file name to lock and unlock for clash detection.\n\
If VISIT is neither t nor nil nor a string,\n\
that means do not print the \"Wrote file\" message.\n\
+The optional sixth arg LOCKNAME, if non-nil, specifies the name to\n\
+ use for locking and unlocking, overriding FILENAME and VISIT.\n\
+The optional seventh arg MUSTBENEW, if non-nil, insists on a check\n\
+ for an existing file with the same name. If MUSTBENEW is `excl',\n\
+ that means to get an error if the file already exists; never overwrite.\n\
+ If MUSTBENEW is neither nil nor `excl', that means ask for\n\
+ confirmation before overwriting, but do go ahead and overwrite the file\n\
+ if the user confirms.\n\
Kludgy feature: if START is a string, then that string is written\n\
-to the file, instead of any buffer contents, and END is ignored.")
- (start, end, filename, append, visit)
- Lisp_Object start, end, filename, append, visit;
+to the file, instead of any buffer contents, and END is ignored.\n\
+\n\
+This does code conversion according to the value of\n\
+`coding-system-for-write', `buffer-file-coding-system', or\n\
+`file-coding-system-alist', and sets the variable\n\
+`last-coding-system-used' to the coding system actually used.")
+
+ (start, end, filename, append, visit, lockname, mustbenew)
+ Lisp_Object start, end, filename, append, visit, lockname, mustbenew;
{
register int desc;
int failure;
Lisp_Object handler;
Lisp_Object visit_file;
Lisp_Object annotations;
+ Lisp_Object encoded_filename;
int visiting, quietly;
- struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
+ struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
struct buffer *given_buffer;
#ifdef DOS_NT
- int buffer_file_type
- = NILP (current_buffer->buffer_file_type) ? O_TEXT : O_BINARY;
+ int buffer_file_type = O_BINARY;
#endif /* DOS_NT */
+ struct coding_system coding;
if (current_buffer->base_buffer && ! NILP (visit))
error ("Cannot do file visiting in an indirect buffer");
if (!NILP (start) && !STRINGP (start))
validate_region (&start, &end);
- GCPRO2 (filename, visit);
+ GCPRO4 (start, filename, visit, lockname);
+
+ /* Decide the coding-system to encode the data with. */
+ {
+ Lisp_Object val;
+
+ if (auto_saving)
+ val = Qnil;
+ else if (!NILP (Vcoding_system_for_write))
+ val = Vcoding_system_for_write;
+ else
+ {
+ /* If the variable `buffer-file-coding-system' is set locally,
+ it means that the file was read with some kind of code
+ conversion or the varialbe is explicitely set by users. We
+ had better write it out with the same coding system even if
+ `enable-multibyte-characters' is nil.
+
+ If it is not set locally, we anyway have to convert EOL
+ format if the default value of `buffer-file-coding-system'
+ tells that it is not Unix-like (LF only) format. */
+ int using_default_coding = 0;
+ int force_raw_text = 0;
+
+ val = current_buffer->buffer_file_coding_system;
+ if (NILP (val)
+ || NILP (Flocal_variable_p (Qbuffer_file_coding_system, Qnil)))
+ {
+ val = Qnil;
+ if (NILP (current_buffer->enable_multibyte_characters))
+ force_raw_text = 1;
+ }
+
+ if (NILP (val))
+ {
+ /* Check file-coding-system-alist. */
+ Lisp_Object args[7], coding_systems;
+
+ args[0] = Qwrite_region; args[1] = start; args[2] = end;
+ args[3] = filename; args[4] = append; args[5] = visit;
+ args[6] = lockname;
+ coding_systems = Ffind_operation_coding_system (7, args);
+ if (CONSP (coding_systems) && !NILP (XCDR (coding_systems)))
+ val = XCDR (coding_systems);
+ }
+
+ if (NILP (val)
+ && !NILP (current_buffer->buffer_file_coding_system))
+ {
+ /* If we still have not decided a coding system, use the
+ default value of buffer-file-coding-system. */
+ val = current_buffer->buffer_file_coding_system;
+ using_default_coding = 1;
+ }
+
+ if (!force_raw_text
+ && !NILP (Ffboundp (Vselect_safe_coding_system_function)))
+ /* Confirm that VAL can surely encode the current region. */
+ val = call3 (Vselect_safe_coding_system_function, start, end, val);
+
+ setup_coding_system (Fcheck_coding_system (val), &coding);
+ if (coding.eol_type == CODING_EOL_UNDECIDED
+ && !using_default_coding)
+ {
+ if (! EQ (default_buffer_file_coding.symbol,
+ buffer_defaults.buffer_file_coding_system))
+ setup_coding_system (buffer_defaults.buffer_file_coding_system,
+ &default_buffer_file_coding);
+ if (default_buffer_file_coding.eol_type != CODING_EOL_UNDECIDED)
+ {
+ Lisp_Object subsidiaries;
+
+ coding.eol_type = default_buffer_file_coding.eol_type;
+ subsidiaries = Fget (coding.symbol, Qeol_type);
+ if (VECTORP (subsidiaries)
+ && XVECTOR (subsidiaries)->size == 3)
+ coding.symbol
+ = XVECTOR (subsidiaries)->contents[coding.eol_type];
+ }
+ }
+
+ if (force_raw_text)
+ setup_raw_text_coding_system (&coding);
+ goto done_setup_coding;
+ }
+
+ setup_coding_system (Fcheck_coding_system (val), &coding);
+
+ done_setup_coding:
+ if (!STRINGP (start) && !NILP (current_buffer->selective_display))
+ coding.mode |= CODING_MODE_SELECTIVE_DISPLAY;
+ }
+
+ Vlast_coding_system_used = coding.symbol;
+
filename = Fexpand_file_name (filename, Qnil);
+
+ if (! NILP (mustbenew) && mustbenew != Qexcl)
+ barf_or_query_if_file_exists (filename, "overwrite", 1, 0, 1);
+
if (STRINGP (visit))
visit_file = Fexpand_file_name (visit, Qnil);
else
annotations = Qnil;
- GCPRO4 (start, filename, annotations, visit_file);
+ if (NILP (lockname))
+ lockname = visit_file;
+
+ GCPRO5 (start, filename, annotations, visit_file, lockname);
/* If the file name has special constructs in it,
call the corresponding file handler. */
handler = Ffind_file_name_handler (filename, Qwrite_region);
/* If FILENAME has no handler, see if VISIT has one. */
if (NILP (handler) && STRINGP (visit))
- handler = Ffind_file_name_handler (visit, Qwrite_region);
+ handler = Ffind_file_name_handler (visit, Qwrite_region);
if (!NILP (handler))
{
count1 = specpdl_ptr - specpdl;
given_buffer = current_buffer;
- annotations = build_annotations (start, end);
+ annotations = build_annotations (start, end, coding.pre_write_conversion);
if (current_buffer != given_buffer)
{
- start = BEGV;
- end = ZV;
+ XSETFASTINT (start, BEGV);
+ XSETFASTINT (end, ZV);
}
#ifdef CLASH_DETECTION
if (!auto_saving)
- lock_file (visit_file);
+ {
+#if 0 /* This causes trouble for GNUS. */
+ /* If we've locked this file for some other buffer,
+ query before proceeding. */
+ if (!visiting && EQ (Ffile_locked_p (lockname), Qt))
+ call2 (intern ("ask-user-about-lock"), filename, Vuser_login_name);
+#endif
+
+ lock_file (lockname);
+ }
#endif /* CLASH_DETECTION */
- fn = XSTRING (filename)->data;
+ encoded_filename = ENCODE_FILE (filename);
+
+ fn = XSTRING (encoded_filename)->data;
desc = -1;
if (!NILP (append))
#ifdef DOS_NT
- desc = open (fn, O_WRONLY | buffer_file_type);
+ desc = emacs_open (fn, O_WRONLY | buffer_file_type, 0);
#else /* not DOS_NT */
- desc = open (fn, O_WRONLY);
+ desc = emacs_open (fn, O_WRONLY, 0);
#endif /* not DOS_NT */
- if (desc < 0)
+ if (desc < 0 && (NILP (append) || errno == ENOENT))
#ifdef VMS
if (auto_saving) /* Overwrite any previous version of autosave file */
{
vms_truncate (fn); /* if fn exists, truncate to zero length */
- desc = open (fn, O_RDWR);
+ desc = emacs_open (fn, O_RDWR, 0);
if (desc < 0)
desc = creat_copy_attrs (STRINGP (current_buffer->filename)
? XSTRING (current_buffer->filename)->data : 0,
/* We can't make a new version;
try to truncate and rewrite existing version if any. */
vms_truncate (fn);
- desc = open (fn, O_RDWR);
+ desc = emacs_open (fn, O_RDWR, 0);
}
#endif
}
}
#else /* not VMS */
#ifdef DOS_NT
- desc = open (fn,
- O_WRONLY | O_TRUNC | O_CREAT | buffer_file_type,
- S_IREAD | S_IWRITE);
+ desc = emacs_open (fn,
+ O_WRONLY | O_TRUNC | O_CREAT | buffer_file_type
+ | (mustbenew == Qexcl ? O_EXCL : 0),
+ S_IREAD | S_IWRITE);
#else /* not DOS_NT */
- desc = creat (fn, auto_saving ? auto_save_mode_bits : 0666);
+ desc = emacs_open (fn, O_WRONLY | O_TRUNC | O_CREAT
+ | (mustbenew == Qexcl ? O_EXCL : 0),
+ auto_saving ? auto_save_mode_bits : 0666);
#endif /* not DOS_NT */
#endif /* not VMS */
{
#ifdef CLASH_DETECTION
save_errno = errno;
- if (!auto_saving) unlock_file (visit_file);
+ if (!auto_saving) unlock_file (lockname);
errno = save_errno;
#endif /* CLASH_DETECTION */
report_file_error ("Opening output file", Fcons (filename, Qnil));
record_unwind_protect (close_file_unwind, make_number (desc));
- if (!NILP (append))
+ if (!NILP (append) && !NILP (Ffile_regular_p (filename)))
if (lseek (desc, 0, 2) < 0)
{
#ifdef CLASH_DETECTION
- if (!auto_saving) unlock_file (visit_file);
+ if (!auto_saving) unlock_file (lockname);
#endif /* CLASH_DETECTION */
report_file_error ("Lseek error", Fcons (filename, Qnil));
}
*/
if (GPT > BEG && GPT_ADDR[-1] != '\n')
move_gap (find_next_newline (GPT, 1));
+#else
+ /* Whether VMS or not, we must move the gap to the next of newline
+ when we must put designation sequences at beginning of line. */
+ if (INTEGERP (start)
+ && coding.type == coding_type_iso2022
+ && coding.flags & CODING_FLAG_ISO_DESIGNATE_AT_BOL
+ && GPT > BEG && GPT_ADDR[-1] != '\n')
+ {
+ int opoint = PT, opoint_byte = PT_BYTE;
+ scan_newline (PT, PT_BYTE, ZV, ZV_BYTE, 1, 0);
+ move_gap_both (PT, PT_BYTE);
+ SET_PT_BOTH (opoint, opoint_byte);
+ }
#endif
failure = 0;
if (STRINGP (start))
{
- failure = 0 > a_write (desc, XSTRING (start)->data,
- XSTRING (start)->size, 0, &annotations);
+ failure = 0 > a_write (desc, start, 0, XSTRING (start)->size,
+ &annotations, &coding);
save_errno = errno;
}
else if (XINT (start) != XINT (end))
{
- int nwritten = 0;
+ register int end1 = CHAR_TO_BYTE (XINT (end));
+
+ tem = CHAR_TO_BYTE (XINT (start));
+
if (XINT (start) < GPT)
{
- register int end1 = XINT (end);
- tem = XINT (start);
- failure = 0 > a_write (desc, &FETCH_CHAR (tem),
- min (GPT, end1) - tem, tem, &annotations);
- nwritten += min (GPT, end1) - tem;
+ failure = 0 > a_write (desc, Qnil, XINT (start),
+ min (GPT, XINT (end)) - XINT (start),
+ &annotations, &coding);
save_errno = errno;
}
if (XINT (end) > GPT && !failure)
{
- tem = XINT (start);
- tem = max (tem, GPT);
- failure = 0 > a_write (desc, &FETCH_CHAR (tem), XINT (end) - tem,
- tem, &annotations);
- nwritten += XINT (end) - tem;
+ tem = max (XINT (start), GPT);
+ failure = 0 > a_write (desc, Qnil, tem , XINT (end) - tem,
+ &annotations, &coding);
save_errno = errno;
}
+ }
+ else
+ {
+ /* If file was empty, still need to write the annotations */
+ coding.mode |= CODING_MODE_LAST_BLOCK;
+ failure = 0 > a_write (desc, Qnil, XINT (end), 0, &annotations, &coding);
+ save_errno = errno;
+ }
- if (nwritten == 0)
- {
- /* If file was empty, still need to write the annotations */
- failure = 0 > a_write (desc, "", 0, XINT (start), &annotations);
- save_errno = errno;
- }
+ if (CODING_REQUIRE_FLUSHING (&coding)
+ && !(coding.mode & CODING_MODE_LAST_BLOCK)
+ && ! failure)
+ {
+ /* We have to flush out a data. */
+ coding.mode |= CODING_MODE_LAST_BLOCK;
+ failure = 0 > e_write (desc, Qnil, 0, 0, &coding);
+ save_errno = errno;
}
immediate_quit = 0;
/* mib says that closing the file will try to write as fast as NFS can do
it, and that means the fsync here is not crucial for autosave files. */
if (!auto_saving && fsync (desc) < 0)
- failure = 1, save_errno = errno;
+ {
+ /* If fsync fails with EINTR, don't treat that as serious. */
+ if (errno != EINTR)
+ failure = 1, save_errno = errno;
+ }
#endif
- /* Spurious "file has changed on disk" warnings have been
+ /* Spurious "file has changed on disk" warnings have been
observed on Suns as well.
It seems that `close' can change the modtime, under nfs.
#endif
/* NFS can report a write failure now. */
- if (close (desc) < 0)
+ if (emacs_close (desc) < 0)
failure = 1, save_errno = errno;
#ifdef VMS
#ifdef CLASH_DETECTION
if (!auto_saving)
- unlock_file (visit_file);
+ unlock_file (lockname);
#endif /* CLASH_DETECTION */
/* Do this before reporting IO error
current_buffer->modtime = st.st_mtime;
if (failure)
- error ("IO error writing %s: %s", fn, strerror (save_errno));
+ error ("IO error writing %s: %s", XSTRING (filename)->data,
+ emacs_strerror (save_errno));
if (visiting)
{
return Qnil;
if (!auto_saving)
- message ("Wrote %s", XSTRING (visit_file)->data);
+ message_with_string ("Wrote %s", visit_file, 1);
return Qnil;
}
-
+\f
Lisp_Object merge ();
DEFUN ("car-less-than-car", Fcar_less_than_car, Scar_less_than_car, 2, 2, 0,
as save-excursion would do. */
static Lisp_Object
-build_annotations (start, end)
- Lisp_Object start, end;
+build_annotations (start, end, pre_write_conversion)
+ Lisp_Object start, end, pre_write_conversion;
{
Lisp_Object annotations;
Lisp_Object p, res;
struct gcpro gcpro1, gcpro2;
+ Lisp_Object original_buffer;
+
+ XSETBUFFER (original_buffer, current_buffer);
annotations = Qnil;
p = Vwrite_region_annotate_functions;
been dealt with by this function. */
if (current_buffer != given_buffer)
{
- start = BEGV;
- end = ZV;
+ XSETFASTINT (start, BEGV);
+ XSETFASTINT (end, ZV);
annotations = Qnil;
}
Flength (res); /* Check basic validity of return value */
annotations = merge (annotations, res, Qcar_less_than_car);
p = Fcdr (p);
}
+
+ /* Now do the same for annotation functions implied by the file-format */
+ if (auto_saving && (!EQ (Vauto_save_file_format, Qt)))
+ p = Vauto_save_file_format;
+ else
+ p = current_buffer->file_format;
+ while (!NILP (p))
+ {
+ struct buffer *given_buffer = current_buffer;
+ Vwrite_region_annotations_so_far = annotations;
+ res = call4 (Qformat_annotate_function, Fcar (p), start, end,
+ original_buffer);
+ if (current_buffer != given_buffer)
+ {
+ XSETFASTINT (start, BEGV);
+ XSETFASTINT (end, ZV);
+ annotations = Qnil;
+ }
+ Flength (res);
+ annotations = merge (annotations, res, Qcar_less_than_car);
+ p = Fcdr (p);
+ }
+
+ /* At last, do the same for the function PRE_WRITE_CONVERSION
+ implied by the current coding-system. */
+ if (!NILP (pre_write_conversion))
+ {
+ struct buffer *given_buffer = current_buffer;
+ Vwrite_region_annotations_so_far = annotations;
+ res = call2 (pre_write_conversion, start, end);
+ Flength (res);
+ annotations = (current_buffer != given_buffer
+ ? res
+ : merge (annotations, res, Qcar_less_than_car));
+ }
+
UNGCPRO;
return annotations;
}
-
-/* Write to descriptor DESC the LEN characters starting at ADDR,
- assuming they start at position POS in the buffer.
+\f
+/* Write to descriptor DESC the NCHARS chars starting at POS of STRING.
+ If STRING is nil, POS is the character position in the current buffer.
Intersperse with them the annotations from *ANNOT
- (those which fall within the range of positions POS to POS + LEN),
+ which fall within the range of POS to POS + NCHARS,
each at its appropriate position.
- Modify *ANNOT by discarding elements as we output them.
+ We modify *ANNOT by discarding elements as we use them up.
+
The return value is negative in case of system call failure. */
-int
-a_write (desc, addr, len, pos, annot)
+static int
+a_write (desc, string, pos, nchars, annot, coding)
int desc;
- register char *addr;
- register int len;
+ Lisp_Object string;
+ register int nchars;
int pos;
Lisp_Object *annot;
+ struct coding_system *coding;
{
Lisp_Object tem;
int nextpos;
- int lastpos = pos + len;
+ int lastpos = pos + nchars;
while (NILP (*annot) || CONSP (*annot))
{
tem = Fcar_safe (Fcar (*annot));
- if (INTEGERP (tem) && XINT (tem) >= pos && XFASTINT (tem) <= lastpos)
+ nextpos = pos - 1;
+ if (INTEGERP (tem))
nextpos = XFASTINT (tem);
- else
- return e_write (desc, addr, lastpos - pos);
+
+ /* If there are no more annotations in this range,
+ output the rest of the range all at once. */
+ if (! (nextpos >= pos && nextpos <= lastpos))
+ return e_write (desc, string, pos, lastpos, coding);
+
+ /* Output buffer text up to the next annotation's position. */
if (nextpos > pos)
{
- if (0 > e_write (desc, addr, nextpos - pos))
+ if (0 > e_write (desc, string, pos, nextpos, coding));
return -1;
- addr += nextpos - pos;
pos = nextpos;
}
+ /* Output the annotation. */
tem = Fcdr (Fcar (*annot));
if (STRINGP (tem))
{
- if (0 > e_write (desc, XSTRING (tem)->data, XSTRING (tem)->size))
+ if (0 > e_write (desc, tem, 0, XSTRING (tem)->size, coding));
return -1;
}
*annot = Fcdr (*annot);
}
+ return 0;
}
-int
-e_write (desc, addr, len)
+#ifndef WRITE_BUF_SIZE
+#define WRITE_BUF_SIZE (16 * 1024)
+#endif
+
+/* Write text in the range START and END into descriptor DESC,
+ encoding them with coding system CODING. If STRING is nil, START
+ and END are character positions of the current buffer, else they
+ are indexes to the string STRING. */
+
+static int
+e_write (desc, string, start, end, coding)
int desc;
- register char *addr;
- register int len;
+ Lisp_Object string;
+ int start, end;
+ struct coding_system *coding;
{
- char buf[16 * 1024];
- register char *p, *end;
-
- if (!EQ (current_buffer->selective_display, Qt))
- return write (desc, addr, len) - len;
+ register char *addr;
+ register int nbytes;
+ char buf[WRITE_BUF_SIZE];
+ int composing = coding->composing;
+ int return_val = 0;
+
+ if (start >= end)
+ coding->composing = COMPOSITION_DISABLED;
+ if (coding->composing != COMPOSITION_DISABLED)
+ coding_save_composition (coding, start, end, string);
+
+ if (STRINGP (string))
+ {
+ addr = XSTRING (string)->data;
+ nbytes = STRING_BYTES (XSTRING (string));
+ }
+ else if (start < end)
+ {
+ /* It is assured that the gap is not in the range START and END-1. */
+ addr = CHAR_POS_ADDR (start);
+ nbytes = CHAR_TO_BYTE (end) - CHAR_TO_BYTE (start);
+ }
else
{
- p = buf;
- end = p + sizeof buf;
- while (len--)
+ addr = "";
+ nbytes = 0;
+ }
+
+ /* We used to have a code for handling selective display here. But,
+ now it is handled within encode_coding. */
+ while (1)
+ {
+ int result;
+
+ result = encode_coding (coding, addr, buf, nbytes, WRITE_BUF_SIZE);
+ if (coding->produced > 0)
+ {
+ coding->produced -= emacs_write (desc, buf, coding->produced);
+ if (coding->produced)
+ {
+ return_val = -1;
+ break;
+ }
+ }
+ if (result == CODING_FINISH_INSUFFICIENT_SRC)
{
- if (p == end)
+ /* The source text ends by an incomplete multibyte form.
+ There's no way other than write it out as is. */
+ nbytes -= emacs_write (desc, addr, nbytes);
+ if (nbytes)
{
- if (write (desc, buf, sizeof buf) != sizeof buf)
- return -1;
- p = buf;
+ return_val = -1;
+ break;
}
- *p = *addr++;
- if (*p++ == '\015')
- p[-1] = '\n';
}
- if (p != buf)
- if (write (desc, buf, p - buf) != p - buf)
- return -1;
+ if (nbytes <= 0)
+ break;
+ nbytes -= coding->consumed;
+ addr += coding->consumed;
+ start += coding->consumed_char;
+ if (coding->cmp_data)
+ coding_adjust_composition_offset (coding, start);
}
return 0;
}
-
+\f
DEFUN ("verify-visited-file-modtime", Fverify_visited_file_modtime,
Sverify_visited_file_modtime, 1, 1, 0,
"Return t if last mod time of BUF's visited file matches what BUF records.\n\
struct buffer *b;
struct stat st;
Lisp_Object handler;
+ Lisp_Object filename;
CHECK_BUFFER (buf, 0);
b = XBUFFER (buf);
if (!NILP (handler))
return call2 (handler, Qverify_visited_file_modtime, buf);
- if (stat (XSTRING (b->filename)->data, &st) < 0)
+ filename = ENCODE_FILE (b->filename);
+
+ if (stat (XSTRING (filename)->data, &st) < 0)
{
/* If the file doesn't exist now and didn't exist before,
we say that it isn't modified, provided the error is a tame one. */
that `file-attributes' returns.")
()
{
- return long_to_cons (current_buffer->modtime);
+ return long_to_cons ((unsigned long) current_buffer->modtime);
}
DEFUN ("set-visited-file-modtime", Fset_visited_file_modtime,
if (!NILP (handler))
/* The handler can find the file name the same way we did. */
return call2 (handler, Qset_visited_file_modtime, Qnil);
- else if (stat (XSTRING (filename)->data, &st) >= 0)
+
+ filename = ENCODE_FILE (filename);
+
+ if (stat (XSTRING (filename)->data, &st) >= 0)
current_buffer->modtime = st.st_mtime;
}
auto_save_error ()
{
ring_bell ();
- message ("Autosaving...error for %s", XSTRING (current_buffer->name)->data);
+ message_with_string ("Autosaving...error for %s", current_buffer->name, 1);
Fsleep_for (make_number (1), Qnil);
- message ("Autosaving...error!for %s", XSTRING (current_buffer->name)->data);
+ message_with_string ("Autosaving...error for %s", current_buffer->name, 0);
Fsleep_for (make_number (1), Qnil);
- message ("Autosaving...error for %s", XSTRING (current_buffer->name)->data);
+ message_with_string ("Autosaving...error for %s", current_buffer->name, 0);
Fsleep_for (make_number (1), Qnil);
return Qnil;
}
return
Fwrite_region (Qnil, Qnil,
current_buffer->auto_save_file_name,
- Qnil, Qlambda);
+ Qnil, Qlambda, Qnil, Qnil);
+}
+
+static Lisp_Object
+do_auto_save_unwind (stream) /* used as unwind-protect function */
+ Lisp_Object stream;
+{
+ auto_saving = 0;
+ if (!NILP (stream))
+ fclose ((FILE *) (XFASTINT (XCAR (stream)) << 16
+ | XFASTINT (XCDR (stream))));
+ return Qnil;
}
static Lisp_Object
-do_auto_save_unwind (desc) /* used as unwind-protect function */
- Lisp_Object desc;
+do_auto_save_unwind_1 (value) /* used as unwind-protect function */
+ Lisp_Object value;
{
- close (XINT (desc));
+ minibuffer_auto_raise = XINT (value);
return Qnil;
}
so that your editing is not lost if the system crashes.\n\
This file is not the file you visited; that changes only when you save.\n\
Normally we run the normal hook `auto-save-hook' before saving.\n\n\
-Non-nil first argument means do not print any message if successful.\n\
-Non-nil second argument means save only current buffer.")
+A non-nil NO-MESSAGE argument means do not print any message if successful.\n\
+A non-nil CURRENT-ONLY argument means save only current buffer.")
(no_message, current_only)
Lisp_Object no_message, current_only;
{
struct buffer *old = current_buffer, *b;
Lisp_Object tail, buf;
int auto_saved = 0;
- char *omessage = echo_area_glyphs;
- int omessage_length = echo_area_glyphs_length;
- extern int minibuf_level;
int do_handled_files;
Lisp_Object oquit;
- int listdesc;
+ FILE *stream;
+ Lisp_Object lispstream;
int count = specpdl_ptr - specpdl;
int *ptr;
-
+ int orig_minibuffer_auto_raise = minibuffer_auto_raise;
+ int message_p = push_message ();
+
/* Ordinarily don't quit within this function,
but don't make it impossible to quit (in case we get hung in I/O). */
oquit = Vquit_flag;
/* No GCPRO needed, because (when it matters) all Lisp_Object variables
point to non-strings reached from Vbuffer_alist. */
- auto_saving = 1;
if (minibuf_level)
no_message = Qt;
if (STRINGP (Vauto_save_list_file_name))
{
-#ifdef DOS_NT
- listdesc = open (XSTRING (Vauto_save_list_file_name)->data,
- O_WRONLY | O_TRUNC | O_CREAT | O_TEXT,
- S_IREAD | S_IWRITE);
-#else /* not DOS_NT */
- listdesc = creat (XSTRING (Vauto_save_list_file_name)->data, 0666);
-#endif /* not DOS_NT */
+ Lisp_Object listfile;
+ listfile = Fexpand_file_name (Vauto_save_list_file_name, Qnil);
+ stream = fopen (XSTRING (listfile)->data, "w");
+ if (stream != NULL)
+ {
+ /* Arrange to close that file whether or not we get an error.
+ Also reset auto_saving to 0. */
+ lispstream = Fcons (Qnil, Qnil);
+ XSETFASTINT (XCAR (lispstream), (EMACS_UINT)stream >> 16);
+ XSETFASTINT (XCDR (lispstream), (EMACS_UINT)stream & 0xffff);
+ }
+ else
+ lispstream = Qnil;
}
else
- listdesc = -1;
-
- /* Arrange to close that file whether or not we get an error. */
- if (listdesc >= 0)
- record_unwind_protect (do_auto_save_unwind, make_number (listdesc));
+ {
+ stream = NULL;
+ lispstream = Qnil;
+ }
+
+ record_unwind_protect (do_auto_save_unwind, lispstream);
+ record_unwind_protect (do_auto_save_unwind_1,
+ make_number (minibuffer_auto_raise));
+ minibuffer_auto_raise = 0;
+ auto_saving = 1;
/* First, save all files which don't have handlers. If Emacs is
crashing, the handlers may tweak what is causing Emacs to crash
autosave perfectly ordinary files because it couldn't handle some
ange-ftp'd file. */
for (do_handled_files = 0; do_handled_files < 2; do_handled_files++)
- for (tail = Vbuffer_alist; GC_CONSP (tail); tail = XCONS (tail)->cdr)
+ for (tail = Vbuffer_alist; GC_CONSP (tail); tail = XCDR (tail))
{
- buf = XCONS (XCONS (tail)->car)->cdr;
+ buf = XCDR (XCAR (tail));
b = XBUFFER (buf);
-
+
/* Record all the buffers that have auto save mode
- in the special file that lists them. */
+ in the special file that lists them. For each of these buffers,
+ Record visited name (if any) and auto save name. */
if (STRINGP (b->auto_save_file_name)
- && listdesc >= 0 && do_handled_files == 0)
+ && stream != NULL && do_handled_files == 0)
{
- write (listdesc, XSTRING (b->auto_save_file_name)->data,
- XSTRING (b->auto_save_file_name)->size);
- write (listdesc, "\n", 1);
+ if (!NILP (b->filename))
+ {
+ fwrite (XSTRING (b->filename)->data, 1,
+ STRING_BYTES (XSTRING (b->filename)), stream);
+ }
+ putc ('\n', stream);
+ fwrite (XSTRING (b->auto_save_file_name)->data, 1,
+ STRING_BYTES (XSTRING (b->auto_save_file_name)), stream);
+ putc ('\n', stream);
}
if (!NILP (current_only)
&& NILP (no_message))
{
/* It has shrunk too much; turn off auto-saving here. */
- message ("Buffer %s has shrunk a lot; auto save turned off there",
- XSTRING (b->name)->data);
+ minibuffer_auto_raise = orig_minibuffer_auto_raise;
+ message_with_string ("Buffer %s has shrunk a lot; auto save turned off there",
+ b->name, 1);
+ minibuffer_auto_raise = 0;
/* Turn off auto-saving until there's a real save,
and prevent any more warnings. */
XSETINT (b->save_length, -1);
if (auto_saved && NILP (no_message))
{
- if (omessage)
- message2 (omessage, omessage_length);
+ if (message_p)
+ {
+ sit_for (1, 0, 0, 0, 0);
+ restore_message ();
+ }
else
message1 ("Auto-saving...done");
}
Vquit_flag = oquit;
- auto_saving = 0;
+ pop_message ();
unbind_to (count, Qnil);
return Qnil;
}
register int n;
int osize, count;
- osize = XSTRING (val)->size;
- /* Quote "$" as "$$" to get it past substitute-in-file-name */
+ osize = STRING_BYTES (XSTRING (val));
+
+ /* Count the number of $ characters. */
for (n = osize, count = 0, old = XSTRING (val)->data; n > 0; n--)
if (*old++ == '$') count++;
if (count > 0)
{
old = XSTRING (val)->data;
- val = Fmake_string (make_number (osize + count), make_number (0));
+ val = make_uninit_multibyte_string (XSTRING (val)->size + count,
+ osize + count);
new = XSTRING (val)->data;
for (n = osize; n > 0; n--)
if (*old != '$')
int changed;
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
+ CHECK_STRING (string, 0);
+
realdir = dir;
name = string;
orig_string = Qnil;
DEFUN ("read-file-name", Fread_file_name, Sread_file_name, 1, 5, 0,
"Read file name, prompting with PROMPT and completing in directory DIR.\n\
Value is not expanded---you must call `expand-file-name' yourself.\n\
-Default name to DEFAULT if user enters a null string.\n\
- (If DEFAULT is omitted, the visited file name is used,\n\
+Default name to DEFAULT-FILENAME if user enters a null string.\n\
+ (If DEFAULT-FILENAME is omitted, the visited file name is used,\n\
except that if INITIAL is specified, that combined with DIR is used.)\n\
Fourth arg MUSTMATCH non-nil means require existing file's name.\n\
Non-nil and non-t means also require confirmation after completion.\n\
Fifth arg INITIAL specifies text to start with.\n\
DIR defaults to current buffer's directory default.")
- (prompt, dir, defalt, mustmatch, initial)
- Lisp_Object prompt, dir, defalt, mustmatch, initial;
+ (prompt, dir, default_filename, mustmatch, initial)
+ Lisp_Object prompt, dir, default_filename, mustmatch, initial;
{
- Lisp_Object val, insdef, insdef1, tem;
+ Lisp_Object val, insdef, tem;
struct gcpro gcpro1, gcpro2;
register char *homedir;
+ int replace_in_history = 0;
+ int add_to_history = 0;
int count;
if (NILP (dir))
dir = current_buffer->directory;
- if (NILP (defalt))
+ if (NILP (default_filename))
{
if (! NILP (initial))
- defalt = Fexpand_file_name (initial, dir);
+ default_filename = Fexpand_file_name (initial, dir);
else
- defalt = current_buffer->filename;
+ default_filename = current_buffer->filename;
}
/* If dir starts with user's homedir, change that to ~. */
homedir = (char *) egetenv ("HOME");
+#ifdef DOS_NT
+ homedir = strcpy (alloca (strlen (homedir) + 1), homedir);
+ CORRECT_DIR_SEPS (homedir);
+#endif
if (homedir != 0
&& STRINGP (dir)
&& !strncmp (homedir, XSTRING (dir)->data, strlen (homedir))
&& IS_DIRECTORY_SEP (XSTRING (dir)->data[strlen (homedir)]))
{
dir = make_string (XSTRING (dir)->data + strlen (homedir) - 1,
- XSTRING (dir)->size - strlen (homedir) + 1);
+ STRING_BYTES (XSTRING (dir)) - strlen (homedir) + 1);
XSTRING (dir)->data[0] = '~';
}
+ /* Likewise for default_filename. */
+ if (homedir != 0
+ && STRINGP (default_filename)
+ && !strncmp (homedir, XSTRING (default_filename)->data, strlen (homedir))
+ && IS_DIRECTORY_SEP (XSTRING (default_filename)->data[strlen (homedir)]))
+ {
+ default_filename
+ = make_string (XSTRING (default_filename)->data + strlen (homedir) - 1,
+ STRING_BYTES (XSTRING (default_filename)) - strlen (homedir) + 1);
+ XSTRING (default_filename)->data[0] = '~';
+ }
+ if (!NILP (default_filename))
+ {
+ CHECK_STRING (default_filename, 3);
+ default_filename = double_dollars (default_filename);
+ }
- if (insert_default_directory)
+ if (insert_default_directory && STRINGP (dir))
{
insdef = dir;
if (!NILP (initial))
args[1] = initial;
insdef = Fconcat (2, args);
pos = make_number (XSTRING (double_dollars (dir))->size);
- insdef1 = Fcons (double_dollars (insdef), pos);
+ insdef = Fcons (double_dollars (insdef), pos);
}
else
- insdef1 = double_dollars (insdef);
- }
- else if (!NILP (initial))
- {
- insdef = initial;
- insdef1 = Fcons (double_dollars (insdef), 0);
+ insdef = double_dollars (insdef);
}
+ else if (STRINGP (initial))
+ insdef = Fcons (double_dollars (initial), make_number (0));
else
- insdef = Qnil, insdef1 = Qnil;
+ insdef = Qnil;
-#ifdef VMS
count = specpdl_ptr - specpdl;
+#ifdef VMS
specbind (intern ("completion-ignore-case"), Qt);
#endif
- GCPRO2 (insdef, defalt);
- val = Fcompleting_read (prompt, intern ("read-file-name-internal"),
- dir, mustmatch, insdef1,
- Qfile_name_history);
+ specbind (intern ("minibuffer-completing-file-name"), Qt);
-#ifdef VMS
- unbind_to (count, Qnil);
+ GCPRO2 (insdef, default_filename);
+
+#ifdef USE_MOTIF
+ if ((NILP (last_nonmenu_event) || CONSP (last_nonmenu_event))
+ && use_dialog_box
+ && have_menus_p ())
+ {
+ val = Fx_file_dialog (prompt, dir, default_filename, mustmatch);
+ add_to_history = 1;
+ }
+ else
#endif
+ val = Fcompleting_read (prompt, intern ("read-file-name-internal"),
+ dir, mustmatch, insdef,
+ Qfile_name_history, default_filename, Qnil);
+
+ tem = Fsymbol_value (Qfile_name_history);
+ if (CONSP (tem) && EQ (XCAR (tem), val))
+ replace_in_history = 1;
+
+ /* If Fcompleting_read returned the inserted default string itself
+ (rather than a new string with the same contents),
+ it has to mean that the user typed RET with the minibuffer empty.
+ In that case, we really want to return ""
+ so that commands such as set-visited-file-name can distinguish. */
+ if (EQ (val, default_filename))
+ {
+ /* In this case, Fcompleting_read has not added an element
+ to the history. Maybe we should. */
+ if (! replace_in_history)
+ add_to_history = 1;
+
+ val = build_string ("");
+ }
+ unbind_to (count, Qnil);
UNGCPRO;
if (NILP (val))
error ("No file name specified");
- tem = Fstring_equal (val, insdef);
- if (!NILP (tem) && !NILP (defalt))
- return defalt;
- if (XSTRING (val)->size == 0 && NILP (insdef))
+
+ tem = Fstring_equal (val, CONSP (insdef) ? XCAR (insdef) : insdef);
+
+ if (!NILP (tem) && !NILP (default_filename))
+ val = default_filename;
+ else if (XSTRING (val)->size == 0 && NILP (insdef))
{
- if (!NILP (defalt))
- return defalt;
+ if (!NILP (default_filename))
+ val = default_filename;
else
error ("No default file name");
}
- return Fsubstitute_in_file_name (val);
-}
-
-#if 0 /* Old version */
-DEFUN ("read-file-name", Fread_file_name, Sread_file_name, 1, 5, 0,
- /* Don't confuse make-docfile by having two doc strings for this function.
- make-docfile does not pay attention to #if, for good reason! */
- 0)
- (prompt, dir, defalt, mustmatch, initial)
- Lisp_Object prompt, dir, defalt, mustmatch, initial;
-{
- Lisp_Object val, insdef, tem;
- struct gcpro gcpro1, gcpro2;
- register char *homedir;
- int count;
-
- if (NILP (dir))
- dir = current_buffer->directory;
- if (NILP (defalt))
- defalt = current_buffer->filename;
+ val = Fsubstitute_in_file_name (val);
- /* If dir starts with user's homedir, change that to ~. */
- homedir = (char *) egetenv ("HOME");
- if (homedir != 0
- && STRINGP (dir)
- && !strncmp (homedir, XSTRING (dir)->data, strlen (homedir))
- && XSTRING (dir)->data[strlen (homedir)] == '/')
+ if (replace_in_history)
+ /* Replace what Fcompleting_read added to the history
+ with what we will actually return. */
+ XCAR (Fsymbol_value (Qfile_name_history)) = double_dollars (val);
+ else if (add_to_history)
{
- dir = make_string (XSTRING (dir)->data + strlen (homedir) - 1,
- XSTRING (dir)->size - strlen (homedir) + 1);
- XSTRING (dir)->data[0] = '~';
+ /* Add the value to the history--but not if it matches
+ the last value already there. */
+ Lisp_Object val1 = double_dollars (val);
+ tem = Fsymbol_value (Qfile_name_history);
+ if (! CONSP (tem) || NILP (Fequal (XCAR (tem), val1)))
+ Fset (Qfile_name_history,
+ Fcons (val1, tem));
}
+
+ return val;
+}
- if (!NILP (initial))
- insdef = initial;
- else if (insert_default_directory)
- insdef = dir;
- else
- insdef = build_string ("");
-
-#ifdef VMS
- count = specpdl_ptr - specpdl;
- specbind (intern ("completion-ignore-case"), Qt);
-#endif
-
- GCPRO2 (insdef, defalt);
- val = Fcompleting_read (prompt, intern ("read-file-name-internal"),
- dir, mustmatch,
- insert_default_directory ? insdef : Qnil,
- Qfile_name_history);
-
-#ifdef VMS
- unbind_to (count, Qnil);
-#endif
-
- UNGCPRO;
- if (NILP (val))
- error ("No file name specified");
- tem = Fstring_equal (val, insdef);
- if (!NILP (tem) && !NILP (defalt))
- return defalt;
- return Fsubstitute_in_file_name (val);
+\f
+void
+init_fileio_once ()
+{
+ /* Must be set before any path manipulation is performed. */
+ XSETFASTINT (Vdirectory_sep_char, '/');
}
-#endif /* Old version */
+
\f
+void
syms_of_fileio ()
{
Qexpand_file_name = intern ("expand-file-name");
Qfile_exists_p = intern ("file-exists-p");
Qfile_executable_p = intern ("file-executable-p");
Qfile_readable_p = intern ("file-readable-p");
- Qfile_symlink_p = intern ("file-symlink-p");
Qfile_writable_p = intern ("file-writable-p");
+ Qfile_symlink_p = intern ("file-symlink-p");
+ Qaccess_file = intern ("access-file");
Qfile_directory_p = intern ("file-directory-p");
+ Qfile_regular_p = intern ("file-regular-p");
Qfile_accessible_directory_p = intern ("file-accessible-directory-p");
Qfile_modes = intern ("file-modes");
Qset_file_modes = intern ("set-file-modes");
staticpro (&Qfile_exists_p);
staticpro (&Qfile_executable_p);
staticpro (&Qfile_readable_p);
- staticpro (&Qfile_symlink_p);
staticpro (&Qfile_writable_p);
+ staticpro (&Qaccess_file);
+ staticpro (&Qfile_symlink_p);
staticpro (&Qfile_directory_p);
+ staticpro (&Qfile_regular_p);
staticpro (&Qfile_accessible_directory_p);
staticpro (&Qfile_modes);
staticpro (&Qset_file_modes);
staticpro (&Qinsert_file_contents);
staticpro (&Qwrite_region);
staticpro (&Qverify_visited_file_modtime);
+ staticpro (&Qset_visited_file_modtime);
Qfile_name_history = intern ("file-name-history");
Fset (Qfile_name_history, Qnil);
Qfile_error = intern ("file-error");
staticpro (&Qfile_error);
- Qfile_already_exists = intern("file-already-exists");
+ Qfile_already_exists = intern ("file-already-exists");
staticpro (&Qfile_already_exists);
+ Qfile_date_error = intern ("file-date-error");
+ staticpro (&Qfile_date_error);
+ Qexcl = intern ("excl");
+ staticpro (&Qexcl);
#ifdef DOS_NT
Qfind_buffer_file_type = intern ("find-buffer-file-type");
staticpro (&Qfind_buffer_file_type);
#endif /* DOS_NT */
+ DEFVAR_LISP ("file-name-coding-system", &Vfile_name_coding_system,
+ "*Coding system for encoding file names.\n\
+If it is nil, default-file-name-coding-system (which see) is used.");
+ Vfile_name_coding_system = Qnil;
+
+ DEFVAR_LISP ("default-file-name-coding-system",
+ &Vdefault_file_name_coding_system,
+ "Default coding system for encoding file names.\n\
+This variable is used only when file-name-coding-system is nil.\n\
+\n\
+This variable is set/changed by the command set-language-environment.\n\
+User should not set this variable manually,\n\
+instead use file-name-coding-system to get a constant encoding\n\
+of file names regardless of the current language environment.");
+ Vdefault_file_name_coding_system = Qnil;
+
+ DEFVAR_LISP ("auto-save-file-format", &Vauto_save_file_format,
+ "*Format in which to write auto-save files.\n\
+Should be a list of symbols naming formats that are defined in `format-alist'.\n\
+If it is t, which is the default, auto-save files are written in the\n\
+same format as a regular save would use.");
+ Vauto_save_file_format = Qt;
+
+ Qformat_decode = intern ("format-decode");
+ staticpro (&Qformat_decode);
+ Qformat_annotate_function = intern ("format-annotate-function");
+ staticpro (&Qformat_annotate_function);
+
Qcar_less_than_car = intern ("car-less-than-car");
staticpro (&Qcar_less_than_car);
Fput (Qfile_already_exists, Qerror_message,
build_string ("File already exists"));
+ Fput (Qfile_date_error, Qerror_conditions,
+ Fcons (Qfile_date_error,
+ Fcons (Qfile_error, Fcons (Qerror, Qnil))));
+ Fput (Qfile_date_error, Qerror_message,
+ build_string ("Cannot set file date"));
+
DEFVAR_BOOL ("insert-default-directory", &insert_default_directory,
"*Non-nil means when reading a filename start with default dir in minibuffer.");
insert_default_directory = 1;
nil means use format `var'. This variable is meaningful only on VMS.");
vms_stmlf_recfm = 0;
+ DEFVAR_LISP ("directory-sep-char", &Vdirectory_sep_char,
+ "Directory separator character for built-in functions that return file names.\n\
+The value should be either ?/ or ?\\ (any other value is treated as ?\\).\n\
+This variable affects the built-in functions only on Windows,\n\
+on other platforms, it is initialized so that Lisp code can find out\n\
+what the normal separator is.");
+
DEFVAR_LISP ("file-name-handler-alist", &Vfile_name_handler_alist,
"*Alist of elements (REGEXP . HANDLER) for file names handled specially.\n\
If a file name matches REGEXP, then all I/O on that file is done by calling\n\
for its argument.");
Vfile_name_handler_alist = Qnil;
+ DEFVAR_LISP ("set-auto-coding-function",
+ &Vset_auto_coding_function,
+ "If non-nil, a function to call to decide a coding system of file.\n\
+Two arguments are passed to this function: the file name\n\
+and the length of a file contents following the point.\n\
+This function should return a coding system to decode the file contents.\n\
+It should check the file name against `auto-coding-alist'.\n\
+If no coding system is decided, it should check a coding system\n\
+specified in the heading lines with the format:\n\
+ -*- ... coding: CODING-SYSTEM; ... -*-\n\
+or local variable spec of the tailing lines with `coding:' tag.");
+ Vset_auto_coding_function = Qnil;
+
DEFVAR_LISP ("after-insert-file-functions", &Vafter_insert_file_functions,
"A list of functions to be called at the end of `insert-file-contents'.\n\
Each is passed one argument, the number of bytes inserted. It should return\n\
DEFVAR_LISP ("write-region-annotate-functions", &Vwrite_region_annotate_functions,
"A list of functions to be called at the start of `write-region'.\n\
-Each is passed two arguments, START and END as for `write-region'. It should\n\
-return a list of pairs (POSITION . STRING) of strings to be effectively\n\
+Each is passed two arguments, START and END as for `write-region'.\n\
+These are usually two numbers but not always; see the documentation\n\
+for `write-region'. The function should return a list of pairs\n\
+of the form (POSITION . STRING), consisting of strings to be effectively\n\
inserted at the specified positions of the file being written (1 means to\n\
insert before the first byte written). The POSITIONs must be sorted into\n\
increasing order. If there are several functions in the list, the several\n\
Vinhibit_file_name_operation = Qnil;
DEFVAR_LISP ("auto-save-list-file-name", &Vauto_save_list_file_name,
- "File name in which we write a list of all auto save file names.");
+ "File name in which we write a list of all auto save file names.\n\
+This variable is initialized automatically from `auto-save-list-file-prefix'\n\
+shortly after Emacs reads your `.emacs' file, if you have not yet given it\n\
+a non-nil value.");
Vauto_save_list_file_name = Qnil;
defsubr (&Sfind_file_name_handler);
defsubr (&Sfile_executable_p);
defsubr (&Sfile_readable_p);
defsubr (&Sfile_writable_p);
+ defsubr (&Saccess_file);
defsubr (&Sfile_symlink_p);
defsubr (&Sfile_directory_p);
defsubr (&Sfile_accessible_directory_p);
HCoop / bpt / emacs.git / blobdiff