/* File IO for GNU Emacs.
-Copyright (C) 1985-1988, 1993-2013 Free Software Foundation, Inc.
+Copyright (C) 1985-1988, 1993-2014 Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include "coding.h"
#include "window.h"
#include "blockinput.h"
+#include "region-cache.h"
#include "frame.h"
#include "dispextern.h"
/* True during writing of auto-save files. */
static bool auto_saving;
+/* Emacs's real umask. */
+static mode_t realmask;
+
/* Nonzero umask during creation of auto-save directories. */
static mode_t auto_saving_dir_umask;
/* Lisp function for recursively deleting directories. */
static Lisp_Object Qdelete_directory;
-#ifdef WINDOWSNT
-#endif
+static Lisp_Object Qsubstitute_env_in_file_name;
Lisp_Object Qfile_error, Qfile_notify_error;
static Lisp_Object Qfile_already_exists, Qfile_date_error;
struct coding_system *);
\f
+/* Return true if FILENAME exists. */
+
+static bool
+check_existing (const char *filename)
+{
+ return faccessat (AT_FDCWD, filename, F_OK, AT_EACCESS) == 0;
+}
+
+/* Return true if file FILENAME exists and can be executed. */
+
+static bool
+check_executable (char *filename)
+{
+ return faccessat (AT_FDCWD, filename, X_OK, AT_EACCESS) == 0;
+}
+
+/* Return true if file FILENAME exists and can be accessed
+ according to AMODE, which should include W_OK.
+ On failure, return false and set errno. */
+
+static bool
+check_writable (const char *filename, int amode)
+{
+#ifdef MSDOS
+ /* FIXME: an faccessat implementation should be added to the
+ DOS/Windows ports and this #ifdef branch should be removed. */
+ struct stat st;
+ if (stat (filename, &st) < 0)
+ return 0;
+ errno = EPERM;
+ return (st.st_mode & S_IWRITE || S_ISDIR (st.st_mode));
+#else /* not MSDOS */
+ bool res = faccessat (AT_FDCWD, filename, amode, AT_EACCESS) == 0;
+#ifdef CYGWIN
+ /* faccessat may have returned failure because Cygwin couldn't
+ determine the file's UID or GID; if so, we return success. */
+ if (!res)
+ {
+ int faccessat_errno = errno;
+ struct stat st;
+ if (stat (filename, &st) < 0)
+ return 0;
+ res = (st.st_uid == -1 || st.st_gid == -1);
+ errno = faccessat_errno;
+ }
+#endif /* CYGWIN */
+ return res;
+#endif /* not MSDOS */
+}
+\f
/* Signal a file-access failure. STRING describes the failure,
NAME the file involved, and ERRORNO the errno value.
emacs_close (fd);
}
+void
+close_file_ptr_unwind (void *fdp)
+{
+ int fd = *((int *) fdp);
+ if (fd >= 0)
+ emacs_close (fd);
+}
+
void
fclose_unwind (void *arg)
{
fclose (stream);
}
+void
+fclose_ptr_unwind (void *arg)
+{
+ FILE *stream = *((void **) arg);
+ if (stream)
+ fclose (stream);
+}
+
/* Restore point, having saved it as a marker. */
void
restore_point_unwind (Lisp_Object location)
{
Fgoto_char (location);
- Fset_marker (location, Qnil, Qnil);
+ unchain_marker (XMARKER (location));
}
\f
}
#ifdef DOS_NT
- beg = alloca (SBYTES (filename) + 1);
- memcpy (beg, SSDATA (filename), SBYTES (filename) + 1);
+ beg = xlispstrdupa (filename);
#else
beg = SSDATA (filename);
#endif
strcat (res, "/");
beg = res;
p = beg + strlen (beg);
- dostounix_filename (beg, 0);
+ dostounix_filename (beg);
tem_fn = make_specified_string (beg, -1, p - beg,
STRING_MULTIBYTE (filename));
}
else if (STRING_MULTIBYTE (filename))
{
tem_fn = make_specified_string (beg, -1, p - beg, 1);
- dostounix_filename (SSDATA (tem_fn), 1);
+ dostounix_filename (SSDATA (tem_fn));
#ifdef WINDOWSNT
if (!NILP (Vw32_downcase_file_names))
tem_fn = Fdowncase (tem_fn);
}
else
{
- dostounix_filename (beg, 0);
+ dostounix_filename (beg);
tem_fn = make_specified_string (beg, -1, p - beg, 0);
}
return tem_fn;
return Ffile_name_directory (filename);
}
+/* Maximum number of bytes that DST will be longer than SRC
+ in file_name_as_directory. This occurs when SRCLEN == 0. */
+enum { file_name_as_directory_slop = 2 };
+
/* Convert from file name SRC of length SRCLEN to directory name in
DST. MULTIBYTE non-zero means the file name in SRC is a multibyte
string. On UNIX, just make sure there is a terminating /. Return
return 2;
}
- strcpy (dst, src);
-
+ memcpy (dst, src, srclen);
if (!IS_DIRECTORY_SEP (dst[srclen - 1]))
- {
- dst[srclen] = DIRECTORY_SEP;
- dst[srclen + 1] = '\0';
- srclen++;
- }
+ dst[srclen++] = DIRECTORY_SEP;
+ dst[srclen] = 0;
#ifdef DOS_NT
- dostounix_filename (dst, multibyte);
+ dostounix_filename (dst);
#endif
return srclen;
}
{
char *buf;
ptrdiff_t length;
- Lisp_Object handler;
+ Lisp_Object handler, val;
+ USE_SAFE_ALLOCA;
CHECK_STRING (file);
if (NILP (file))
if (!NILP (Vw32_downcase_file_names))
file = Fdowncase (file);
#endif
- buf = alloca (SBYTES (file) + 10);
+ buf = SAFE_ALLOCA (SBYTES (file) + file_name_as_directory_slop + 1);
length = file_name_as_directory (buf, SSDATA (file), SBYTES (file),
STRING_MULTIBYTE (file));
- return make_specified_string (buf, -1, length, STRING_MULTIBYTE (file));
+ val = make_specified_string (buf, -1, length, STRING_MULTIBYTE (file));
+ SAFE_FREE ();
+ return val;
}
\f
/* Convert from directory name SRC of length SRCLEN to file name in
directory_file_name (char *dst, char *src, ptrdiff_t srclen, bool multibyte)
{
/* Process as Unix format: just remove any final slash.
- But leave "/" unchanged; do not change it to "". */
- strcpy (dst, src);
- if (srclen > 1
- && IS_DIRECTORY_SEP (dst[srclen - 1])
+ But leave "/" and "//" unchanged. */
+ while (srclen > 1
#ifdef DOS_NT
- && !IS_ANY_SEP (dst[srclen - 2])
+ && !IS_ANY_SEP (src[srclen - 2])
#endif
- )
- {
- dst[srclen - 1] = 0;
- srclen--;
- }
+ && IS_DIRECTORY_SEP (src[srclen - 1])
+ && ! (srclen == 2 && IS_DIRECTORY_SEP (src[0])))
+ srclen--;
+
+ memcpy (dst, src, srclen);
+ dst[srclen] = 0;
#ifdef DOS_NT
- dostounix_filename (dst, multibyte);
+ dostounix_filename (dst);
#endif
return srclen;
}
{
char *buf;
ptrdiff_t length;
- Lisp_Object handler;
+ Lisp_Object handler, val;
+ USE_SAFE_ALLOCA;
CHECK_STRING (directory);
if (!NILP (Vw32_downcase_file_names))
directory = Fdowncase (directory);
#endif
- buf = alloca (SBYTES (directory) + 20);
+ buf = SAFE_ALLOCA (SBYTES (directory) + 1);
length = directory_file_name (buf, SSDATA (directory), SBYTES (directory),
STRING_MULTIBYTE (directory));
- return make_specified_string (buf, -1, length, STRING_MULTIBYTE (directory));
+ val = make_specified_string (buf, -1, length, STRING_MULTIBYTE (directory));
+ SAFE_FREE ();
+ return val;
}
static const char make_temp_name_tbl[64] =
Lisp_Object
make_temp_name (Lisp_Object prefix, bool base64_p)
{
- Lisp_Object val;
- int len, clen;
+ Lisp_Object val, encoded_prefix;
+ int len;
printmax_t pid;
char *p, *data;
char pidbuf[INT_BUFSIZE_BOUND (printmax_t)];
#endif
}
- len = SBYTES (prefix); clen = SCHARS (prefix);
- val = make_uninit_multibyte_string (clen + 3 + pidlen, len + 3 + pidlen);
- if (!STRING_MULTIBYTE (prefix))
- STRING_SET_UNIBYTE (val);
+ encoded_prefix = ENCODE_FILE (prefix);
+ len = SBYTES (encoded_prefix);
+ val = make_uninit_string (len + 3 + pidlen);
data = SSDATA (val);
- memcpy (data, SSDATA (prefix), len);
+ memcpy (data, SSDATA (encoded_prefix), len);
p = data + len;
memcpy (p, pidbuf, pidlen);
{
/* We want to return only if errno is ENOENT. */
if (errno == ENOENT)
- return val;
+ return DECODE_FILE (val);
else
/* The error here is dubious, but there is little else we
can do. The alternatives are to return nil, which is
Lisp_Object handler, result, handled_name;
bool multibyte;
Lisp_Object hdir;
+ USE_SAFE_ALLOCA;
CHECK_STRING (name);
if (multibyte != STRING_MULTIBYTE (default_directory))
{
if (multibyte)
- default_directory = string_to_multibyte (default_directory);
+ {
+ unsigned char *p = SDATA (name);
+
+ while (*p && ASCII_CHAR_P (*p))
+ p++;
+ if (*p == '\0')
+ {
+ /* NAME is a pure ASCII string, and DEFAULT_DIRECTORY is
+ unibyte. Do not convert DEFAULT_DIRECTORY to
+ multibyte; instead, convert NAME to a unibyte string,
+ so that the result of this function is also a unibyte
+ string. This is needed during bootstrapping and
+ dumping, when Emacs cannot decode file names, because
+ the locale environment is not set up. */
+ name = make_unibyte_string (SSDATA (name), SBYTES (name));
+ multibyte = 0;
+ }
+ else
+ default_directory = string_to_multibyte (default_directory);
+ }
else
{
name = string_to_multibyte (name);
#endif
/* Make a local copy of nm[] to protect it from GC in DECODE_FILE below. */
- nm = alloca (SBYTES (name) + 1);
- memcpy (nm, SSDATA (name), SBYTES (name) + 1);
+ nm = xlispstrdupa (name);
#ifdef DOS_NT
/* Note if special escape prefix is present, but remove for now. */
nm++;
/* 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;
- }
+ if (IS_DIRECTORY_SEP (nm[0]) && IS_DIRECTORY_SEP (nm[1])
+ && !IS_DIRECTORY_SEP (nm[2]))
+ drive = 0;
#endif /* WINDOWSNT */
#endif /* DOS_NT */
|| (p[2] == '.' && (IS_DIRECTORY_SEP (p[3])
|| p[3] == 0))))
lose = 1;
- /* We want to replace multiple `/' in a row with a single
- slash. */
- else if (p > nm
- && IS_DIRECTORY_SEP (p[0])
- && IS_DIRECTORY_SEP (p[1]))
+ /* Replace multiple slashes with a single one, except
+ leave leading "//" alone. */
+ else if (IS_DIRECTORY_SEP (p[0])
+ && IS_DIRECTORY_SEP (p[1])
+ && (p != nm || IS_DIRECTORY_SEP (p[2])))
lose = 1;
p++;
}
#ifdef DOS_NT
/* Make sure directories are all separated with /, but
avoid allocation of a new string when not required. */
- dostounix_filename (nm, multibyte);
+ dostounix_filename (nm);
#ifdef WINDOWSNT
if (IS_DIRECTORY_SEP (nm[1]))
{
nm++;
/* `egetenv' may return a unibyte string, which will bite us since
we expect the directory to be multibyte. */
- tem = build_string (newdir);
+#ifdef WINDOWSNT
+ if (newdir[0])
+ {
+ char newdir_utf8[MAX_UTF8_PATH];
+
+ filename_from_ansi (newdir, newdir_utf8);
+ tem = build_string (newdir_utf8);
+ }
+ else
+#endif
+ tem = build_string (newdir);
if (multibyte && !STRING_MULTIBYTE (tem))
{
hdir = DECODE_FILE (tem);
else /* ~user/filename */
{
char *o, *p;
- for (p = nm; *p && (!IS_DIRECTORY_SEP (*p)); p++);
- o = alloca (p - nm + 1);
+ for (p = nm; *p && !IS_DIRECTORY_SEP (*p); p++)
+ continue;
+ o = SAFE_ALLOCA (p - nm + 1);
memcpy (o, nm, p - nm);
- o [p - nm] = 0;
+ o[p - nm] = 0;
block_input ();
pw = getpwnam (o + 1);
&& !IS_DIRECTORY_SEP (nm[0])
#endif
#ifdef WINDOWSNT
- && !(IS_DIRECTORY_SEP (nm[0]) && IS_DIRECTORY_SEP (nm[1]))
+ && !(IS_DIRECTORY_SEP (nm[0]) && IS_DIRECTORY_SEP (nm[1])
+ && !IS_DIRECTORY_SEP (nm[2]))
#endif
&& !newdir)
{
&& 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]))
+ && ! (IS_DIRECTORY_SEP (newdir[0]) && IS_DIRECTORY_SEP (newdir[1])
+ && !IS_DIRECTORY_SEP (newdir[2]))
#endif
)
{
indirectly by prepending newdir to nm if necessary, and using
cwd (or the wd of newdir's drive) as the new newdir. */
char *adir;
+#ifdef WINDOWSNT
+ const int adir_size = MAX_UTF8_PATH;
+#else
+ const int adir_size = MAXPATHLEN + 1;
+#endif
if (IS_DRIVE (newdir[0]) && IS_DEVICE_SEP (newdir[1]))
{
if (!IS_DIRECTORY_SEP (nm[0]))
{
ptrdiff_t newlen = strlen (newdir);
- char *tmp = alloca (newlen + strlen (nm) + 2);
+ char *tmp = alloca (newlen + file_name_as_directory_slop
+ + strlen (nm) + 1);
file_name_as_directory (tmp, newdir, newlen, multibyte);
strcat (tmp, nm);
nm = tmp;
}
- adir = alloca (MAXPATHLEN + 1);
+ adir = alloca (adir_size);
if (drive)
{
if (!getdefdir (c_toupper (drive) - 'A' + 1, adir))
strcpy (adir, "/");
}
else
- getcwd (adir, MAXPATHLEN + 1);
+ getcwd (adir, adir_size);
if (multibyte)
{
Lisp_Object tem = build_string (adir);
if (IS_DIRECTORY_SEP (nm[0]) && collapse_newdir)
{
#ifdef WINDOWSNT
- if (IS_DIRECTORY_SEP (newdir[0]) && IS_DIRECTORY_SEP (newdir[1]))
+ if (IS_DIRECTORY_SEP (newdir[0]) && IS_DIRECTORY_SEP (newdir[1])
+ && !IS_DIRECTORY_SEP (newdir[2]))
{
char *adir = strcpy (alloca (strlen (newdir) + 1), newdir);
char *p = adir + 2;
if (newdir)
{
- /* Get rid of any slash at the end of newdir, unless newdir is
- just / or // (an incomplete UNC name). */
+ /* Ignore any slash at the end of newdir, unless newdir is
+ just "/" or "//". */
length = strlen (newdir);
- tlen = length + 1;
- if (length > 1 && IS_DIRECTORY_SEP (newdir[length - 1])
-#ifdef WINDOWSNT
- && !(length == 2 && IS_DIRECTORY_SEP (newdir[0]))
-#endif
- )
- {
- char *temp = alloca (length);
- memcpy (temp, newdir, length - 1);
- temp[length - 1] = 0;
- length--;
- newdir = temp;
- }
+ while (length > 1 && IS_DIRECTORY_SEP (newdir[length - 1])
+ && ! (length == 2 && IS_DIRECTORY_SEP (newdir[0])))
+ length--;
}
else
- {
- length = 0;
- tlen = 0;
- }
+ length = 0;
/* Now concatenate the directory and name to new space in the stack frame. */
- tlen += strlen (nm) + 1;
+ tlen = length + file_name_as_directory_slop + 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
target = alloca (tlen + 4);
target += 4;
#else /* not DOS_NT */
- target = alloca (tlen);
+ target = SAFE_ALLOCA (tlen);
#endif /* not DOS_NT */
*target = 0;
if (!(drive && nm[0] && IS_DIRECTORY_SEP (newdir[0])
&& newdir[1] == '\0'))
#endif
- strcpy (target, newdir);
+ {
+ memcpy (target, newdir, length);
+ target[length] = 0;
+ }
}
else
file_name_as_directory (target, newdir, length, multibyte);
++o;
p += 3;
}
- else if (p > target && IS_DIRECTORY_SEP (p[1]))
- /* Collapse multiple `/' in a row. */
+ else if (IS_DIRECTORY_SEP (p[1])
+ && (p != target || IS_DIRECTORY_SEP (p[2])))
+ /* Collapse multiple "/", except leave leading "//" alone. */
p++;
else
{
target[1] = ':';
}
result = make_specified_string (target, -1, o - target, multibyte);
- dostounix_filename (SSDATA (result), multibyte);
+ dostounix_filename (SSDATA (result));
#ifdef WINDOWSNT
if (!NILP (Vw32_downcase_file_names))
result = Fdowncase (result);
{
handled_name = call3 (handler, Qexpand_file_name,
result, default_directory);
- if (STRINGP (handled_name))
- return handled_name;
- error ("Invalid handler in `file-name-handler-alist'");
+ if (! STRINGP (handled_name))
+ error ("Invalid handler in `file-name-handler-alist'");
+ result = handled_name;
}
+ SAFE_FREE ();
return result;
}
those `/' is discarded. */)
(Lisp_Object filename)
{
- char *nm, *s, *p, *o, *x, *endp;
- char *target = NULL;
- ptrdiff_t total = 0;
- bool substituted = 0;
+ char *nm, *p, *x, *endp;
+ bool substituted = false;
bool multibyte;
char *xnm;
Lisp_Object handler;
/* Always work on a copy of the string, in case GC happens during
decode of environment variables, causing the original Lisp_String
data to be relocated. */
- nm = alloca (SBYTES (filename) + 1);
- memcpy (nm, SDATA (filename), SBYTES (filename) + 1);
+ nm = xlispstrdupa (filename);
#ifdef DOS_NT
- dostounix_filename (nm, multibyte);
+ dostounix_filename (nm);
substituted = (memcmp (nm, SDATA (filename), SBYTES (filename)) != 0);
#endif
endp = nm + SBYTES (filename);
return Fsubstitute_in_file_name
(make_specified_string (p, -1, endp - p, multibyte));
- /* See if any variables are substituted into the string
- and find the total length of their values in `total'. */
+ /* See if any variables are substituted into the string. */
- for (p = nm; p != endp;)
- if (*p != '$')
- p++;
- else
- {
- p++;
- if (p == endp)
- goto badsubst;
- else if (*p == '$')
- {
- /* "$$" means a single "$". */
- p++;
- total -= 1;
- substituted = 1;
- continue;
- }
- else if (*p == '{')
- {
- o = ++p;
- p = memchr (p, '}', endp - p);
- if (! p)
- goto missingclose;
- s = p;
- }
- else
- {
- o = p;
- while (p != endp && (c_isalnum (*p) || *p == '_')) p++;
- s = p;
- }
-
- /* Copy out the variable name. */
- target = alloca (s - o + 1);
- memcpy (target, o, s - o);
- target[s - o] = 0;
-#ifdef DOS_NT
- strupr (target); /* $home == $HOME etc. */
-#endif /* DOS_NT */
-
- /* Get variable value. */
- o = egetenv (target);
- if (o)
- {
- /* Don't try to guess a maximum length - UTF8 can use up to
- four bytes per character. This code is unlikely to run
- in a situation that requires performance, so decoding the
- env variables twice should be acceptable. Note that
- decoding may cause a garbage collect. */
- Lisp_Object orig, decoded;
- orig = build_unibyte_string (o);
- decoded = DECODE_FILE (orig);
- total += SBYTES (decoded);
- substituted = 1;
- }
- else if (*p == '}')
- goto badvar;
- }
+ if (!NILP (Ffboundp (Qsubstitute_env_in_file_name)))
+ {
+ Lisp_Object name
+ = (!substituted ? filename
+ : make_specified_string (nm, -1, endp - nm, multibyte));
+ Lisp_Object tmp = call1 (Qsubstitute_env_in_file_name, name);
+ CHECK_STRING (tmp);
+ if (!EQ (tmp, name))
+ substituted = true;
+ filename = tmp;
+ }
if (!substituted)
{
return filename;
}
- /* If substitution required, recopy the string and do it. */
- /* Make space in stack frame for the new copy. */
- xnm = alloca (SBYTES (filename) + total + 1);
- x = xnm;
-
- /* Copy the rest of the name through, replacing $ constructs with values. */
- for (p = nm; *p;)
- if (*p != '$')
- *x++ = *p++;
- else
- {
- p++;
- if (p == endp)
- goto badsubst;
- else if (*p == '$')
- {
- *x++ = *p++;
- continue;
- }
- else if (*p == '{')
- {
- o = ++p;
- p = memchr (p, '}', endp - p);
- if (! p)
- goto missingclose;
- s = p++;
- }
- else
- {
- o = p;
- while (p != endp && (c_isalnum (*p) || *p == '_')) p++;
- s = p;
- }
-
- /* Copy out the variable name. */
- target = alloca (s - o + 1);
- memcpy (target, o, s - o);
- target[s - o] = 0;
-
- /* Get variable value. */
- o = egetenv (target);
- if (!o)
- {
- *x++ = '$';
- strcpy (x, target); x+= strlen (target);
- }
- else
- {
- Lisp_Object orig, decoded;
- ptrdiff_t orig_length, decoded_length;
- orig_length = strlen (o);
- orig = make_unibyte_string (o, orig_length);
- decoded = DECODE_FILE (orig);
- decoded_length = SBYTES (decoded);
- memcpy (x, SDATA (decoded), decoded_length);
- x += decoded_length;
-
- /* If environment variable needed decoding, return value
- needs to be multibyte. */
- if (decoded_length != orig_length
- || memcmp (SDATA (decoded), o, orig_length))
- multibyte = 1;
- }
- }
-
- *x = 0;
+ xnm = SSDATA (filename);
+ x = xnm + SBYTES (filename);
/* If /~ or // appears, discard everything through first slash. */
while ((p = search_embedded_absfilename (xnm, x)) != NULL)
}
else
#endif
- return make_specified_string (xnm, -1, x - xnm, multibyte);
-
- badsubst:
- error ("Bad format environment-variable substitution");
- missingclose:
- error ("Missing \"}\" in environment-variable substitution");
- badvar:
- error ("Substituting nonexistent environment variable \"%s\"", target);
+ return (xnm == SSDATA (filename)
+ ? filename
+ : make_specified_string (xnm, -1, x - xnm, multibyte));
}
\f
/* A slightly faster and more convenient way to get
}
\f
/* Signal an error if the file ABSNAME already exists.
- If INTERACTIVE, ask the user whether to proceed,
- and bypass the error if the user says to go ahead.
+ If KNOWN_TO_EXIST, the file is known to exist.
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 INTERACTIVE, ask the user whether to proceed,
+ and bypass the error if the user says to go ahead.
If QUICK, ask for y or n, not yes or no. */
static void
-barf_or_query_if_file_exists (Lisp_Object absname, const char *querystring,
- bool interactive, struct stat *statptr,
+barf_or_query_if_file_exists (Lisp_Object absname, bool known_to_exist,
+ const char *querystring, bool interactive,
bool quick)
{
Lisp_Object tem, encoded_filename;
encoded_filename = ENCODE_FILE (absname);
- /* `stat' is a good way to tell whether the file exists,
- regardless of what access permissions it has. */
- if (lstat (SSDATA (encoded_filename), &statbuf) >= 0)
+ if (! known_to_exist && lstat (SSDATA (encoded_filename), &statbuf) == 0)
{
if (S_ISDIR (statbuf.st_mode))
xsignal2 (Qfile_error,
build_string ("File is a directory"), absname);
+ known_to_exist = true;
+ }
+ if (known_to_exist)
+ {
if (! interactive)
xsignal2 (Qfile_already_exists,
build_string ("File already exists"), absname);
if (NILP (tem))
xsignal2 (Qfile_already_exists,
build_string ("File already exists"), absname);
- if (statptr)
- *statptr = statbuf;
}
- else
- {
- if (statptr)
- statptr->st_mode = 0;
- }
- return;
}
DEFUN ("copy-file", Fcopy_file, Scopy_file, 2, 6,
If PRESERVE-UID-GID is non-nil, we try to transfer the
uid and gid of FILE to NEWNAME.
-If PRESERVE-EXTENDED-ATTRIBUTES is non-nil, we try to copy additional
-attributes of FILE to NEWNAME, such as its SELinux context and ACL
-entries (depending on how Emacs was built). */)
- (Lisp_Object file, Lisp_Object newname, Lisp_Object ok_if_already_exists, Lisp_Object keep_time, Lisp_Object preserve_uid_gid, Lisp_Object preserve_extended_attributes)
+If PRESERVE-PERMISSIONS is non-nil, copy permissions of FILE to NEWNAME;
+this includes the file modes, along with ACL entries and SELinux
+context if present. Otherwise, if NEWNAME is created its file
+permission bits are those of FILE, masked by the default file
+permissions. */)
+ (Lisp_Object file, Lisp_Object newname, Lisp_Object ok_if_already_exists,
+ Lisp_Object keep_time, Lisp_Object preserve_uid_gid,
+ Lisp_Object preserve_permissions)
{
- int ifd, ofd;
- int n;
- char buf[16 * 1024];
- struct stat st, out_st;
Lisp_Object handler;
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
ptrdiff_t count = SPECPDL_INDEX ();
int conlength = 0;
#endif
#ifdef WINDOWSNT
- acl_t acl = NULL;
+ int result;
+#else
+ bool already_exists = false;
+ mode_t new_mask;
+ int ifd, ofd;
+ int n;
+ char buf[16 * 1024];
+ struct stat st;
#endif
encoded_file = encoded_newname = Qnil;
if (!NILP (handler))
RETURN_UNGCPRO (call7 (handler, Qcopy_file, file, newname,
ok_if_already_exists, keep_time, preserve_uid_gid,
- preserve_extended_attributes));
+ preserve_permissions));
encoded_file = ENCODE_FILE (file);
encoded_newname = ENCODE_FILE (newname);
+#ifdef WINDOWSNT
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), &out_st, 0);
- else if (stat (SSDATA (encoded_newname), &out_st) < 0)
- out_st.st_mode = 0;
+ barf_or_query_if_file_exists (newname, false, "copy to it",
+ INTEGERP (ok_if_already_exists), false);
-#ifdef WINDOWSNT
- if (!NILP (preserve_extended_attributes))
+ result = w32_copy_file (SSDATA (encoded_file), SSDATA (encoded_newname),
+ !NILP (keep_time), !NILP (preserve_uid_gid),
+ !NILP (preserve_permissions));
+ switch (result)
{
- acl = acl_get_file (SDATA (encoded_file), ACL_TYPE_ACCESS);
- if (acl == NULL && acl_errno_valid (errno))
- report_file_error ("Getting ACL", file);
- }
- if (!CopyFile (SDATA (encoded_file),
- SDATA (encoded_newname),
- FALSE))
- {
- /* CopyFile doesn't set errno when it fails. By far the most
- "popular" reason is that the target is read-only. */
- report_file_errno ("Copying file", list2 (file, newname),
- GetLastError () == 5 ? EACCES : EPERM);
- }
- /* CopyFile retains the timestamp by default. */
- else if (NILP (keep_time))
- {
- EMACS_TIME now;
- DWORD attributes;
- char * filename;
-
- filename = SDATA (encoded_newname);
-
- /* Ensure file is writable while its modified time is set. */
- attributes = GetFileAttributes (filename);
- SetFileAttributes (filename, attributes & ~FILE_ATTRIBUTE_READONLY);
- now = current_emacs_time ();
- if (set_file_times (-1, filename, now, now))
- {
- /* Restore original attributes. */
- SetFileAttributes (filename, attributes);
- xsignal2 (Qfile_date_error,
- build_string ("Cannot set file date"), newname);
- }
- /* Restore original attributes. */
- SetFileAttributes (filename, attributes);
- }
- if (acl != NULL)
- {
- bool fail =
- acl_set_file (SDATA (encoded_newname), ACL_TYPE_ACCESS, acl) != 0;
- if (fail && acl_errno_valid (errno))
- report_file_error ("Setting ACL", newname);
-
- acl_free (acl);
+ case -1:
+ report_file_error ("Copying file", list2 (file, newname));
+ case -2:
+ report_file_error ("Copying permissions from", file);
+ case -3:
+ xsignal2 (Qfile_date_error,
+ build_string ("Resetting file times"), newname);
+ case -4:
+ report_file_error ("Copying permissions to", newname);
}
#else /* not WINDOWSNT */
immediate_quit = 1;
if (ifd < 0)
report_file_error ("Opening input file", file);
- record_unwind_protect_int (close_file_unwind, ifd);
+ record_unwind_protect_int_1 (close_file_unwind, ifd, false);
if (fstat (ifd, &st) != 0)
report_file_error ("Input file status", file);
- if (!NILP (preserve_extended_attributes))
+ if (!NILP (preserve_permissions))
{
#if HAVE_LIBSELINUX
if (is_selinux_enabled ())
#endif
}
- if (out_st.st_mode != 0
- && st.st_dev == out_st.st_dev && st.st_ino == out_st.st_ino)
- report_file_errno ("Input and output files are the same",
- list2 (file, newname), 0);
-
/* We can copy only regular files. */
if (!S_ISREG (st.st_mode))
report_file_errno ("Non-regular file", file,
S_ISDIR (st.st_mode) ? EISDIR : EINVAL);
- {
#ifndef MSDOS
- int new_mask = st.st_mode & (!NILP (preserve_uid_gid) ? 0600 : 0666);
+ new_mask = st.st_mode & (!NILP (preserve_uid_gid) ? 0700 : 0777);
#else
- int new_mask = S_IREAD | S_IWRITE;
+ new_mask = S_IREAD | S_IWRITE;
#endif
- ofd = emacs_open (SSDATA (encoded_newname),
- (O_WRONLY | O_TRUNC | O_CREAT
- | (NILP (ok_if_already_exists) ? O_EXCL : 0)),
- new_mask);
- }
+
+ ofd = emacs_open (SSDATA (encoded_newname), O_WRONLY | O_CREAT | O_EXCL,
+ new_mask);
+ if (ofd < 0 && errno == EEXIST)
+ {
+ if (NILP (ok_if_already_exists) || INTEGERP (ok_if_already_exists))
+ barf_or_query_if_file_exists (newname, true, "copy to it",
+ INTEGERP (ok_if_already_exists), false);
+ already_exists = true;
+ ofd = emacs_open (SSDATA (encoded_newname), O_WRONLY, 0);
+ }
if (ofd < 0)
report_file_error ("Opening output file", newname);
- record_unwind_protect_int (close_file_unwind, ofd);
+ record_unwind_protect_int_1 (close_file_unwind, ofd, false);
+
+ if (already_exists)
+ {
+ struct stat out_st;
+ if (fstat (ofd, &out_st) != 0)
+ report_file_error ("Output file status", newname);
+ if (st.st_dev == out_st.st_dev && st.st_ino == out_st.st_ino)
+ report_file_errno ("Input and output files are the same",
+ list2 (file, newname), 0);
+ if (ftruncate (ofd, 0) != 0)
+ report_file_error ("Truncating output file", newname);
+ }
immediate_quit = 1;
QUIT;
/* Preserve the original file permissions, and if requested, also its
owner and group. */
{
- mode_t mode_mask = 07777;
+ mode_t preserved_permissions = st.st_mode & 07777;
+ mode_t default_permissions = st.st_mode & 0777 & ~realmask;
if (!NILP (preserve_uid_gid))
{
/* Attempt to change owner and group. If that doesn't work
attempt to change just the group, as that is sometimes allowed.
Adjust the mode mask to eliminate setuid or setgid bits
- that are inappropriate if the owner and group are wrong. */
+ or group permissions bits that are inappropriate if the
+ owner or group are wrong. */
if (fchown (ofd, st.st_uid, st.st_gid) != 0)
{
- mode_mask &= ~06000;
if (fchown (ofd, -1, st.st_gid) == 0)
- mode_mask |= 02000;
+ preserved_permissions &= ~04000;
+ else
+ {
+ preserved_permissions &= ~06000;
+
+ /* Copy the other bits to the group bits, since the
+ group is wrong. */
+ preserved_permissions &= ~070;
+ preserved_permissions |= (preserved_permissions & 7) << 3;
+ default_permissions &= ~070;
+ default_permissions |= (default_permissions & 7) << 3;
+ }
}
}
- switch (!NILP (preserve_extended_attributes)
+ switch (!NILP (preserve_permissions)
? qcopy_acl (SSDATA (encoded_file), ifd,
SSDATA (encoded_newname), ofd,
- st.st_mode & mode_mask)
- : fchmod (ofd, st.st_mode & mode_mask))
+ preserved_permissions)
+ : (already_exists
+ || (new_mask & ~realmask) == default_permissions)
+ ? 0
+ : fchmod (ofd, default_permissions))
{
case -2: report_file_error ("Copying permissions from", file);
case -1: report_file_error ("Copying permissions to", newname);
if (!NILP (keep_time))
{
- EMACS_TIME atime = get_stat_atime (&st);
- EMACS_TIME mtime = get_stat_mtime (&st);
- if (set_file_times (ofd, SSDATA (encoded_newname), atime, mtime))
+ struct timespec atime = get_stat_atime (&st);
+ struct timespec mtime = get_stat_mtime (&st);
+ if (set_file_times (ofd, SSDATA (encoded_newname), atime, mtime) != 0)
xsignal2 (Qfile_date_error,
build_string ("Cannot set file date"), newname);
}
#endif /* MSDOS */
#endif /* not WINDOWSNT */
- /* Discard the unwind protects. */
- specpdl_ptr = specpdl + count;
+ unbind_to (count, Qnil);
UNGCPRO;
return Qnil;
#endif
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), 0, 0);
+ barf_or_query_if_file_exists (newname, false, "rename to it",
+ INTEGERP (ok_if_already_exists), false);
if (rename (SSDATA (encoded_file), SSDATA (encoded_newname)) < 0)
{
int rename_errno = errno;
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), 0, 0);
+ barf_or_query_if_file_exists (newname, false, "make it a new name",
+ INTEGERP (ok_if_already_exists), false);
unlink (SSDATA (newname));
if (link (SSDATA (encoded_file), SSDATA (encoded_newname)) < 0)
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), 0, 0);
+ barf_or_query_if_file_exists (linkname, false, "make it a link",
+ INTEGERP (ok_if_already_exists), false);
if (symlink (SSDATA (encoded_filename), SSDATA (encoded_linkname)) < 0)
{
/* If we didn't complain already, silently delete existing file. */
return file_name_absolute_p (SSDATA (filename)) ? Qt : Qnil;
}
\f
-/* Return true if FILENAME exists. */
-bool
-check_existing (const char *filename)
-{
- return faccessat (AT_FDCWD, filename, F_OK, AT_EACCESS) == 0;
-}
-
-/* Return true if file FILENAME exists and can be executed. */
-
-static bool
-check_executable (char *filename)
-{
- return faccessat (AT_FDCWD, filename, X_OK, AT_EACCESS) == 0;
-}
-
-/* Return true if file FILENAME exists and can be accessed
- according to AMODE, which should include W_OK.
- On failure, return false and set errno. */
-
-static bool
-check_writable (const char *filename, int amode)
-{
-#ifdef MSDOS
- /* FIXME: an faccessat implementation should be added to the
- DOS/Windows ports and this #ifdef branch should be removed. */
- struct stat st;
- if (stat (filename, &st) < 0)
- return 0;
- errno = EPERM;
- return (st.st_mode & S_IWRITE || S_ISDIR (st.st_mode));
-#else /* not MSDOS */
- bool res = faccessat (AT_FDCWD, filename, amode, AT_EACCESS) == 0;
-#ifdef CYGWIN
- /* faccessat may have returned failure because Cygwin couldn't
- determine the file's UID or GID; if so, we return success. */
- if (!res)
- {
- int faccessat_errno = errno;
- struct stat st;
- if (stat (filename, &st) < 0)
- return 0;
- res = (st.st_uid == -1 || st.st_gid == -1);
- errno = faccessat_errno;
- }
-#endif /* CYGWIN */
- return res;
-#endif /* not MSDOS */
-}
-
DEFUN ("file-exists-p", Ffile_exists_p, Sfile_exists_p, 1, 1, 0,
doc: /* Return t if file FILENAME exists (whether or not you can read it.)
See also `file-readable-p' and `file-attributes'.
absname = ENCODE_FILE (absname);
- return (check_existing (SSDATA (absname))) ? Qt : Qnil;
+ return check_existing (SSDATA (absname)) ? Qt : Qnil;
}
DEFUN ("file-executable-p", Ffile_executable_p, Sfile_executable_p, 1, 1, 0,
doc: /* Return t if FILENAME can be executed by you.
-For a directory, this means you can access files in that directory. */)
+For a directory, this means you can access files in that directory.
+\(It is generally better to use `file-accessible-directory-p' for that
+purpose, though.) */)
(Lisp_Object filename)
{
Lisp_Object absname;
if (!buf)
return Qnil;
- val = build_string (buf);
+ val = build_unibyte_string (buf);
if (buf[0] == '/' && strchr (buf, ':'))
- val = concat2 (build_string ("/:"), val);
+ val = concat2 (build_unibyte_string ("/:"), val);
if (buf != readlink_buf)
xfree (buf);
val = DECODE_FILE (val);
The value is the link target, as a string.
Otherwise it returns nil.
-This function returns t when given the name of a symlink that
-points to a nonexistent file. */)
+This function does not check whether the link target exists. */)
(Lisp_Object filename)
{
Lisp_Object handler;
}
#endif
- return Flist (sizeof (values) / sizeof (values[0]), values);
+ return Flist (ARRAYELTS (values), values);
}
\f
DEFUN ("set-file-selinux-context", Fset_file_selinux_context,
acl_t acl;
Lisp_Object acl_string;
char *str;
+# ifndef HAVE_ACL_TYPE_EXTENDED
+ acl_type_t ACL_TYPE_EXTENDED = ACL_TYPE_ACCESS;
+# endif
#endif
absname = expand_and_dir_to_file (filename,
#ifdef HAVE_ACL_SET_FILE
absname = ENCODE_FILE (absname);
- acl = acl_get_file (SSDATA (absname), ACL_TYPE_ACCESS);
+ acl = acl_get_file (SSDATA (absname), ACL_TYPE_EXTENDED);
if (acl == NULL)
return Qnil;
This setting is inherited by subprocesses. */)
(Lisp_Object mode)
{
+ mode_t oldrealmask, oldumask, newumask;
CHECK_NUMBER (mode);
+ oldrealmask = realmask;
+ newumask = ~ XINT (mode) & 0777;
- umask ((~ XINT (mode)) & 0777);
+ block_input ();
+ realmask = newumask;
+ oldumask = umask (newumask);
+ unblock_input ();
+ eassert (oldumask == oldrealmask);
return Qnil;
}
The value is an integer. */)
(void)
{
- mode_t realmask;
Lisp_Object value;
-
- block_input ();
- realmask = umask (0);
- umask (realmask);
- unblock_input ();
-
XSETINT (value, (~ realmask) & 0777);
return value;
}
{
Lisp_Object absname, encoded_absname;
Lisp_Object handler;
- EMACS_TIME t = lisp_time_argument (timestamp);
+ struct timespec t = lisp_time_argument (timestamp);
absname = Fexpand_file_name (filename, BVAR (current_buffer, directory));
encoded_absname = ENCODE_FILE (absname);
{
- if (set_file_times (-1, SSDATA (encoded_absname), t, t))
+ if (set_file_times (-1, SSDATA (encoded_absname), t, t) != 0)
{
#ifdef MSDOS
/* Setting times on a directory always fails. */
if (stat (SSDATA (absname2), &st2) < 0)
return Qt;
- return (EMACS_TIME_LT (get_stat_mtime (&st2), get_stat_mtime (&st1))
+ return (timespec_cmp (get_stat_mtime (&st2), get_stat_mtime (&st1)) < 0
? Qt : Qnil);
}
\f
}
/* Return a special time value indicating the error number ERRNUM. */
-static EMACS_TIME
+static struct timespec
time_error_value (int errnum)
{
int ns = (errnum == ENOENT || errnum == EACCES || errnum == ENOTDIR
? NONEXISTENT_MODTIME_NSECS
: UNKNOWN_MODTIME_NSECS);
- return make_emacs_time (0, ns);
+ return make_timespec (0, ns);
}
DEFUN ("insert-file-contents", Finsert_file_contents, Sinsert_file_contents,
(Lisp_Object filename, Lisp_Object visit, Lisp_Object beg, Lisp_Object end, Lisp_Object replace)
{
struct stat st;
- EMACS_TIME mtime;
+ struct timespec mtime;
int fd;
ptrdiff_t inserted = 0;
ptrdiff_t how_much;
off_t beg_offset, end_offset;
int unprocessed;
- ptrdiff_t count = SPECPDL_INDEX ();
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
Lisp_Object handler, val, insval, orig_filename, old_undo;
Lisp_Object p;
&& BEG == Z);
Lisp_Object old_Vdeactivate_mark = Vdeactivate_mark;
bool we_locked_file = 0;
- ptrdiff_t fd_index;
+
+ dynwind_begin ();
if (current_buffer->base_buffer && ! NILP (visit))
error ("Cannot do file visiting in an indirect buffer");
goto notfound;
}
- fd_index = SPECPDL_INDEX ();
- record_unwind_protect_int (close_file_unwind, fd);
+ record_unwind_protect_ptr (close_file_ptr_unwind, &fd);
/* Replacement should preserve point as it preserves markers. */
if (!NILP (replace))
report_file_error ("Read error", orig_filename);
else if (nread > 0)
{
- struct buffer *prev = current_buffer;
Lisp_Object workbuf;
struct buffer *buf;
+ dynwind_begin ();
record_unwind_current_buffer ();
workbuf = Fget_buffer_create (build_string (" *code-converting-work*"));
TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
coding_system = call2 (Vset_auto_coding_function,
filename, make_number (nread));
- set_buffer_internal (prev);
- /* Discard the unwind protect for recovering the
- current buffer. */
- specpdl_ptr--;
+ dynwind_end ();
/* Rewind the file for the actual read done later. */
if (lseek (fd, 0, SEEK_SET) < 0)
if (same_at_start - BEGV_BYTE == end_offset - beg_offset)
{
emacs_close (fd);
- clear_unwind_protect (fd_index);
+ fd = -1;
/* Truncate the buffer to the size of the file. */
del_range_1 (same_at_start, same_at_end, 0, 0);
beg_offset += same_at_start - BEGV_BYTE;
end_offset -= ZV_BYTE - same_at_end;
+ invalidate_buffer_caches (current_buffer,
+ BYTE_TO_CHAR (same_at_start),
+ BYTE_TO_CHAR (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);
unsigned char *decoded;
ptrdiff_t temp;
ptrdiff_t this = 0;
- ptrdiff_t this_count = SPECPDL_INDEX ();
bool multibyte
= ! NILP (BVAR (current_buffer, enable_multibyte_characters));
Lisp_Object conversion_buffer;
struct gcpro gcpro1;
+ dynwind_begin ();
conversion_buffer = code_conversion_save (1, multibyte);
/* First read the whole file, performing code conversion into
if (this < 0)
report_file_error ("Read error", orig_filename);
emacs_close (fd);
- clear_unwind_protect (fd_index);
+ fd = -1;
if (unprocessed > 0)
{
{
/* Truncate the buffer to the size of the file. */
if (same_at_start != same_at_end)
- del_range_byte (same_at_start, same_at_end, 0);
+ {
+ invalidate_buffer_caches (current_buffer,
+ BYTE_TO_CHAR (same_at_start),
+ BYTE_TO_CHAR (same_at_end));
+ del_range_byte (same_at_start, same_at_end, 0);
+ }
inserted = 0;
- unbind_to (this_count, Qnil);
+ dynwind_end ();
goto handled;
}
if (same_at_end != same_at_start)
{
+ invalidate_buffer_caches (current_buffer,
+ BYTE_TO_CHAR (same_at_start),
+ BYTE_TO_CHAR (same_at_end));
del_range_byte (same_at_start, same_at_end, 0);
temp = GPT;
eassert (same_at_start == GPT_BYTE);
/* Set point before the inserted characters. */
SET_PT_BOTH (temp, same_at_start);
- unbind_to (this_count, Qnil);
+ dynwind_end ();
goto handled;
}
if (NILP (visit) && total > 0)
{
-#ifdef CLASH_DETECTION
if (!NILP (BVAR (current_buffer, file_truename))
/* Make binding buffer-file-name to nil effective. */
&& !NILP (BVAR (current_buffer, filename))
&& SAVE_MODIFF >= MODIFF)
we_locked_file = 1;
-#endif /* CLASH_DETECTION */
- prepare_to_modify_buffer (GPT, GPT, NULL);
+ prepare_to_modify_buffer (PT, PT, NULL);
}
move_gap_both (PT, PT_BYTE);
if (inserted == 0)
{
-#ifdef CLASH_DETECTION
if (we_locked_file)
unlock_file (BVAR (current_buffer, file_truename));
-#endif
Vdeactivate_mark = old_Vdeactivate_mark;
}
else
Vdeactivate_mark = Qt;
emacs_close (fd);
- clear_unwind_protect (fd_index);
+ fd = -1;
if (how_much < 0)
report_file_error ("Read error", orig_filename);
care of marker adjustment. By this way, we can run Lisp
program safely before decoding the inserted text. */
Lisp_Object unwind_data;
- ptrdiff_t count1 = SPECPDL_INDEX ();
+ dynwind_begin ();
unwind_data = Fcons (BVAR (current_buffer, enable_multibyte_characters),
Fcons (BVAR (current_buffer, undo_list),
if (CONSP (coding_system))
coding_system = XCAR (coding_system);
}
- unbind_to (count1, Qnil);
+ dynwind_end ();
inserted = Z_BYTE - BEG_BYTE;
}
SAVE_MODIFF = MODIFF;
BUF_AUTOSAVE_MODIFF (current_buffer) = MODIFF;
XSETFASTINT (BVAR (current_buffer, save_length), Z - BEG);
-#ifdef CLASH_DETECTION
if (NILP (handler))
{
if (!NILP (BVAR (current_buffer, file_truename)))
unlock_file (BVAR (current_buffer, file_truename));
unlock_file (filename);
}
-#endif /* CLASH_DETECTION */
if (not_regular)
xsignal2 (Qfile_error,
build_string ("not a regular file"), orig_filename);
if (inserted > 0)
{
/* Don't run point motion or modification hooks when decoding. */
- ptrdiff_t count1 = SPECPDL_INDEX ();
ptrdiff_t old_inserted = inserted;
+ dynwind_begin ();
specbind (Qinhibit_point_motion_hooks, Qt);
specbind (Qinhibit_modification_hooks, Qt);
Otherwise start with an empty undo_list. */
bset_undo_list (current_buffer, EQ (old_undo, Qt) ? Qt : Qnil);
- unbind_to (count1, Qnil);
+ dynwind_end ();
}
if (!NILP (visit)
- && EMACS_NSECS (current_buffer->modtime) == NONEXISTENT_MODTIME_NSECS)
+ && current_buffer->modtime.tv_nsec == NONEXISTENT_MODTIME_NSECS)
{
/* If visiting nonexistent file, return nil. */
report_file_errno ("Opening input file", orig_filename, save_errno);
}
+ /* We made a lot of deletions and insertions above, so invalidate
+ the newline cache for the entire region of the inserted
+ characters. */
+ if (current_buffer->base_buffer && current_buffer->base_buffer->newline_cache)
+ invalidate_region_cache (current_buffer->base_buffer,
+ current_buffer->base_buffer->newline_cache,
+ PT - BEG, Z - PT - inserted);
+ else if (current_buffer->newline_cache)
+ invalidate_region_cache (current_buffer,
+ current_buffer->newline_cache,
+ PT - BEG, Z - PT - inserted);
+
if (read_quit)
Fsignal (Qquit, Qnil);
if (NILP (val))
val = list2 (orig_filename, make_number (inserted));
- RETURN_UNGCPRO (unbind_to (count, val));
+ dynwind_end ();
+ return val;
}
\f
static Lisp_Object build_annotations (Lisp_Object, Lisp_Object);
int save_errno = 0;
const char *fn;
struct stat st;
- EMACS_TIME modtime;
- ptrdiff_t count = SPECPDL_INDEX ();
- ptrdiff_t count1 IF_LINT (= 0);
+ struct timespec modtime;
Lisp_Object handler;
Lisp_Object visit_file;
Lisp_Object annotations;
filename = Fexpand_file_name (filename, Qnil);
if (!NILP (mustbenew) && !EQ (mustbenew, Qexcl))
- barf_or_query_if_file_exists (filename, "overwrite", 1, 0, 1);
+ barf_or_query_if_file_exists (filename, false, "overwrite", true, true);
if (STRINGP (visit))
visit_file = Fexpand_file_name (visit, Qnil);
return val;
}
+ dynwind_begin ();
record_unwind_protect (save_restriction_restore, save_restriction_save ());
/* Special kludge to simplify auto-saving. */
if (!STRINGP (start) && !NILP (BVAR (current_buffer, selective_display)))
coding.mode |= CODING_MODE_SELECTIVE_DISPLAY;
-#ifdef CLASH_DETECTION
if (open_and_close_file && !auto_saving)
{
lock_file (lockname);
file_locked = 1;
}
-#endif /* CLASH_DETECTION */
encoded_filename = ENCODE_FILE (filename);
fn = SSDATA (encoded_filename);
if (desc < 0)
{
int open_errno = errno;
-#ifdef CLASH_DETECTION
if (file_locked)
unlock_file (lockname);
-#endif /* CLASH_DETECTION */
UNGCPRO;
report_file_errno ("Opening output file", filename, open_errno);
}
- count1 = SPECPDL_INDEX ();
- record_unwind_protect_int (close_file_unwind, desc);
+ dynwind_begin ();
+ record_unwind_protect_int_1 (close_file_unwind, desc, false);
}
if (NUMBERP (append))
if (ret < 0)
{
int lseek_errno = errno;
-#ifdef CLASH_DETECTION
if (file_locked)
unlock_file (lockname);
-#endif /* CLASH_DETECTION */
UNGCPRO;
report_file_errno ("Lseek error", filename, lseek_errno);
}
}
}
- modtime = invalid_emacs_time ();
+ modtime = invalid_timespec ();
if (visiting)
{
if (fstat (desc, &st) == 0)
if (emacs_close (desc) < 0)
ok = 0, save_errno = errno;
- /* Discard the unwind protect for close_file_unwind. */
- specpdl_ptr = specpdl + count1;
+ dynwind_end ();
}
/* Some file systems have a bug where st_mtime is not updated
unlikely and a similar race between the last write and the fstat
above cannot possibly be closed anyway. */
- if (EMACS_TIME_VALID_P (modtime)
+ if (timespec_valid_p (modtime)
&& ! (valid_timestamp_file_system && st.st_dev == timestamp_file_system))
{
int desc1 = emacs_open (fn, O_WRONLY | O_BINARY, 0);
bool use_heuristic
= ((open_flags & (O_EXCL | O_TRUNC)) != 0
&& st.st_size != 0
- && EMACS_NSECS (modtime) % 100 != 0);
+ && modtime.tv_nsec % 100 != 0);
- EMACS_TIME modtime1 = get_stat_mtime (&st1);
+ struct timespec modtime1 = get_stat_mtime (&st1);
if (use_heuristic
- && EMACS_TIME_EQ (modtime, modtime1)
+ && timespec_cmp (modtime, modtime1) == 0
&& st.st_size == st1.st_size)
{
timestamp_file_system = st.st_dev;
= XCDR (Vwrite_region_annotation_buffers);
}
- unbind_to (count, Qnil);
+ dynwind_end ();
-#ifdef CLASH_DETECTION
if (file_locked)
unlock_file (lockname);
-#endif /* CLASH_DETECTION */
/* Do this before reporting IO error
to avoid a "file has changed on disk" warning on
next attempt to save. */
- if (EMACS_TIME_VALID_P (modtime))
+ if (timespec_valid_p (modtime))
{
current_buffer->modtime = modtime;
current_buffer->modtime_size = st.st_size;
SAVE_MODIFF = MODIFF;
XSETFASTINT (BVAR (current_buffer, save_length), Z - BEG);
bset_filename (current_buffer, visit_file);
- update_mode_lines++;
+ update_mode_lines = 14;
}
else if (quietly)
{
doc: /* Return t if (car A) is numerically less than (car B). */)
(Lisp_Object a, Lisp_Object b)
{
- return Flss (Fcar (a), Fcar (b));
+ Lisp_Object args[2];
+ args[0] = Fcar (a);
+ args[1] = Fcar (b);
+ return Flss (2, args);
}
/* Build the complete list of annotations appropriate for writing out
return 1;
}
+/* Maximum number of characters that the next
+ function encodes per one loop iteration. */
+
+enum { E_WRITE_MAX = 8 * 1024 * 1024 };
/* Write text in the range START and END into descriptor DESC,
encoding them with coding system CODING. If STRING is nil, START
coding->src_multibyte = SCHARS (string) < SBYTES (string);
if (CODING_REQUIRE_ENCODING (coding))
{
- encode_coding_object (coding, string,
- start, string_char_to_byte (string, start),
- end, string_char_to_byte (string, end), Qt);
+ ptrdiff_t nchars = min (end - start, E_WRITE_MAX);
+
+ /* Avoid creating huge Lisp string in encode_coding_object. */
+ if (nchars == E_WRITE_MAX)
+ coding->raw_destination = 1;
+
+ encode_coding_object
+ (coding, string, start, string_char_to_byte (string, start),
+ start + nchars, string_char_to_byte (string, start + nchars),
+ Qt);
}
else
{
coding->src_multibyte = (end - start) < (end_byte - start_byte);
if (CODING_REQUIRE_ENCODING (coding))
{
- encode_coding_object (coding, Fcurrent_buffer (),
- start, start_byte, end, end_byte, Qt);
+ ptrdiff_t nchars = min (end - start, E_WRITE_MAX);
+
+ /* Likewise. */
+ if (nchars == E_WRITE_MAX)
+ coding->raw_destination = 1;
+
+ encode_coding_object
+ (coding, Fcurrent_buffer (), start, start_byte,
+ start + nchars, CHAR_TO_BYTE (start + nchars), Qt);
}
else
{
if (coding->produced > 0)
{
- char *buf = (STRINGP (coding->dst_object)
- ? SSDATA (coding->dst_object)
- : (char *) BYTE_POS_ADDR (coding->dst_pos_byte));
+ char *buf = (coding->raw_destination ? (char *) coding->destination
+ : (STRINGP (coding->dst_object)
+ ? SSDATA (coding->dst_object)
+ : (char *) BYTE_POS_ADDR (coding->dst_pos_byte)));
coding->produced -= emacs_write_sig (desc, buf, coding->produced);
+ if (coding->raw_destination)
+ {
+ /* We're responsible for freeing this, see
+ encode_coding_object to check why. */
+ xfree (coding->destination);
+ coding->raw_destination = 0;
+ }
if (coding->produced)
return 0;
}
struct stat st;
Lisp_Object handler;
Lisp_Object filename;
- EMACS_TIME mtime;
+ struct timespec mtime;
if (NILP (buf))
b = current_buffer;
}
if (!STRINGP (BVAR (b, filename))) return Qt;
- if (EMACS_NSECS (b->modtime) == UNKNOWN_MODTIME_NSECS) return Qt;
+ if (b->modtime.tv_nsec == UNKNOWN_MODTIME_NSECS) return Qt;
/* If the file name has special constructs in it,
call the corresponding file handler. */
mtime = (stat (SSDATA (filename), &st) == 0
? get_stat_mtime (&st)
: time_error_value (errno));
- if (EMACS_TIME_EQ (mtime, b->modtime)
+ if (timespec_cmp (mtime, b->modtime) == 0
&& (b->modtime_size < 0
|| st.st_size == b->modtime_size))
return Qt;
See Info node `(elisp)Modification Time' for more details. */)
(void)
{
- int ns = EMACS_NSECS (current_buffer->modtime);
+ int ns = current_buffer->modtime.tv_nsec;
if (ns < 0)
return make_number (UNKNOWN_MODTIME_NSECS - ns);
return make_lisp_time (current_buffer->modtime);
{
if (!NILP (time_flag))
{
- EMACS_TIME mtime;
+ struct timespec mtime;
if (INTEGERP (time_flag))
{
CHECK_RANGED_INTEGER (time_flag, -1, 0);
- mtime = make_emacs_time (0, UNKNOWN_MODTIME_NSECS - XINT (time_flag));
+ mtime = make_timespec (0, UNKNOWN_MODTIME_NSECS - XINT (time_flag));
}
else
mtime = lisp_time_argument (time_flag);
|| NILP (Ffind_file_name_handler (BVAR (b, auto_save_file_name),
Qwrite_region))))
{
- EMACS_TIME before_time = current_emacs_time ();
- EMACS_TIME after_time;
+ struct timespec before_time = current_timespec ();
+ struct timespec after_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)
+ && before_time.tv_sec - b->auto_save_failure_time < 1200)
continue;
set_buffer_internal (b);
XSETFASTINT (BVAR (current_buffer, save_length), Z - BEG);
set_buffer_internal (old);
- after_time = current_emacs_time ();
+ after_time = current_timespec ();
/* 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);
+ if (after_time.tv_sec - before_time.tv_sec > 60)
+ b->auto_save_failure_time = after_time.tv_sec;
}
}
return Qnil;
}
-Lisp_Object
-Fread_file_name (Lisp_Object prompt, Lisp_Object dir, Lisp_Object default_filename, Lisp_Object mustmatch, Lisp_Object initial, Lisp_Object predicate)
-{
- struct gcpro gcpro1;
- Lisp_Object args[7];
-
- GCPRO1 (default_filename);
- args[0] = intern ("read-file-name");
- args[1] = prompt;
- args[2] = dir;
- args[3] = default_filename;
- args[4] = mustmatch;
- args[5] = initial;
- args[6] = predicate;
- RETURN_UNGCPRO (Ffuncall (7, args));
-}
-
-\f
void
init_fileio (void)
{
+ realmask = umask (0);
+ umask (realmask);
+
valid_timestamp_file_system = 0;
+
+ /* fsync can be a significant performance hit. Often it doesn't
+ suffice to make the file-save operation survive a crash. For
+ batch scripts, which are typically part of larger shell commands
+ that don't fsync other files, its effect on performance can be
+ significant so its utility is particularly questionable.
+ Hence, for now by default fsync is used only when interactive.
+
+ For more on why fsync often fails to work on today's hardware, see:
+ Zheng M et al. Understanding the robustness of SSDs under power fault.
+ 11th USENIX Conf. on File and Storage Technologies, 2013 (FAST '13), 271-84
+ http://www.usenix.org/system/files/conference/fast13/fast13-final80.pdf
+
+ For more on why fsync does not suffice even if it works properly, see:
+ Roche X. Necessary step(s) to synchronize filename operations on disk.
+ Austin Group Defect 672, 2013-03-19
+ http://austingroupbugs.net/view.php?id=672 */
+ write_region_inhibit_fsync = noninteractive;
}
void
syms_of_fileio (void)
{
+#include "fileio.x"
+
DEFSYM (Qoperations, "operations");
DEFSYM (Qexpand_file_name, "expand-file-name");
DEFSYM (Qsubstitute_in_file_name, "substitute-in-file-name");
DEFVAR_LISP ("file-name-coding-system", Vfile_name_coding_system,
doc: /* Coding system for encoding file names.
-If it is nil, `default-file-name-coding-system' (which see) is used. */);
+If it is nil, `default-file-name-coding-system' (which see) is used.
+
+On MS-Windows, the value of this variable is largely ignored if
+\`w32-unicode-filenames' (which see) is non-nil. Emacs on Windows
+behaves as if file names were encoded in `utf-8'. */);
Vfile_name_coding_system = Qnil;
DEFVAR_LISP ("default-file-name-coding-system",
This variable is set/changed by the command `set-language-environment'.
User should not set this variable manually,
instead use `file-name-coding-system' to get a constant encoding
-of file names regardless of the current language environment. */);
+of file names regardless of the current language environment.
+
+On MS-Windows, the value of this variable is largely ignored if
+\`w32-unicode-filenames' (which see) is non-nil. Emacs on Windows
+behaves as if file names were encoded in `utf-8'. */);
Vdefault_file_name_coding_system = Qnil;
DEFSYM (Qformat_decode, "format-decode");
file is usually more useful if it contains the deleted text. */);
Vauto_save_include_big_deletions = Qnil;
- /* fsync can be a significant performance hit. Often it doesn't
- suffice to make the file-save operation survive a crash. For
- batch scripts, which are typically part of larger shell commands
- that don't fsync other files, its effect on performance can be
- significant so its utility is particularly questionable.
- Hence, for now by default fsync is used only when interactive.
-
- For more on why fsync often fails to work on today's hardware, see:
- Zheng M et al. Understanding the robustness of SSDs under power fault.
- 11th USENIX Conf. on File and Storage Technologies, 2013 (FAST '13), 271-84
- http://www.usenix.org/system/files/conference/fast13/fast13-final80.pdf
-
- For more on why fsync does not suffice even if it works properly, see:
- Roche X. Necessary step(s) to synchronize filename operations on disk.
- Austin Group Defect 672, 2013-03-19
- http://austingroupbugs.net/view.php?id=672 */
DEFVAR_BOOL ("write-region-inhibit-fsync", write_region_inhibit_fsync,
doc: /* Non-nil means don't call fsync in `write-region'.
This variable affects calls to `write-region' as well as save commands.
Setting this to nil may avoid data loss if the system loses power or
-the operating system crashes. */);
- write_region_inhibit_fsync = noninteractive;
+the operating system crashes. By default, it is non-nil in batch mode. */);
+ write_region_inhibit_fsync = 0; /* See also `init_fileio' above. */
DEFVAR_BOOL ("delete-by-moving-to-trash", delete_by_moving_to_trash,
doc: /* Specifies whether to use the system's trash can.
DEFSYM (Qmove_file_to_trash, "move-file-to-trash");
DEFSYM (Qcopy_directory, "copy-directory");
DEFSYM (Qdelete_directory, "delete-directory");
-
- defsubr (&Sfind_file_name_handler);
- defsubr (&Sfile_name_directory);
- defsubr (&Sfile_name_nondirectory);
- defsubr (&Sunhandled_file_name_directory);
- defsubr (&Sfile_name_as_directory);
- defsubr (&Sdirectory_file_name);
- defsubr (&Smake_temp_name);
- defsubr (&Sexpand_file_name);
- defsubr (&Ssubstitute_in_file_name);
- defsubr (&Scopy_file);
- defsubr (&Smake_directory_internal);
- defsubr (&Sdelete_directory_internal);
- defsubr (&Sdelete_file);
- defsubr (&Srename_file);
- defsubr (&Sadd_name_to_file);
- defsubr (&Smake_symbolic_link);
- defsubr (&Sfile_name_absolute_p);
- defsubr (&Sfile_exists_p);
- 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);
- defsubr (&Sfile_regular_p);
- defsubr (&Sfile_modes);
- defsubr (&Sset_file_modes);
- defsubr (&Sset_file_times);
- defsubr (&Sfile_selinux_context);
- defsubr (&Sfile_acl);
- defsubr (&Sset_file_acl);
- defsubr (&Sset_file_selinux_context);
- defsubr (&Sset_default_file_modes);
- defsubr (&Sdefault_file_modes);
- defsubr (&Sfile_newer_than_file_p);
- defsubr (&Sinsert_file_contents);
- defsubr (&Schoose_write_coding_system);
- defsubr (&Swrite_region);
- defsubr (&Scar_less_than_car);
- defsubr (&Sverify_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 (&Snext_read_file_uses_dialog_p);
-
-#ifdef HAVE_SYNC
- defsubr (&Sunix_sync);
-#endif
+ DEFSYM (Qsubstitute_env_in_file_name, "substitute-env-in-file-name");
}