/* File IO for GNU Emacs.
- Copyright (C) 1985, 1986, 1987, 1988, 1993 Free Software Foundation, Inc.
+ Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994 Free Software Foundation, Inc.
This file is part of GNU Emacs.
along with GNU Emacs; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
-#include "config.h"
+#include <config.h>
#include <sys/types.h>
#include <sys/stat.h>
+#if !defined (S_ISLNK) && defined (S_IFLNK)
+# define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)
+#endif
+
+#if !defined (S_ISREG) && defined (S_IFREG)
+# define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
+#endif
+
#ifdef VMS
#include "vms-pwd.h"
#else
#include <pwd.h>
#endif
+#ifdef MSDOS
+#include "msdos.h"
+#include <sys/param.h>
+#endif
+
#include <ctype.h>
#ifdef VMS
-#include "dir.h"
+#include "vmsdir.h"
#include <perror.h>
#include <stddef.h>
#include <string.h>
#ifndef vax11c
extern int errno;
-extern char *sys_errlist[];
-extern int sys_nerr;
#endif
-#define err_str(a) ((a) < sys_nerr ? sys_errlist[a] : "unknown error")
+extern char *strerror ();
#ifdef APOLLO
#include <sys/time.h>
whose I/O is done with a special handler. */
Lisp_Object Vfile_name_handler_alist;
+/* Functions to be called to process text properties in inserted file. */
+Lisp_Object Vafter_insert_file_functions;
+
+/* Functions to be called to create text property annotations for file. */
+Lisp_Object Vwrite_region_annotate_functions;
+
/* Nonzero means, when reading a filename in the minibuffer,
start out by inserting the default directory into the minibuffer. */
int insert_default_directory;
Lisp_Object Qfile_name_history;
+Lisp_Object Qcar_less_than_car;
+
report_file_error (string, data)
char *string;
Lisp_Object data;
{
Lisp_Object errstring;
- if (errno >= 0 && errno < sys_nerr)
- errstring = build_string (sys_errlist[errno]);
- else
- errstring = build_string ("undocumented error code");
+ errstring = build_string (strerror (errno));
/* System error messages are capitalized. Downcase the initial
unless it is followed by a slash. */
{
close (XFASTINT (fd));
}
+
+/* Restore point, having saved it as a marker. */
+
+restore_point_unwind (location)
+ Lisp_Object location;
+{
+ SET_PT (marker_position (location));
+ Fset_marker (location, Qnil, Qnil);
+}
\f
Lisp_Object Qexpand_file_name;
Lisp_Object Qdirectory_file_name;
if (!NILP (handler))
return call2 (handler, Qfile_name_directory, file);
+#ifdef FILE_SYSTEM_CASE
+ file = FILE_SYSTEM_CASE (file);
+#endif
beg = XSTRING (file)->data;
p = beg + XSTRING (file)->size;
#ifdef VMS
&& p[-1] != ':' && p[-1] != ']' && p[-1] != '>'
#endif /* VMS */
+#ifdef MSDOS
+ && p[-1] != ':'
+#endif
) p--;
if (p == beg)
return Qnil;
+#ifdef MSDOS
+ /* Expansion of "c:" to drive and default directory. */
+ if (p == beg + 2 && beg[1] == ':')
+ {
+ int drive = (*beg) - 'a';
+ /* MAXPATHLEN+1 is guaranteed to be enough space for getdefdir. */
+ unsigned char *res = alloca (MAXPATHLEN + 5);
+ if (getdefdir (drive + 1, res + 2))
+ {
+ res[0] = drive + 'a';
+ res[1] = ':';
+ if (res[strlen (res) - 1] != '/')
+ strcat (res, "/");
+ beg = res;
+ p = beg + strlen (beg);
+ }
+ }
+#endif
return make_string (beg, p - beg);
}
#ifdef VMS
&& p[-1] != ':' && p[-1] != ']' && p[-1] != '>'
#endif /* VMS */
+#ifdef MSDOS
+ && p[-1] != ':'
+#endif
) p--;
return make_string (p, end - p);
}
#else /* not VMS */
/* For Unix syntax, Append a slash if necessary */
+#ifdef MSDOS
+ if (out[size] != ':' && out[size] != '/')
+#else
if (out[size] != '/')
+#endif
strcat (out, "/");
#endif /* not VMS */
return out;
/* Process as Unix format: just remove any final slash.
But leave "/" unchanged; do not change it to "". */
strcpy (dst, src);
- if (slen > 1 && dst[slen - 1] == '/')
+ if (slen > 1
+ && dst[slen - 1] == '/'
+#ifdef MSDOS
+ && dst[slen - 2] != ':'
+#endif
+ )
dst[slen - 1] = 0;
return 1;
}
int lbrack = 0, rbrack = 0;
int dots = 0;
#endif /* VMS */
+#ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida */
+ int drive = -1;
+ int relpath = 0;
+ unsigned char *tmp, *defdir;
+#endif
Lisp_Object handler;
CHECK_STRING (name, 0);
/* Filenames on VMS are always upper case. */
name = Fupcase (name);
#endif
+#ifdef FILE_SYSTEM_CASE
+ name = FILE_SYSTEM_CASE (name);
+#endif
nm = XSTRING (name)->data;
+#ifdef MSDOS
+ /* firstly, strip drive name. */
+ {
+ unsigned char *colon = rindex (nm, ':');
+ if (colon)
+ if (nm == colon)
+ nm++;
+ else
+ {
+ drive = tolower (colon[-1]) - 'a';
+ nm = colon + 1;
+ if (*nm != '/')
+ {
+ defdir = alloca (MAXPATHLEN + 1);
+ relpath = getdefdir (drive + 1, defdir);
+ }
+ }
+ }
+#endif
+
/* If nm is absolute, flush ...// and detect /./ and /../.
If no /./ or /../ we can return right away. */
if (
if (index (nm, '/'))
return build_string (sys_translate_unix (nm));
#endif /* VMS */
+#ifndef MSDOS
if (nm == XSTRING (name)->data)
return name;
return build_string (nm);
+#endif
}
}
{
if (!(newdir = (unsigned char *) egetenv ("HOME")))
newdir = (unsigned char *) "";
+#ifdef MSDOS
+ dostounix_filename (newdir);
+#endif
nm++;
#ifdef VMS
nm++; /* Don't leave the slash in nm. */
#ifdef VMS
&& !index (nm, ':')
#endif /* not VMS */
+#ifdef MSDOS
+ && drive == -1
+#endif
&& !newdir)
{
newdir = XSTRING (defalt)->data;
}
+#ifdef MSDOS
+ if (newdir == 0 && relpath)
+ newdir = defdir;
+#endif
if (newdir != 0)
{
/* Get rid of any slash at the end of 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)
+#endif
if (newdir[length - 1] == '/')
{
unsigned char *temp = (unsigned char *) alloca (length);
/* Now concatenate the directory and name to new space in the stack frame */
tlen += strlen (nm) + 1;
+#ifdef MSDOS
+ /* Add reserved space for drive name. */
+ target = (unsigned char *) alloca (tlen + 2) + 2;
+#else
target = (unsigned char *) alloca (tlen);
+#endif
*target = 0;
if (newdir)
#endif /* not VMS */
}
+#ifdef MSDOS
+ /* at last, set drive name. */
+ if (target[1] != ':')
+ {
+ target -= 2;
+ target[0] = (drive < 0 ? getdisk () : drive) + 'a';
+ target[1] = ':';
+ }
+#endif
+
return make_string (target, o - target);
}
#if 0
nm = p;
substituted = 1;
}
+#ifdef MSDOS
+ if (p[0] && p[1] == ':')
+ {
+ nm = p;
+ substituted = 1;
+ }
+#endif /* MSDOS */
}
#ifdef VMS
target = (unsigned char *) alloca (s - o + 1);
strncpy (target, o, s - o);
target[s - o] = 0;
+#ifdef MSDOS
+ strupr (target); /* $home == $HOME etc. */
+#endif
/* Get variable value */
o = (unsigned char *) egetenv (target);
-/* The presence of this code makes vax 5.0 crash, for reasons yet unknown */
-#if 0
-#ifdef USG
- if (!o && !strcmp (target, "USER"))
- o = egetenv ("LOGNAME");
-#endif /* USG */
-#endif /* 0 */
if (!o) goto badvar;
total += strlen (o);
substituted = 1;
target = (unsigned char *) alloca (s - o + 1);
strncpy (target, o, s - o);
target[s - o] = 0;
+#ifdef MSDOS
+ strupr (target); /* $home == $HOME etc. */
+#endif
/* Get variable value */
o = (unsigned char *) egetenv (target);
-/* The presence of this code makes vax 5.0 crash, for reasons yet unknown */
-#if 0
-#ifdef USG
- if (!o && !strcmp (target, "USER"))
- o = egetenv ("LOGNAME");
-#endif /* USG */
-#endif /* 0 */
if (!o)
goto badvar;
)
&& p != nm && p[-1] == '/')
xnm = p;
+#ifdef MSDOS
+ else if (p[0] && p[1] == ':')
+ xnm = p;
+#endif
return make_string (xnm, x - xnm);
}
\f
/* A slightly faster and more convenient way to get
- (directory-file-name (expand-file-name FOO)). The return value may
- have had its last character zapped with a '\0' character, meaning
- that it is acceptable to system calls, but not to other lisp
- functions. Callers should make sure that the return value doesn't
- escape. */
+ (directory-file-name (expand-file-name FOO)). */
Lisp_Object
expand_and_dir_to_file (filename, defdir)
stat behaves differently depending! */
if (XSTRING (abspath)->size > 1
&& XSTRING (abspath)->data[XSTRING (abspath)->size - 1] == '/')
- {
- if (EQ (abspath, filename))
- abspath = Fcopy_sequence (abspath);
- XSTRING (abspath)->data[XSTRING (abspath)->size - 1] = 0;
- }
+ /* We cannot take shortcuts; they might be wrong for magic file names. */
+ abspath = Fdirectory_file_name (abspath);
#endif
return abspath;
}
struct gcpro gcpro1, gcpro2;
int count = specpdl_ptr - specpdl;
Lisp_Object args[6];
+ int input_file_statable_p;
GCPRO2 (filename, newname);
CHECK_STRING (filename, 0);
if (NILP (handler))
handler = Ffind_file_name_handler (newname);
if (!NILP (handler))
- return call5 (handler, Qcopy_file, filename, newname,
- ok_if_already_exists, keep_date);
+ RETURN_UNGCPRO (call5 (handler, Qcopy_file, filename, newname,
+ ok_if_already_exists, keep_date));
if (NILP (ok_if_already_exists)
|| XTYPE (ok_if_already_exists) == Lisp_Int)
record_unwind_protect (close_file_unwind, make_number (ifd));
+ /* We can only copy regular files and symbolic links. Other files are not
+ copyable by us. */
+ input_file_statable_p = (fstat (ifd, &st) >= 0);
+
+#if defined (S_ISREG) && defined (S_ISLNK)
+ if (input_file_statable_p)
+ {
+ if (!(S_ISREG (st.st_mode)) && !(S_ISLNK (st.st_mode)))
+ {
+#if defined (EISDIR)
+ /* Get a better looking error message. */
+ errno = EISDIR;
+#endif /* EISDIR */
+ report_file_error ("Non-regular file", Fcons (filename, 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);
#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);
+#else /* not MSDOS */
ofd = creat (XSTRING (newname)->data, 0666);
+#endif /* not MSDOS */
#endif /* VMS */
if (ofd < 0)
report_file_error ("Opening output file", Fcons (newname, Qnil));
report_file_error ("I/O error", Fcons (newname, Qnil));
immediate_quit = 0;
- if (fstat (ifd, &st) >= 0)
+ if (input_file_statable_p)
{
if (!NILP (keep_date))
{
if (NILP (handler))
handler = Ffind_file_name_handler (newname);
if (!NILP (handler))
- return call4 (handler, Qrename_file,
- filename, newname, ok_if_already_exists);
+ RETURN_UNGCPRO (call4 (handler, Qrename_file,
+ filename, newname, ok_if_already_exists));
if (NILP (ok_if_already_exists)
|| XTYPE (ok_if_already_exists) == Lisp_Int)
{
if (errno == EXDEV)
{
- Fcopy_file (filename, newname, ok_if_already_exists, Qt);
+ Fcopy_file (filename, 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);
}
else
call the corresponding file handler. */
handler = Ffind_file_name_handler (filename);
if (!NILP (handler))
- return call4 (handler, Qadd_name_to_file, filename, newname,
- ok_if_already_exists);
+ RETURN_UNGCPRO (call4 (handler, Qadd_name_to_file, filename,
+ newname, ok_if_already_exists));
if (NILP (ok_if_already_exists)
|| XTYPE (ok_if_already_exists) == Lisp_Int)
GCPRO2 (filename, linkname);
CHECK_STRING (filename, 0);
CHECK_STRING (linkname, 1);
-#if 0 /* This made it impossible to make a link to a relative name. */
- filename = Fexpand_file_name (filename, Qnil);
-#endif
+ /* If the link target has a ~, we must expand it to get
+ a truly valid file name. Otherwise, do not expand;
+ we want to permit links to relative file names. */
+ if (XSTRING (filename)->data[0] == '~')
+ filename = Fexpand_file_name (filename, Qnil);
linkname = Fexpand_file_name (linkname, Qnil);
/* If the file name has special constructs in it,
call the corresponding file handler. */
handler = Ffind_file_name_handler (filename);
if (!NILP (handler))
- return call4 (handler, Qmake_symbolic_link, filename, linkname,
- ok_if_already_exists);
+ RETURN_UNGCPRO (call4 (handler, Qmake_symbolic_link, filename,
+ linkname, ok_if_already_exists));
if (NILP (ok_if_already_exists)
|| XTYPE (ok_if_already_exists) == Lisp_Int)
|| (*ptr == '[' && (ptr[1] != '-' || (ptr[2] != '.' && ptr[2] != ']'))
&& ptr[1] != '.')
#endif /* VMS */
+#ifdef MSDOS
+ || (*ptr != 0 && ptr[1] == ':' && ptr[2] == '/')
+#endif
)
return Qt;
else
}
DEFUN ("file-symlink-p", Ffile_symlink_p, Sfile_symlink_p, 1, 1, 0,
- "If file FILENAME is the name of a symbolic link\n\
-returns the name of the file to which it is linked.\n\
-Otherwise returns NIL.")
+ "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\
+Otherwise returns nil.")
(filename)
Lisp_Object filename;
{
if (!NILP (dir))
dir = Fdirectory_file_name (dir);
#endif /* VMS */
+#ifdef MSDOS
+ if (!NILP (dir))
+ dir = Fdirectory_file_name (dir);
+#endif /* MSDOS */
return ((access (!NILP (dir) ? (char *) XSTRING (dir)->data : "", 2) >= 0
&& ! ro_fsys ((char *) XSTRING (dir)->data))
? Qt : Qnil);
if (stat (XSTRING (abspath)->data, &st) < 0)
return Qnil;
+#ifdef MSDOS
+ {
+ 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 /* MSDOS */
+
return make_number (st.st_mode & 07777);
}
return (mtime1 > st.st_mtime) ? Qt : Qnil;
}
\f
+#ifdef MSDOS
+Lisp_Object Qfind_buffer_file_type;
+#endif
+
DEFUN ("insert-file-contents", Finsert_file_contents, Sinsert_file_contents,
- 1, 4, 0,
+ 1, 5, 0,
"Insert contents of file FILENAME after point.\n\
Returns list of absolute file name and length of data inserted.\n\
If second argument VISIT is non-nil, the buffer's visited filename\n\
before the error is signaled.\n\n\
The optional third and fourth arguments BEG and END\n\
specify what portion of the file to insert.\n\
-If VISIT is non-nil, BEG and END must be nil.")
- (filename, visit, beg, end)
- Lisp_Object filename, visit, beg, end;
+If VISIT is non-nil, BEG and END must be nil.\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.")
+ (filename, visit, beg, end, replace)
+ Lisp_Object filename, visit, beg, end, replace;
{
struct stat st;
register int fd;
register int inserted = 0;
register int how_much;
int count = specpdl_ptr - specpdl;
- struct gcpro gcpro1;
- Lisp_Object handler, val;
+ struct gcpro gcpro1, gcpro2;
+ Lisp_Object handler, val, insval;
+ Lisp_Object p;
int total;
val = Qnil;
+ p = Qnil;
- GCPRO1 (filename);
+ GCPRO2 (filename, p);
if (!NILP (current_buffer->read_only))
Fbarf_if_buffer_read_only();
handler = Ffind_file_name_handler (filename);
if (!NILP (handler))
{
- val = call5 (handler, Qinsert_file_contents, filename, visit, beg, end);
- st.st_mtime = 0;
+ val = call6 (handler, Qinsert_file_contents, filename,
+ visit, beg, end, replace);
goto handled;
}
goto notfound;
}
+ /* Replacement should preserve point as it preserves markers. */
+ if (!NILP (replace))
+ record_unwind_protect (restore_point_unwind, Fpoint_marker ());
+
record_unwind_protect (close_file_unwind, make_number (fd));
#ifdef S_IFSOCK
error ("maximum buffer size exceeded");
}
+ /* 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. */
+ if (!NILP (replace))
+ {
+ char buffer[1 << 14];
+ int same_at_start = BEGV;
+ int same_at_end = ZV;
+ int overlap;
+
+ immediate_quit = 1;
+ QUIT;
+ /* Count how many chars at the start of the file
+ match the text at the beginning of the buffer. */
+ while (1)
+ {
+ int nread, bufpos;
+
+ nread = read (fd, buffer, sizeof buffer);
+ if (nread < 0)
+ error ("IO error reading %s: %s",
+ XSTRING (filename)->data, strerror (errno));
+ else if (nread == 0)
+ break;
+ bufpos = 0;
+ while (bufpos < nread && same_at_start < ZV
+ && FETCH_CHAR (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. */
+ 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 == ZV)
+ {
+ close (fd);
+ specpdl_ptr--;
+ 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)
+ {
+ int total_read, nread, bufpos, curpos, trial;
+
+ /* At what file position are we now scanning? */
+ curpos = st.st_size - (ZV - same_at_end);
+ /* How much can we scan in the next step? */
+ trial = min (curpos, sizeof buffer);
+ if (lseek (fd, curpos - trial, 0) < 0)
+ report_file_error ("Setting file position",
+ Fcons (filename, Qnil));
+
+ total_read = 0;
+ while (total_read < trial)
+ {
+ nread = read (fd, buffer + total_read, trial - total_read);
+ if (nread <= 0)
+ error ("IO error reading %s: %s",
+ XSTRING (filename)->data, strerror (errno));
+ total_read += nread;
+ }
+ /* Scan this bufferfull 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])
+ same_at_end--, bufpos--;
+ /* If we found a discrepancy, stop the scan.
+ Otherwise loop around and scan the preceding bufferfull. */
+ if (bufpos != 0)
+ break;
+ }
+ immediate_quit = 0;
+
+ /* Don't try to reuse the same piece of text twice. */
+ overlap = same_at_start - BEGV - (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. */
+ XFASTINT (beg) = same_at_start - BEGV;
+ XFASTINT (end) = st.st_size - (ZV - same_at_end);
+
+ del_range_1 (same_at_start, same_at_end, 0);
+ /* Insert from the file at the proper position. */
+ SET_PT (same_at_start);
+ }
+
total = XINT (end) - XINT (beg);
{
error ("maximum buffer size exceeded");
}
- if (NILP (visit))
+ if (NILP (visit) && total > 0)
prepare_to_modify_buffer (point, point);
move_gap (point);
if (GAP_SIZE < total)
make_gap (total - GAP_SIZE);
- if (XINT (beg) != 0)
+ if (XINT (beg) != 0 || !NILP (replace))
{
if (lseek (fd, XINT (beg), 0) < 0)
report_file_error ("Setting file position", Fcons (filename, Qnil));
}
- while (1)
+ how_much = 0;
+ while (inserted < total)
{
int try = min (total - inserted, 64 << 10);
int this;
inserted += this;
}
+#ifdef MSDOS
+ /* 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. */
+ {
+ struct gcpro gcpro1;
+ Lisp_Object code;
+ code = Qnil;
+ GCPRO1 (filename);
+ code = call1 (Qfind_buffer_file_type, filename);
+ UNGCPRO;
+ if (XTYPE (code) == Lisp_Int)
+ XFASTINT (current_buffer->buffer_file_type) = XFASTINT (code);
+ if (XFASTINT (current_buffer->buffer_file_type) == 0)
+ {
+ 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;
+ }
+ }
+#endif
+
if (inserted > 0)
{
record_insert (point, inserted);
close (fd);
- /* Discard the unwind protect */
- specpdl_ptr = specpdl + count;
+ /* Discard the unwind protect for closing the file. */
+ specpdl_ptr--;
if (how_much < 0)
error ("IO error reading %s: %s",
- XSTRING (filename)->data, err_str (errno));
+ XSTRING (filename)->data, strerror (errno));
notfound:
handled:
if (!NILP (visit))
{
- current_buffer->undo_list = Qnil;
+ if (!EQ (current_buffer->undo_list, Qt))
+ current_buffer->undo_list = Qnil;
#ifdef APOLLO
stat (XSTRING (filename)->data, &st);
#endif
- current_buffer->modtime = st.st_mtime;
+
+ if (NILP (handler))
+ {
+ current_buffer->modtime = st.st_mtime;
+ current_buffer->filename = filename;
+ }
+
current_buffer->save_modified = MODIFF;
current_buffer->auto_save_modified = MODIFF;
XFASTINT (current_buffer->save_length) = Z - BEG;
unlock_file (filename);
}
#endif /* CLASH_DETECTION */
- current_buffer->filename = filename;
/* If visiting nonexistent file, return nil. */
if (current_buffer->modtime == -1)
report_file_error ("Opening input file", Fcons (filename, Qnil));
}
- signal_after_change (point, 0, inserted);
+ if (inserted > 0 && NILP (visit) && total > 0)
+ signal_after_change (point, 0, inserted);
- if (!NILP (val))
- RETURN_UNGCPRO (val);
- RETURN_UNGCPRO (Fcons (filename,
- Fcons (make_number (inserted),
- Qnil)));
+ if (inserted > 0)
+ {
+ p = Vafter_insert_file_functions;
+ while (!NILP (p))
+ {
+ insval = call1 (Fcar (p), make_number (inserted));
+ if (!NILP (insval))
+ {
+ CHECK_NUMBER (insval, 0);
+ inserted = XFASTINT (insval);
+ }
+ QUIT;
+ p = Fcdr (p);
+ }
+ }
+
+ if (NILP (val))
+ val = Fcons (filename,
+ Fcons (make_number (inserted),
+ Qnil));
+
+ RETURN_UNGCPRO (unbind_to (count, val));
}
\f
+static Lisp_Object build_annotations ();
+
DEFUN ("write-region", Fwrite_region, Swrite_region, 3, 5,
"r\nFWrite region to file: ",
"Write current region into specified file.\n\
#endif /* VMS */
Lisp_Object handler;
Lisp_Object visit_file;
+ Lisp_Object annotations;
+ int visiting, quietly;
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
+#ifdef MSDOS
+ int buffer_file_type
+ = NILP (current_buffer->buffer_file_type) ? O_TEXT : O_BINARY;
+#endif
- /* Special kludge to simplify auto-saving */
- if (NILP (start))
- {
- XFASTINT (start) = BEG;
- XFASTINT (end) = Z;
- }
- else if (XTYPE (start) != Lisp_String)
+ if (!NILP (start) && !STRINGP (start))
validate_region (&start, &end);
filename = Fexpand_file_name (filename, Qnil);
- if (XTYPE (visit) == Lisp_String)
+ if (STRINGP (visit))
visit_file = Fexpand_file_name (visit, Qnil);
else
visit_file = filename;
- GCPRO4 (start, filename, visit, visit_file);
+ visiting = (EQ (visit, Qt) || STRINGP (visit));
+ quietly = !NILP (visit);
+
+ annotations = Qnil;
+
+ GCPRO4 (start, filename, annotations, visit_file);
/* If the file name has special constructs in it,
call the corresponding file handler. */
handler = Ffind_file_name_handler (filename);
+ /* If FILENAME has no handler, see if VISIT has one. */
+ if (NILP (handler) && XTYPE (visit) == Lisp_String)
+ handler = Ffind_file_name_handler (visit);
if (!NILP (handler))
{
val = call6 (handler, Qwrite_region, start, end,
filename, append, visit);
- /* Do this before reporting IO error
- to avoid a "file has changed on disk" warning on
- next attempt to save. */
- if (EQ (visit, Qt) || XTYPE (visit) == Lisp_String)
+ if (visiting)
{
- current_buffer->modtime = 0;
current_buffer->save_modified = MODIFF;
XFASTINT (current_buffer->save_length) = Z - BEG;
current_buffer->filename = visit_file;
return val;
}
+ /* Special kludge to simplify auto-saving. */
+ if (NILP (start))
+ {
+ XFASTINT (start) = BEG;
+ XFASTINT (end) = Z;
+ }
+
+ annotations = build_annotations (start, end);
+
#ifdef CLASH_DETECTION
if (!auto_saving)
lock_file (visit_file);
fn = XSTRING (filename)->data;
desc = -1;
if (!NILP (append))
+#ifdef MSDOS
+ desc = open (fn, O_WRONLY | buffer_file_type);
+#else
desc = open (fn, O_WRONLY);
+#endif
if (desc < 0)
#ifdef VMS
vms_truncate (fn); /* if fn exists, truncate to zero length */
desc = open (fn, O_RDWR);
if (desc < 0)
- desc = creat_copy_attrs (XTYPE (current_buffer->filename) == Lisp_String
+ desc = creat_copy_attrs (STRINGP (current_buffer->filename)
? XSTRING (current_buffer->filename)->data : 0,
fn);
}
desc = creat (fn, 0666);
}
#else /* not VMS */
+#ifdef MSDOS
+ desc = open (fn,
+ O_WRONLY | O_TRUNC | O_CREAT | buffer_file_type,
+ S_IREAD | S_IWRITE);
+#else /* not MSDOS */
desc = creat (fn, auto_saving ? auto_save_mode_bits : 0666);
+#endif /* not MSDOS */
#endif /* not VMS */
UNGCPRO;
failure = 0;
immediate_quit = 1;
- if (XTYPE (start) == Lisp_String)
+ if (STRINGP (start))
{
- failure = 0 > e_write (desc, XSTRING (start)->data,
- XSTRING (start)->size);
+ failure = 0 > a_write (desc, XSTRING (start)->data,
+ XSTRING (start)->size, 0, &annotations);
save_errno = errno;
}
else if (XINT (start) != XINT (end))
{
+ int nwritten = 0;
if (XINT (start) < GPT)
{
register int end1 = XINT (end);
tem = XINT (start);
- failure = 0 > e_write (desc, &FETCH_CHAR (tem),
- min (GPT, end1) - tem);
+ failure = 0 > a_write (desc, &FETCH_CHAR (tem),
+ min (GPT, end1) - tem, tem, &annotations);
+ nwritten += min (GPT, end1) - tem;
save_errno = errno;
}
{
tem = XINT (start);
tem = max (tem, GPT);
- failure = 0 > e_write (desc, &FETCH_CHAR (tem), XINT (end) - tem);
+ failure = 0 > a_write (desc, &FETCH_CHAR (tem), XINT (end) - tem,
+ tem, &annotations);
+ nwritten += XINT (end) - tem;
+ 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;
}
}
/* Do this before reporting IO error
to avoid a "file has changed on disk" warning on
next attempt to save. */
- if (EQ (visit, Qt) || XTYPE (visit) == Lisp_String)
+ if (visiting)
current_buffer->modtime = st.st_mtime;
if (failure)
- error ("IO error writing %s: %s", fn, err_str (save_errno));
+ error ("IO error writing %s: %s", fn, strerror (save_errno));
- if (EQ (visit, Qt) || XTYPE (visit) == Lisp_String)
+ if (visiting)
{
current_buffer->save_modified = MODIFF;
XFASTINT (current_buffer->save_length) = Z - BEG;
current_buffer->filename = visit_file;
}
- else if (!NILP (visit))
+ else if (quietly)
return Qnil;
if (!auto_saving)
return Qnil;
}
+Lisp_Object merge ();
+
+DEFUN ("car-less-than-car", Fcar_less_than_car, Scar_less_than_car, 2, 2, 0,
+ "Return t if (car A) is numerically less than (car B).")
+ (a, b)
+ Lisp_Object a, b;
+{
+ return Flss (Fcar (a), Fcar (b));
+}
+
+/* Build the complete list of annotations appropriate for writing out
+ the text between START and END, by calling all the functions in
+ write-region-annotate-functions and merging the lists they return. */
+
+static Lisp_Object
+build_annotations (start, end)
+ Lisp_Object start, end;
+{
+ Lisp_Object annotations;
+ Lisp_Object p, res;
+ struct gcpro gcpro1, gcpro2;
+
+ annotations = Qnil;
+ p = Vwrite_region_annotate_functions;
+ GCPRO2 (annotations, p);
+ while (!NILP (p))
+ {
+ res = call2 (Fcar (p), start, end);
+ Flength (res); /* Check basic validity of return value */
+ annotations = merge (annotations, res, Qcar_less_than_car);
+ p = Fcdr (p);
+ }
+ UNGCPRO;
+ return annotations;
+}
+
+/* Write to descriptor DESC the LEN characters starting at ADDR,
+ assuming they start at position POS in the buffer.
+ Intersperse with them the annotations from *ANNOT
+ (those which fall within the range of positions POS to POS + LEN),
+ each at its appropriate position.
+
+ Modify *ANNOT by discarding elements as we output them.
+ The return value is negative in case of system call failure. */
+
+int
+a_write (desc, addr, len, pos, annot)
+ int desc;
+ register char *addr;
+ register int len;
+ int pos;
+ Lisp_Object *annot;
+{
+ Lisp_Object tem;
+ int nextpos;
+ int lastpos = pos + len;
+
+ while (1)
+ {
+ tem = Fcar_safe (Fcar (*annot));
+ if (INTEGERP (tem) && XINT (tem) >= pos && XFASTINT (tem) <= lastpos)
+ nextpos = XFASTINT (tem);
+ else
+ return e_write (desc, addr, lastpos - pos);
+ if (nextpos > pos)
+ {
+ if (0 > e_write (desc, addr, nextpos - pos))
+ return -1;
+ addr += nextpos - pos;
+ pos = nextpos;
+ }
+ tem = Fcdr (Fcar (*annot));
+ if (STRINGP (tem))
+ {
+ if (0 > e_write (desc, XSTRING (tem)->data, XSTRING (tem)->size))
+ return -1;
+ }
+ *annot = Fcdr (*annot);
+ }
+}
+
int
e_write (desc, addr, len)
int desc;
and are changed since last auto-saved.\n\
Auto-saving writes the buffer into a file\n\
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\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.")
(no_message, current_only)
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;
+
+ /* 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;
+ Vquit_flag = Qnil;
/* No GCPRO needed, because (when it matters) all Lisp_Object variables
point to non-strings reached from Vbuffer_alist. */
if (minibuf_level)
no_message = Qt;
- /* Vrun_hooks is nil before emacs is dumped, and inc-vers.el will
- eventually call do-auto-save, so don't err here in that case. */
if (!NILP (Vrun_hooks))
call1 (Vrun_hooks, intern ("auto-save-hook"));
&& (do_handled_files
|| NILP (Ffind_file_name_handler (b->auto_save_file_name))))
{
+ EMACS_TIME before_time, after_time;
+
+ EMACS_GET_TIME (before_time);
+
+ /* If we had a failure, don't try again for 20 minutes. */
+ if (b->auto_save_failure_time >= 0
+ && EMACS_SECS (before_time) - b->auto_save_failure_time < 1200)
+ continue;
+
if ((XFASTINT (b->save_length) * 10
> (BUF_Z (b) - BUF_BEG (b)) * 13)
/* A short file is likely to change a large fraction;
b->auto_save_modified = BUF_MODIFF (b);
XFASTINT (current_buffer->save_length) = Z - BEG;
set_buffer_internal (old);
+
+ EMACS_GET_TIME (after_time);
+
+ /* If auto-save took more than 60 seconds,
+ assume it was an NFS failure that got a timeout. */
+ if (EMACS_SECS (after_time) - EMACS_SECS (before_time) > 60)
+ b->auto_save_failure_time = EMACS_SECS (after_time);
}
}
record_auto_save ();
if (auto_saved && NILP (no_message))
- message1 (omessage ? omessage : "Auto-saving...done");
+ {
+ if (omessage)
+ message2 (omessage, omessage_length);
+ else
+ message1 ("Auto-saving...done");
+ }
+
+ Vquit_flag = oquit;
auto_saving = 0;
return Qnil;
{
current_buffer->auto_save_modified = MODIFF;
XFASTINT (current_buffer->save_length) = Z - BEG;
+ current_buffer->auto_save_failure_time = -1;
+ return Qnil;
+}
+
+DEFUN ("clear-buffer-auto-save-failure", Fclear_buffer_auto_save_failure,
+ Sclear_buffer_auto_save_failure, 0, 0, 0,
+ "Clear any record of a recent auto-save failure in the current buffer.")
+ ()
+{
+ current_buffer->auto_save_failure_time = -1;
return Qnil;
}
/* Reading and completing file names */
extern Lisp_Object Ffile_name_completion (), Ffile_name_all_completions ();
+/* In the string VAL, change each $ to $$ and return the result. */
+
+static Lisp_Object
+double_dollars (val)
+ Lisp_Object val;
+{
+ register unsigned char *old, *new;
+ register int n;
+ int osize, count;
+
+ osize = XSTRING (val)->size;
+ /* Quote "$" as "$$" to get it past substitute-in-file-name */
+ 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));
+ new = XSTRING (val)->data;
+ for (n = osize; n > 0; n--)
+ if (*old != '$')
+ *new++ = *old++;
+ else
+ {
+ *new++ = '$';
+ *new++ = '$';
+ old++;
+ }
+ }
+ return val;
+}
+
DEFUN ("read-file-name-internal", Fread_file_name_internal, Sread_file_name_internal,
3, 3, 0,
"Internal subroutine for read-file-name. Do not call this.")
if (!NILP (specdir))
val = concat2 (specdir, val);
#ifndef VMS
- {
- register unsigned char *old, *new;
- register int n;
- int osize, count;
-
- osize = XSTRING (val)->size;
- /* Quote "$" as "$$" to get it past substitute-in-file-name */
- 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));
- new = XSTRING (val)->data;
- for (n = osize; n > 0; n--)
- if (*old != '$')
- *new++ = *old++;
- else
- {
- *new++ = '$';
- *new++ = '$';
- old++;
- }
- }
- }
-#endif /* Not VMS */
+ return double_dollars (val);
+#else /* not VMS */
return val;
+#endif /* not VMS */
}
UNGCPRO;
if (insert_default_directory)
{
insdef = dir;
- insdef1 = dir;
if (!NILP (initial))
{
Lisp_Object args[2], pos;
args[0] = insdef;
args[1] = initial;
insdef = Fconcat (2, args);
- pos = make_number (XSTRING (dir)->size);
- insdef1 = Fcons (insdef, pos);
+ pos = make_number (XSTRING (double_dollars (dir))->size);
+ insdef1 = Fcons (double_dollars (insdef), pos);
}
+ else
+ insdef1 = double_dollars (insdef);
+ }
+ else if (!NILP (initial))
+ {
+ insdef = initial;
+ insdef1 = Fcons (double_dollars (insdef), 0);
}
else
insdef = Qnil, insdef1 = Qnil;
if (!NILP (tem) && !NILP (defalt))
return defalt;
if (XSTRING (val)->size == 0 && NILP (insdef))
- return defalt;
+ {
+ if (!NILP (defalt))
+ return defalt;
+ 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,
- "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\
-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.")
+ /* 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;
{
Qfile_already_exists = intern("file-already-exists");
staticpro (&Qfile_already_exists);
+#ifdef MSDOS
+ Qfind_buffer_file_type = intern ("find-buffer-file-type");
+ staticpro (&Qfind_buffer_file_type);
+#endif
+
+ Qcar_less_than_car = intern ("car-less-than-car");
+ staticpro (&Qcar_less_than_car);
+
Fput (Qfile_error, Qerror_conditions,
Fcons (Qfile_error, Fcons (Qerror, Qnil)));
Fput (Qfile_error, Qerror_message,
for its argument.");
Vfile_name_handler_alist = 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\
+the new byte count, and leave point the same. If `insert-file-contents' is\n\
+intercepted by a handler from `file-name-handler-alist', that handler is\n\
+responsible for calling the after-insert-file-functions if appropriate.");
+ Vafter_insert_file_functions = Qnil;
+
+ 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\
+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\
+lists are merged destructively.");
+ Vwrite_region_annotate_functions = Qnil;
+
defsubr (&Sfind_file_name_handler);
defsubr (&Sfile_name_directory);
defsubr (&Sfile_name_nondirectory);
defsubr (&Sfile_newer_than_file_p);
defsubr (&Sinsert_file_contents);
defsubr (&Swrite_region);
+ defsubr (&Scar_less_than_car);
defsubr (&Sverify_visited_file_modtime);
defsubr (&Sclear_visited_file_modtime);
defsubr (&Svisited_file_modtime);
defsubr (&Sset_visited_file_modtime);
defsubr (&Sdo_auto_save);
defsubr (&Sset_buffer_auto_saved);
+ defsubr (&Sclear_buffer_auto_save_failure);
defsubr (&Srecent_auto_save_p);
defsubr (&Sread_file_name_internal);
HCoop / bpt / emacs.git / blobdiff