/* File IO for GNU Emacs.
- Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995, 1996,
- 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
- 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+
+Copyright (C) 1985-1988, 1993-2011 Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include <config.h>
#include <limits.h>
-
-#ifdef HAVE_FCNTL_H
#include <fcntl.h>
-#endif
-
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <setjmp.h>
-
-#ifdef HAVE_UNISTD_H
#include <unistd.h>
-#endif
-
-#if !defined (S_ISLNK) && defined (S_IFLNK)
-# 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
#ifdef HAVE_PWD_H
#include <pwd.h>
#ifdef WINDOWSNT
#define NOMINMAX 1
#include <windows.h>
-#include <stdlib.h>
#include <fcntl.h>
#endif /* not WINDOWSNT */
#include "msdos.h"
#include <sys/param.h>
#include <fcntl.h>
-#include <string.h>
#endif
#ifdef DOS_NT
#define IS_DRIVE(x) ((x) >= 'A' && (x) <= 'z')
#endif
#ifdef WINDOWSNT
-#define IS_DRIVE(x) isalpha (x)
+#define IS_DRIVE(x) isalpha ((unsigned char) (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))
+#define DRIVE_LETTER(x) (tolower ((unsigned char) (x)))
#endif
#include "systime.h"
#endif
#include "commands.h"
-extern int use_dialog_box;
-extern int use_file_dialog;
-
-#ifndef O_WRONLY
-#define O_WRONLY 1
-#endif
-
-#ifndef O_RDONLY
-#define O_RDONLY 0
-#endif
-
-#ifndef S_ISLNK
-# define lstat stat
-#endif
#ifndef FILE_SYSTEM_CASE
#define FILE_SYSTEM_CASE(filename) (filename)
auto saving and recovering a file. */
Lisp_Object Qauto_save_coding;
-/* 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;
-
/* Property name of a file name handler,
which gives a list of operations it handles.. */
Lisp_Object Qoperations;
/* 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;
-
/* Lisp function for setting buffer-file-coding-system and the
multibyteness of the current buffer after inserting a file. */
Lisp_Object Qafter_insert_file_set_coding;
-/* Functions to be called to create text property annotations for file. */
-Lisp_Object Vwrite_region_annotate_functions;
Lisp_Object Qwrite_region_annotate_functions;
-Lisp_Object Vwrite_region_post_annotation_function;
-
-/* During build_annotations, each time an annotation function is called,
- this holds the annotations made by the previous functions. */
-Lisp_Object Vwrite_region_annotations_so_far;
-
/* Each time an annotation function changes the buffer, the new buffer
is added here. */
Lisp_Object Vwrite_region_annotation_buffers;
-/* File name in which we write a list of all our auto save files. */
-Lisp_Object Vauto_save_list_file_name;
-
-/* Whether or not files are auto-saved into themselves. */
-Lisp_Object Vauto_save_visited_file_name;
-
-/* Whether or not to continue auto-saving after a large deletion. */
-Lisp_Object Vauto_save_include_big_deletions;
-
-/* On NT, specifies the directory separator character, used (eg.) when
- expanding file names. This can be bound to / or \. */
-Lisp_Object Vdirectory_sep_char;
-
#ifdef HAVE_FSYNC
-/* Nonzero means skip the call to fsync in Fwrite-region. */
-int write_region_inhibit_fsync;
#endif
-/* Non-zero means call move-file-to-trash in Fdelete_file or
- Fdelete_directory_internal. */
-int delete_by_moving_to_trash;
-
Lisp_Object Qdelete_by_moving_to_trash;
/* Lisp function for moving files to trash. */
/* Lisp function for recursively deleting directories. */
Lisp_Object Qdelete_directory;
-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.
-
- Vinhibit_file_name_handlers is a list of file name handlers.
- Vinhibit_file_name_operation is the operation being handled.
- If we try to handle that operation, we ignore those handlers. */
-
-static Lisp_Object Vinhibit_file_name_handlers;
-static Lisp_Object Vinhibit_file_name_operation;
-
Lisp_Object Qfile_error, Qfile_already_exists, Qfile_date_error;
Lisp_Object Qexcl;
Lisp_Object Qfile_name_history;
{
int c;
- str = (char *) SDATA (errstring);
- c = STRING_CHAR (str);
+ str = SSDATA (errstring);
+ c = STRING_CHAR ((unsigned char *) str);
Faset (errstring, make_number (0), make_number (DOWNCASE (c)));
}
(Lisp_Object filename)
{
#ifndef DOS_NT
- register const unsigned char *beg;
+ register const char *beg;
#else
- register unsigned char *beg;
+ register char *beg;
#endif
- register const unsigned char *p;
+ register const char *p;
Lisp_Object handler;
CHECK_STRING (filename);
filename = FILE_SYSTEM_CASE (filename);
#ifdef DOS_NT
- beg = (unsigned char *) alloca (SBYTES (filename) + 1);
- memcpy (beg, SDATA (filename), SBYTES (filename) + 1);
+ beg = (char *) alloca (SBYTES (filename) + 1);
+ memcpy (beg, SSDATA (filename), SBYTES (filename) + 1);
#else
- beg = SDATA (filename);
+ beg = SSDATA (filename);
#endif
p = beg + SBYTES (filename);
if (p[-1] == ':')
{
/* MAXPATHLEN+1 is guaranteed to be enough space for getdefdir. */
- unsigned char *res = alloca (MAXPATHLEN + 1);
- unsigned char *r = res;
+ char *res = alloca (MAXPATHLEN + 1);
+ char *r = res;
if (p == beg + 4 && IS_DIRECTORY_SEP (*beg) && beg[1] == ':')
{
r += 2;
}
- if (getdefdir (toupper (*beg) - 'A' + 1, r))
+ if (getdefdir (toupper ((unsigned char) *beg) - 'A' + 1, r))
{
if (!IS_DIRECTORY_SEP (res[strlen (res) - 1]))
strcat (res, "/");
or the entire name if it contains no slash. */)
(Lisp_Object filename)
{
- register const unsigned char *beg, *p, *end;
+ register const char *beg, *p, *end;
Lisp_Object handler;
CHECK_STRING (filename);
if (!NILP (handler))
return call2 (handler, Qfile_name_nondirectory, filename);
- beg = SDATA (filename);
+ beg = SSDATA (filename);
end = p = beg + SBYTES (filename);
while (p != beg && !IS_DIRECTORY_SEP (p[-1])
return call2 (handler, Qfile_name_as_directory, file);
buf = (char *) alloca (SBYTES (file) + 10);
- file_name_as_directory (buf, SDATA (file));
+ file_name_as_directory (buf, SSDATA (file));
return make_specified_string (buf, -1, strlen (buf),
STRING_MULTIBYTE (file));
}
return call2 (handler, Qdirectory_file_name, directory);
buf = (char *) alloca (SBYTES (directory) + 20);
- directory_file_name (SDATA (directory), buf);
+ directory_file_name (SSDATA (directory), buf);
return make_specified_string (buf, -1, strlen (buf),
STRING_MULTIBYTE (directory));
}
Lisp_Object val;
int len, clen;
int pid;
- unsigned char *p, *data;
+ char *p, *data;
char pidbuf[20];
int pidlen;
val = make_uninit_multibyte_string (clen + 3 + pidlen, len + 3 + pidlen);
if (!STRING_MULTIBYTE (prefix))
STRING_SET_UNIBYTE (val);
- data = SDATA (val);
- memcpy (data, SDATA (prefix), len);
+ data = SSDATA (val);
+ memcpy (data, SSDATA (prefix), len);
p = data + len;
memcpy (p, pidbuf, pidlen);
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. */
+ dog-slow, but also useless since eventually nil would
+ have to be returned anyway. */
report_file_error ("Cannot create temporary name for prefix",
Fcons (prefix, Qnil));
/* not reached */
}
}
-
- error ("Cannot create temporary name for prefix `%s'",
- SDATA (prefix));
- return Qnil;
}
Second arg DEFAULT-DIRECTORY is directory to start with if NAME is relative
\(does not start with slash or tilde); if DEFAULT-DIRECTORY is nil or missing,
the current buffer's value of `default-directory' is used.
+NAME should be a string that is a valid file name for the underlying
+filesystem.
File name components that are `.' are removed, and
so are file name components followed by `..', along with the `..' itself;
note that these simplifications are done without checking the resulting
file names in the file system.
+Multiple consecutive slashes are collapsed into a single slash,
+except at the beginning of the file name when they are significant (e.g.,
+UNC file names on MS-Windows.)
An initial `~/' expands to your home directory.
An initial `~USER/' expands to USER's home directory.
See also the function `substitute-in-file-name'.
For technical reasons, this function can return correct but
non-intuitive results for the root directory; for instance,
\(expand-file-name ".." "/") returns "/..". For this reason, use
-(directory-file-name (file-name-directory dirname)) to traverse a
+\(directory-file-name (file-name-directory dirname)) to traverse a
filesystem tree, not (expand-file-name ".." dirname). */)
(Lisp_Object name, Lisp_Object default_directory)
{
/* These point to SDATA and need to be careful with string-relocation
during GC (via DECODE_FILE). */
- unsigned char *nm, *newdir;
+ char *nm, *newdir;
/* This should only point to alloca'd data. */
- unsigned char *target;
+ char *target;
int tlen;
struct passwd *pw;
/* Use the buffer's default-directory if DEFAULT_DIRECTORY is omitted. */
if (NILP (default_directory))
- default_directory = current_buffer->directory;
+ default_directory = BVAR (current_buffer, directory);
if (! STRINGP (default_directory))
{
#ifdef DOS_NT
To avoid this, we set default_directory to the root of the
current drive. */
- extern char *emacs_root_dir (void);
-
default_directory = build_string (emacs_root_dir ());
#else
default_directory = build_string ("/");
}
{
- unsigned char *o = SDATA (default_directory);
+ char *o = SSDATA (default_directory);
/* Make sure DEFAULT_DIRECTORY is properly expanded.
It would be better to do this down below where we actually use
}
/* Make a local copy of nm[] to protect it from GC in DECODE_FILE below. */
- nm = (unsigned char *) alloca (SBYTES (name) + 1);
- memcpy (nm, SDATA (name), SBYTES (name) + 1);
+ nm = (char *) alloca (SBYTES (name) + 1);
+ memcpy (nm, SSDATA (name), SBYTES (name) + 1);
#ifdef DOS_NT
/* Note if special escape prefix is present, but remove for now. */
drive specifier at the beginning. */
if (IS_DRIVE (nm[0]) && IS_DEVICE_SEP (nm[1]))
{
- drive = nm[0];
+ drive = (unsigned char) nm[0];
nm += 2;
}
non-zero value, that means we've discovered that we can't do
that cool trick. */
int lose = 0;
- unsigned char *p = nm;
+ char *p = nm;
while (*p)
{
#ifdef WINDOWSNT
if (IS_DIRECTORY_SEP (nm[1]))
{
- if (strcmp (nm, SDATA (name)) != 0)
+ if (strcmp (nm, SSDATA (name)) != 0)
name = make_specified_string (nm, -1, strlen (nm), multibyte);
}
else
#endif
/* drive must be set, so this is okay */
- if (strcmp (nm - 2, SDATA (name)) != 0)
+ if (strcmp (nm - 2, SSDATA (name)) != 0)
{
char temp[] = " :";
}
return name;
#else /* not DOS_NT */
- if (strcmp (nm, SDATA (name)) == 0)
+ if (strcmp (nm, SSDATA (name)) == 0)
return name;
return make_specified_string (nm, -1, strlen (nm), multibyte);
#endif /* not DOS_NT */
{
Lisp_Object tem;
- if (!(newdir = (unsigned char *) egetenv ("HOME")))
- newdir = (unsigned char *) "";
+ if (!(newdir = egetenv ("HOME")))
+ newdir = "";
nm++;
/* egetenv may return a unibyte string, which will bite us since
we expect the directory to be multibyte. */
if (!STRING_MULTIBYTE (tem))
{
hdir = DECODE_FILE (tem);
- newdir = SDATA (hdir);
+ newdir = SSDATA (hdir);
}
#ifdef DOS_NT
collapse_newdir = 0;
}
else /* ~user/filename */
{
- unsigned char *o, *p;
+ char *o, *p;
for (p = nm; *p && (!IS_DIRECTORY_SEP (*p)); p++);
o = alloca (p - nm + 1);
memcpy (o, nm, p - nm);
UNBLOCK_INPUT;
if (pw)
{
- newdir = (unsigned char *) pw -> pw_dir;
+ newdir = pw->pw_dir;
nm = p;
#ifdef DOS_NT
collapse_newdir = 0;
#endif
&& !newdir)
{
- newdir = SDATA (default_directory);
+ newdir = SSDATA (default_directory);
#ifdef DOS_NT
/* Note if special escape prefix is present, but remove for now. */
if (newdir[0] == '/' && newdir[1] == ':')
if (IS_DRIVE (newdir[0]) && IS_DEVICE_SEP (newdir[1]))
{
- drive = newdir[0];
+ drive = (unsigned char) newdir[0];
newdir += 2;
}
if (!IS_DIRECTORY_SEP (nm[0]))
#ifdef WINDOWSNT
if (IS_DIRECTORY_SEP (newdir[0]) && IS_DIRECTORY_SEP (newdir[1]))
{
- unsigned char *p;
+ char *p;
newdir = strcpy (alloca (strlen (newdir) + 1), newdir);
p = newdir + 2;
while (*p && !IS_DIRECTORY_SEP (*p)) p++;
#endif
)
{
- unsigned char *temp = (unsigned char *) alloca (length);
+ char *temp = (char *) alloca (length);
memcpy (temp, newdir, length - 1);
temp[length - 1] = 0;
newdir = temp;
/* 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 = (char *) alloca (tlen + 4);
target += 4;
#else /* not DOS_NT */
- target = (unsigned char *) alloca (tlen);
+ target = (char *) alloca (tlen);
#endif /* not DOS_NT */
*target = 0;
/* Now canonicalize by removing `//', `/.' and `/foo/..' if they
appear. */
{
- unsigned char *p = target;
- unsigned char *o = target;
+ char *p = target;
+ char *o = target;
while (*p)
{
&& (IS_DIRECTORY_SEP (p[3]) || p[3] == 0))
{
#ifdef WINDOWSNT
- unsigned char *prev_o = o;
+ char *prev_o = o;
#endif
while (o != target && (--o) && !IS_DIRECTORY_SEP (*o))
;
/* Get past ~ to user */
unsigned char *user = nm + 1;
/* Find end of name. */
- unsigned char *ptr = (unsigned char *) index (user, '/');
+ unsigned char *ptr = (unsigned char *) strchr (user, '/');
int len = ptr ? ptr - user : strlen (user);
/* Copy the user name into temp storage. */
o = (unsigned char *) alloca (len + 1);
\f
/* If /~ or // appears, discard everything through first slash. */
static int
-file_name_absolute_p (const unsigned char *filename)
+file_name_absolute_p (const char *filename)
{
return
(IS_DIRECTORY_SEP (*filename) || *filename == '~'
);
}
-static unsigned char *
-search_embedded_absfilename (unsigned char *nm, unsigned char *endp)
+static char *
+search_embedded_absfilename (char *nm, char *endp)
{
- unsigned char *p, *s;
+ char *p, *s;
for (p = nm + 1; p < endp; p++)
{
for (s = p; *s && (!IS_DIRECTORY_SEP (*s)); s++);
if (p[0] == '~' && s > p + 1) /* we've got "/~something/" */
{
- unsigned char *o = alloca (s - p + 1);
+ char *o = alloca (s - p + 1);
struct passwd *pw;
memcpy (o, p, s - p);
o [s - p] = 0;
those `/' is discarded. */)
(Lisp_Object filename)
{
- unsigned char *nm;
+ char *nm;
- register unsigned char *s, *p, *o, *x, *endp;
- unsigned char *target = NULL;
+ register char *s, *p, *o, *x, *endp;
+ char *target = NULL;
int total = 0;
int substituted = 0;
int multibyte;
- unsigned char *xnm;
+ char *xnm;
Lisp_Object handler;
CHECK_STRING (filename);
/* 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 = (unsigned char *) alloca (SBYTES (filename) + 1);
+ nm = (char *) alloca (SBYTES (filename) + 1);
memcpy (nm, SDATA (filename), SBYTES (filename) + 1);
#ifdef DOS_NT
}
/* Copy out the variable name */
- target = (unsigned char *) alloca (s - o + 1);
+ target = (char *) alloca (s - o + 1);
strncpy (target, o, s - o);
target[s - o] = 0;
#ifdef DOS_NT
#endif /* DOS_NT */
/* Get variable value */
- o = (unsigned char *) egetenv (target);
+ o = egetenv (target);
if (o)
{
/* Don't try to guess a maximum length - UTF8 can use up to
/* If substitution required, recopy the string and do it */
/* Make space in stack frame for the new copy */
- xnm = (unsigned char *) alloca (SBYTES (filename) + total + 1);
+ xnm = (char *) alloca (SBYTES (filename) + total + 1);
x = xnm;
/* Copy the rest of the name through, replacing $ constructs with values */
}
/* Copy out the variable name */
- target = (unsigned char *) alloca (s - o + 1);
+ target = (char *) alloca (s - o + 1);
strncpy (target, o, s - o);
target[s - o] = 0;
#ifdef DOS_NT
#endif /* DOS_NT */
/* Get variable value */
- o = (unsigned char *) egetenv (target);
+ o = egetenv (target);
if (!o)
{
*x++ = '$';
orig = make_unibyte_string (o, orig_length);
decoded = DECODE_FILE (orig);
decoded_length = SBYTES (decoded);
- strncpy (x, SDATA (decoded), decoded_length);
+ strncpy (x, SSDATA (decoded), decoded_length);
x += decoded_length;
/* If environment variable needed decoding, return value
needs to be multibyte. */
if (decoded_length != orig_length
- || strncmp (SDATA (decoded), o, orig_length))
+ || strncmp (SSDATA (decoded), o, orig_length))
multibyte = 1;
}
}
If QUICK is nonzero, we ask for y or n, not yes or no. */
void
-barf_or_query_if_file_exists (Lisp_Object absname, unsigned char *querystring, int interactive, struct stat *statptr, int quick)
+barf_or_query_if_file_exists (Lisp_Object absname, const char *querystring,
+ int interactive, struct stat *statptr, int quick)
{
register Lisp_Object tem, encoded_filename;
struct stat statbuf;
/* stat is a good way to tell whether the file exists,
regardless of what access permissions it has. */
- if (lstat (SDATA (encoded_filename), &statbuf) >= 0)
+ if (lstat (SSDATA (encoded_filename), &statbuf) >= 0)
{
if (! interactive)
xsignal2 (Qfile_already_exists,
tem = format2 ("File %s already exists; %s anyway? ",
absname, build_string (querystring));
if (quick)
- tem = Fy_or_n_p (tem);
+ tem = call1 (intern ("y-or-n-p"), tem);
else
tem = do_yes_or_no_p (tem);
UNGCPRO;
|| 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 (SDATA (encoded_newname), &out_st) < 0)
+ else if (stat (SSDATA (encoded_newname), &out_st) < 0)
out_st.st_mode = 0;
#ifdef WINDOWSNT
}
#else /* not WINDOWSNT */
immediate_quit = 1;
- ifd = emacs_open (SDATA (encoded_file), O_RDONLY, 0);
+ ifd = emacs_open (SSDATA (encoded_file), O_RDONLY, 0);
immediate_quit = 0;
if (ifd < 0)
Fcons (file, Fcons (newname, Qnil)));
}
-#if defined (S_ISREG) && defined (S_ISLNK)
if (input_file_statable_p)
{
if (!(S_ISREG (st.st_mode)) && !(S_ISLNK (st.st_mode)))
report_file_error ("Non-regular file", Fcons (file, Qnil));
}
}
-#endif /* S_ISREG && S_ISLNK */
#ifdef MSDOS
/* System's default file type was set to binary by _fmode in emacs.c. */
| (NILP (ok_if_already_exists) ? O_EXCL : 0),
S_IREAD | S_IWRITE);
#else /* not MSDOS */
- ofd = emacs_open (SDATA (encoded_newname),
+ ofd = emacs_open (SSDATA (encoded_newname),
O_WRONLY | O_TRUNC | O_CREAT
| (NILP (ok_if_already_exists) ? O_EXCL : 0),
0666);
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 (SDATA (encoded_newname),
+ if (set_file_times (SSDATA (encoded_newname),
atime, mtime))
xsignal2 (Qfile_date_error,
build_string ("Cannot set file date"), newname);
doc: /* Create a new directory named DIRECTORY. */)
(Lisp_Object directory)
{
- const unsigned char *dir;
+ const char *dir;
Lisp_Object handler;
Lisp_Object encoded_dir;
encoded_dir = ENCODE_FILE (directory);
- dir = SDATA (encoded_dir);
+ dir = SSDATA (encoded_dir);
#ifdef WINDOWSNT
if (mkdir (dir) != 0)
doc: /* Delete the directory named DIRECTORY. Does not follow symlinks. */)
(Lisp_Object directory)
{
- const unsigned char *dir;
+ const char *dir;
Lisp_Object handler;
Lisp_Object encoded_dir;
CHECK_STRING (directory);
directory = Fdirectory_file_name (Fexpand_file_name (directory, Qnil));
encoded_dir = ENCODE_FILE (directory);
- dir = SDATA (encoded_dir);
+ dir = SSDATA (encoded_dir);
if (rmdir (dir) != 0)
report_file_error ("Removing directory", list1 (directory));
encoded_file = ENCODE_FILE (filename);
- if (0 > unlink (SDATA (encoded_file)))
+ if (0 > unlink (SSDATA (encoded_file)))
report_file_error ("Removing old name", list1 (filename));
return Qnil;
}
|| INTEGERP (ok_if_already_exists))
barf_or_query_if_file_exists (newname, "rename to it",
INTEGERP (ok_if_already_exists), 0, 0);
- if (0 > rename (SDATA (encoded_file), SDATA (encoded_newname)))
+ if (0 > rename (SSDATA (encoded_file), SSDATA (encoded_newname)))
{
if (errno == EXDEV)
{
int count;
-#ifdef S_IFLNK
symlink_target = Ffile_symlink_p (file);
if (! NILP (symlink_target))
Fmake_symbolic_link (symlink_target, newname,
NILP (ok_if_already_exists) ? Qnil : Qt);
- else
-#endif
- if (!NILP (Ffile_directory_p (file)))
+ else if (!NILP (Ffile_directory_p (file)))
call4 (Qcopy_directory, file, newname, Qt, Qnil);
else
/* We have already prompted if it was an integer, so don't
count = SPECPDL_INDEX ();
specbind (Qdelete_by_moving_to_trash, Qnil);
- if (!NILP (Ffile_directory_p (file))
-#ifdef S_IFLNK
- && NILP (symlink_target)
-#endif
- )
+ if (!NILP (Ffile_directory_p (file)) && NILP (symlink_target))
call2 (Qdelete_directory, file, Qt);
else
Fdelete_file (file, Qnil);
barf_or_query_if_file_exists (newname, "make it a new name",
INTEGERP (ok_if_already_exists), 0, 0);
- unlink (SDATA (newname));
- if (0 > link (SDATA (encoded_file), SDATA (encoded_newname)))
+ unlink (SSDATA (newname));
+ if (0 > link (SSDATA (encoded_file), SSDATA (encoded_newname)))
report_file_error ("Adding new name", list2 (file, newname));
UNGCPRO;
RETURN_UNGCPRO (call4 (handler, Qmake_symbolic_link, filename,
linkname, ok_if_already_exists));
-#ifdef S_IFLNK
encoded_filename = ENCODE_FILE (filename);
encoded_linkname = ENCODE_FILE (linkname);
|| INTEGERP (ok_if_already_exists))
barf_or_query_if_file_exists (linkname, "make it a link",
INTEGERP (ok_if_already_exists), 0, 0);
- if (0 > symlink (SDATA (encoded_filename),
- SDATA (encoded_linkname)))
+ if (0 > symlink (SSDATA (encoded_filename),
+ SSDATA (encoded_linkname)))
{
/* If we didn't complain already, silently delete existing file. */
if (errno == EEXIST)
{
- unlink (SDATA (encoded_linkname));
- if (0 <= symlink (SDATA (encoded_filename),
- SDATA (encoded_linkname)))
+ unlink (SSDATA (encoded_linkname));
+ if (0 <= symlink (SSDATA (encoded_filename),
+ SSDATA (encoded_linkname)))
{
UNGCPRO;
return Qnil;
}
UNGCPRO;
return Qnil;
-
-#else
- UNGCPRO;
- xsignal1 (Qfile_error, build_string ("Symbolic links are not supported"));
-
-#endif /* S_IFLNK */
}
\f
(Lisp_Object filename)
{
CHECK_STRING (filename);
- return file_name_absolute_p (SDATA (filename)) ? Qt : Qnil;
+ return file_name_absolute_p (SSDATA (filename)) ? Qt : Qnil;
}
\f
/* Return nonzero if file FILENAME exists and can be executed. */
/* Return nonzero if file FILENAME exists and can be written. */
static int
-check_writable (char *filename)
+check_writable (const char *filename)
{
#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);
+ return (st.st_mode & S_IWRITE || S_ISDIR (st.st_mode));
#else /* not MSDOS */
#ifdef HAVE_EUIDACCESS
return (euidaccess (filename, 2) >= 0);
absname = ENCODE_FILE (absname);
- return (stat (SDATA (absname), &statbuf) >= 0) ? Qt : Qnil;
+ return (stat (SSDATA (absname), &statbuf) >= 0) ? Qt : Qnil;
}
DEFUN ("file-executable-p", Ffile_executable_p, Sfile_executable_p, 1, 1, 0,
absname = ENCODE_FILE (absname);
- return (check_executable (SDATA (absname)) ? Qt : Qnil);
+ return (check_executable (SSDATA (absname)) ? Qt : Qnil);
}
DEFUN ("file-readable-p", Ffile_readable_p, Sfile_readable_p, 1, 1, 0,
return Qnil;
#else /* not DOS_NT and not macintosh */
flags = O_RDONLY;
-#if defined (S_ISFIFO) && defined (O_NONBLOCK)
+#ifdef 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 (SDATA (absname), &statbuf);
+ desc = stat (SSDATA (absname), &statbuf);
if (desc < 0)
return Qnil;
if (S_ISFIFO (statbuf.st_mode))
flags |= O_NONBLOCK;
#endif
- desc = emacs_open (SDATA (absname), flags, 0);
+ desc = emacs_open (SSDATA (absname), flags, 0);
if (desc < 0)
return Qnil;
emacs_close (desc);
return call2 (handler, Qfile_writable_p, absname);
encoded = ENCODE_FILE (absname);
- if (stat (SDATA (encoded), &statbuf) >= 0)
- return (check_writable (SDATA (encoded))
+ if (stat (SSDATA (encoded), &statbuf) >= 0)
+ return (check_writable (SSDATA (encoded))
? Qt : Qnil);
dir = Ffile_name_directory (absname);
should check ACLs though, which do affect this. */
if (stat (SDATA (dir), &statbuf) < 0)
return Qnil;
- return (statbuf.st_mode & S_IFMT) == S_IFDIR ? Qt : Qnil;
+ return S_ISDIR (statbuf.st_mode) ? Qt : Qnil;
#else
- return (check_writable (!NILP (dir) ? (char *) SDATA (dir) : "")
+ return (check_writable (!NILP (dir) ? SSDATA (dir) : "")
? Qt : Qnil);
#endif
}
encoded_filename = ENCODE_FILE (absname);
- fd = emacs_open (SDATA (encoded_filename), O_RDONLY, 0);
+ fd = emacs_open (SSDATA (encoded_filename), O_RDONLY, 0);
if (fd < 0)
- report_file_error (SDATA (string), Fcons (filename, Qnil));
+ report_file_error (SSDATA (string), Fcons (filename, Qnil));
emacs_close (fd);
return Qnil;
(Lisp_Object filename)
{
Lisp_Object handler;
+ char *buf;
+ int bufsize;
+ int valsize;
+ Lisp_Object val;
CHECK_STRING (filename);
filename = Fexpand_file_name (filename, Qnil);
if (!NILP (handler))
return call2 (handler, Qfile_symlink_p, filename);
-#ifdef S_IFLNK
- {
- char *buf;
- int bufsize;
- int valsize;
- Lisp_Object val;
-
filename = ENCODE_FILE (filename);
bufsize = 50;
memset (buf, 0, bufsize);
errno = 0;
- valsize = readlink (SDATA (filename), buf, bufsize);
+ valsize = readlink (SSDATA (filename), buf, bufsize);
if (valsize == -1)
{
#ifdef ERANGE
while (valsize >= bufsize);
val = make_string (buf, valsize);
- if (buf[0] == '/' && index (buf, ':'))
+ if (buf[0] == '/' && strchr (buf, ':'))
val = concat2 (build_string ("/:"), val);
xfree (buf);
val = DECODE_FILE (val);
return val;
- }
-#else /* not S_IFLNK */
- return Qnil;
-#endif /* not S_IFLNK */
}
DEFUN ("file-directory-p", Ffile_directory_p, Sfile_directory_p, 1, 1, 0,
struct stat st;
Lisp_Object handler;
- absname = expand_and_dir_to_file (filename, current_buffer->directory);
+ absname = expand_and_dir_to_file (filename, BVAR (current_buffer, directory));
/* If the file name has special constructs in it,
call the corresponding file handler. */
absname = ENCODE_FILE (absname);
- if (stat (SDATA (absname), &st) < 0)
+ if (stat (SSDATA (absname), &st) < 0)
return Qnil;
- return (st.st_mode & S_IFMT) == S_IFDIR ? Qt : Qnil;
+ return S_ISDIR (st.st_mode) ? Qt : Qnil;
}
DEFUN ("file-accessible-directory-p", Ffile_accessible_directory_p, Sfile_accessible_directory_p, 1, 1, 0,
struct stat st;
Lisp_Object handler;
- absname = expand_and_dir_to_file (filename, current_buffer->directory);
+ absname = expand_and_dir_to_file (filename, BVAR (current_buffer, directory));
/* If the file name has special constructs in it,
call the corresponding file handler. */
if (result < 0)
return Qnil;
- return (st.st_mode & S_IFMT) == S_IFREG ? Qt : Qnil;
+ return S_ISREG (st.st_mode) ? Qt : Qnil;
}
#else
- if (stat (SDATA (absname), &st) < 0)
+ if (stat (SSDATA (absname), &st) < 0)
return Qnil;
- return (st.st_mode & S_IFMT) == S_IFREG ? Qt : Qnil;
+ return S_ISREG (st.st_mode) ? Qt : Qnil;
#endif
}
\f
context_t context;
#endif
- absname = expand_and_dir_to_file (filename, current_buffer->directory);
+ absname = expand_and_dir_to_file (filename, BVAR (current_buffer, directory));
/* If the file name has special constructs in it,
call the corresponding file handler. */
context_t parsed_con;
#endif
- absname = Fexpand_file_name (filename, current_buffer->directory);
+ absname = Fexpand_file_name (filename, BVAR (current_buffer, directory));
/* If the file name has special constructs in it,
call the corresponding file handler. */
struct stat st;
Lisp_Object handler;
- absname = expand_and_dir_to_file (filename, current_buffer->directory);
+ absname = expand_and_dir_to_file (filename, BVAR (current_buffer, directory));
/* If the file name has special constructs in it,
call the corresponding file handler. */
absname = ENCODE_FILE (absname);
- if (stat (SDATA (absname), &st) < 0)
+ if (stat (SSDATA (absname), &st) < 0)
return Qnil;
return make_number (st.st_mode & 07777);
Lisp_Object absname, encoded_absname;
Lisp_Object handler;
- absname = Fexpand_file_name (filename, current_buffer->directory);
+ absname = Fexpand_file_name (filename, BVAR (current_buffer, directory));
CHECK_NUMBER (mode);
/* If the file name has special constructs in it,
encoded_absname = ENCODE_FILE (absname);
- if (chmod (SDATA (encoded_absname), XINT (mode)) < 0)
+ if (chmod (SSDATA (encoded_absname), XINT (mode)) < 0)
report_file_error ("Doing chmod", Fcons (absname, Qnil));
return Qnil;
return value;
}
\f
-extern int lisp_time_argument (Lisp_Object, time_t *, int *);
DEFUN ("set-file-times", Fset_file_times, Sset_file_times, 1, 2, 0,
doc: /* Set times of file FILENAME to TIME.
if (! lisp_time_argument (time, &sec, &usec))
error ("Invalid time specification");
- absname = Fexpand_file_name (filename, current_buffer->directory);
+ absname = Fexpand_file_name (filename, BVAR (current_buffer, directory));
/* If the file name has special constructs in it,
call the corresponding file handler. */
EMACS_SET_SECS (t, sec);
EMACS_SET_USECS (t, usec);
- if (set_file_times (SDATA (encoded_absname), t, t))
+ if (set_file_times (SSDATA (encoded_absname), t, t))
{
#ifdef DOS_NT
struct stat st;
/* Setting times on a directory always fails. */
- if (stat (SDATA (encoded_absname), &st) == 0
- && (st.st_mode & S_IFMT) == S_IFDIR)
+ if (stat (SSDATA (encoded_absname), &st) == 0 && S_ISDIR (st.st_mode))
return Qnil;
#endif
report_file_error ("Setting file times", Fcons (absname, Qnil));
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);
+ absname1 = expand_and_dir_to_file (file1, BVAR (current_buffer, directory));
+ absname2 = expand_and_dir_to_file (file2, BVAR (current_buffer, directory));
UNGCPRO;
/* If the file name has special constructs in it,
absname2 = ENCODE_FILE (absname2);
UNGCPRO;
- if (stat (SDATA (absname1), &st) < 0)
+ if (stat (SSDATA (absname1), &st) < 0)
return Qnil;
mtime1 = st.st_mtime;
- if (stat (SDATA (absname2), &st) < 0)
+ if (stat (SSDATA (absname2), &st) < 0)
return Qt;
return (mtime1 > st.st_mtime) ? Qt : Qnil;
}
\f
-#ifdef DOS_NT
-Lisp_Object Qfind_buffer_file_type;
-#endif /* DOS_NT */
-
#ifndef READ_BUF_SIZE
#define READ_BUF_SIZE (64 << 10)
#endif
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;
+ BVAR (current_buffer, enable_multibyte_characters) = multibyte;
+ BVAR (current_buffer, undo_list) = undo_list;
return Qnil;
}
immediate_quit = 1;
QUIT;
nbytes = emacs_read (non_regular_fd,
- BEG_ADDR + PT_BYTE - BEG_BYTE + non_regular_inserted,
+ ((char *) BEG_ADDR + PT_BYTE - BEG_BYTE
+ + non_regular_inserted),
non_regular_nbytes);
immediate_quit = 0;
return make_number (nbytes);
Lisp_Object p;
EMACS_INT total = 0;
int not_regular = 0;
- unsigned char read_buf[READ_BUF_SIZE];
+ char read_buf[READ_BUF_SIZE];
struct coding_system coding;
- unsigned char buffer[1 << 14];
+ char buffer[1 << 14];
int replace_handled = 0;
int set_coding_system = 0;
Lisp_Object coding_system;
if (current_buffer->base_buffer && ! NILP (visit))
error ("Cannot do file visiting in an indirect buffer");
- if (!NILP (current_buffer->read_only))
+ if (!NILP (BVAR (current_buffer, read_only)))
Fbarf_if_buffer_read_only ();
val = Qnil;
/* Tell stat to use expensive method to get accurate info. */
Vw32_get_true_file_attributes = Qt;
- total = stat (SDATA (filename), &st);
+ total = stat (SSDATA (filename), &st);
Vw32_get_true_file_attributes = tem;
}
if (total < 0)
#else
- if (stat (SDATA (filename), &st) < 0)
+ if (stat (SSDATA (filename), &st) < 0)
#endif /* WINDOWSNT */
{
if (fd >= 0) emacs_close (fd);
goto notfound;
}
-#ifdef S_IFREG
/* This code will need to be changed in order to work on named
pipes, and it's probably just not worth it. So we should at
least signal an error. */
xsignal2 (Qfile_error,
build_string ("not a regular file"), orig_filename);
}
-#endif
if (fd < 0)
- if ((fd = emacs_open (SDATA (filename), O_RDONLY, 0)) < 0)
+ if ((fd = emacs_open (SSDATA (filename), O_RDONLY, 0)) < 0)
goto badopen;
/* Replacement should preserve point as it preserves markers. */
buf = XBUFFER (buffer);
delete_all_overlays (buf);
- buf->directory = current_buffer->directory;
- buf->read_only = Qnil;
- buf->filename = Qnil;
- buf->undo_list = Qt;
+ BVAR (buf, directory) = BVAR (current_buffer, directory);
+ BVAR (buf, read_only) = Qnil;
+ BVAR (buf, filename) = Qnil;
+ BVAR (buf, undo_list) = Qt;
eassert (buf->overlays_before == NULL);
eassert (buf->overlays_after == NULL);
set_buffer_internal (buf);
Ferase_buffer ();
- buf->enable_multibyte_characters = Qnil;
+ BVAR (buf, enable_multibyte_characters) = Qnil;
- insert_1_both (read_buf, nread, nread, 0, 0, 0);
+ insert_1_both ((char *) read_buf, nread, nread, 0, 0, 0);
TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
coding_system = call2 (Vset_auto_coding_function,
filename, make_number (nread));
else
CHECK_CODING_SYSTEM (coding_system);
- if (NILP (current_buffer->enable_multibyte_characters))
+ if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
/* We must suppress all character code conversion except for
end-of-line conversion. */
coding_system = raw_text_coding_system (coding_system);
nread = emacs_read (fd, buffer, sizeof buffer);
if (nread < 0)
error ("IO error reading %s: %s",
- SDATA (orig_filename), emacs_strerror (errno));
+ SSDATA (orig_filename), emacs_strerror (errno));
else if (nread == 0)
break;
if (CODING_REQUIRE_DETECTION (&coding))
{
- coding_system = detect_coding_system (buffer, nread, nread, 1, 0,
+ coding_system = detect_coding_system ((unsigned char *) buffer,
+ nread, nread, 1, 0,
coding_system);
setup_coding_system (coding_system, &coding);
}
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)
+ && ! NILP (BVAR (current_buffer, enable_multibyte_characters))
&& (CODING_MAY_REQUIRE_DECODING (&coding)))
giveup_match_end = 1;
break;
/* Extend the start of non-matching text area to multibyte
character boundary. */
- if (! NILP (current_buffer->enable_multibyte_characters))
+ if (! NILP (BVAR (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))
+ if (! NILP (BVAR (current_buffer, enable_multibyte_characters)))
while (same_at_end < ZV_BYTE
&& ! CHAR_HEAD_P (FETCH_BYTE (same_at_end)))
same_at_end++;
unsigned char *decoded;
EMACS_INT temp;
int this_count = SPECPDL_INDEX ();
- int multibyte = ! NILP (current_buffer->enable_multibyte_characters);
+ int multibyte = ! NILP (BVAR (current_buffer, enable_multibyte_characters));
Lisp_Object conversion_buffer;
conversion_buffer = code_conversion_save (1, multibyte);
BUF_TEMP_SET_PT (XBUFFER (conversion_buffer),
BUF_Z (XBUFFER (conversion_buffer)));
- decode_coding_c_string (&coding, read_buf, unprocessed + this,
- conversion_buffer);
+ decode_coding_c_string (&coding, (unsigned char *) read_buf,
+ unprocessed + this, conversion_buffer);
unprocessed = coding.carryover_bytes;
if (coding.carryover_bytes > 0)
memcpy (read_buf, coding.carryover, unprocessed);
if (unprocessed > 0)
{
coding.mode |= CODING_MODE_LAST_BLOCK;
- decode_coding_c_string (&coding, read_buf, unprocessed,
- conversion_buffer);
+ decode_coding_c_string (&coding, (unsigned char *) read_buf,
+ unprocessed, conversion_buffer);
coding.mode &= ~CODING_MODE_LAST_BLOCK;
}
/* Extend the start of non-matching text area to the previous
multibyte character boundary. */
- if (! NILP (current_buffer->enable_multibyte_characters))
+ if (! NILP (BVAR (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 the next
multibyte character boundary. */
- if (! NILP (current_buffer->enable_multibyte_characters))
+ if (! NILP (BVAR (current_buffer, enable_multibyte_characters)))
while (same_at_end < ZV_BYTE
&& ! CHAR_HEAD_P (FETCH_BYTE (same_at_end)))
same_at_end++;
if (NILP (visit) && inserted > 0)
{
#ifdef CLASH_DETECTION
- if (!NILP (current_buffer->file_truename)
+ if (!NILP (BVAR (current_buffer, file_truename))
/* Make binding buffer-file-name to nil effective. */
- && !NILP (current_buffer->filename)
+ && !NILP (BVAR (current_buffer, filename))
&& SAVE_MODIFF >= MODIFF)
we_locked_file = 1;
#endif /* CLASH_DETECTION */
here doesn't do any harm. */
immediate_quit = 1;
QUIT;
- this = emacs_read (fd, BEG_ADDR + PT_BYTE - BEG_BYTE + inserted, trytry);
+ this = emacs_read (fd,
+ ((char *) BEG_ADDR + PT_BYTE - BEG_BYTE
+ + inserted),
+ trytry);
immediate_quit = 0;
}
{
#ifdef CLASH_DETECTION
if (we_locked_file)
- unlock_file (current_buffer->file_truename);
+ unlock_file (BVAR (current_buffer, file_truename));
#endif
Vdeactivate_mark = old_Vdeactivate_mark;
}
Lisp_Object unwind_data;
int count = SPECPDL_INDEX ();
- unwind_data = Fcons (current_buffer->enable_multibyte_characters,
- Fcons (current_buffer->undo_list,
+ unwind_data = Fcons (BVAR (current_buffer, enable_multibyte_characters),
+ Fcons (BVAR (current_buffer, undo_list),
Fcurrent_buffer ()));
- current_buffer->enable_multibyte_characters = Qnil;
- current_buffer->undo_list = Qt;
+ BVAR (current_buffer, enable_multibyte_characters) = Qnil;
+ BVAR (current_buffer, undo_list) = Qt;
record_unwind_protect (decide_coding_unwind, unwind_data);
if (inserted > 0 && ! NILP (Vset_auto_coding_function))
else
CHECK_CODING_SYSTEM (coding_system);
- if (NILP (current_buffer->enable_multibyte_characters))
+ if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
/* We must suppress all character code conversion except for
end-of-line conversion. */
coding_system = raw_text_coding_system (coding_system);
&& NILP (replace))
/* Visiting a file with these coding system makes the buffer
unibyte. */
- current_buffer->enable_multibyte_characters = Qnil;
+ BVAR (current_buffer, enable_multibyte_characters) = Qnil;
}
- coding.dst_multibyte = ! NILP (current_buffer->enable_multibyte_characters);
+ coding.dst_multibyte = ! NILP (BVAR (current_buffer, enable_multibyte_characters));
if (CODING_MAY_REQUIRE_DECODING (&coding)
&& (inserted > 0 || CODING_REQUIRE_FLUSHING (&coding)))
{
/* Now INSERTED is measured in characters. */
-#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 ((VECTORP (CODING_ID_EOL_TYPE (coding.id))
- || EQ (CODING_ID_EOL_TYPE (coding.id), Qunix))
- && ! CODING_REQUIRE_DECODING (&coding))
- current_buffer->buffer_file_type = Qt;
- else
- current_buffer->buffer_file_type = Qnil;
-#endif
-
handled:
if (deferred_remove_unwind_protect)
if (!NILP (visit))
{
- if (!EQ (current_buffer->undo_list, Qt) && !nochange)
- current_buffer->undo_list = Qnil;
+ if (!EQ (BVAR (current_buffer, undo_list), Qt) && !nochange)
+ BVAR (current_buffer, undo_list) = Qnil;
if (NILP (handler))
{
current_buffer->modtime = st.st_mtime;
current_buffer->modtime_size = st.st_size;
- current_buffer->filename = orig_filename;
+ BVAR (current_buffer, filename) = orig_filename;
}
SAVE_MODIFF = MODIFF;
BUF_AUTOSAVE_MODIFF (current_buffer) = MODIFF;
- XSETFASTINT (current_buffer->save_length, Z - BEG);
+ XSETFASTINT (BVAR (current_buffer, save_length), Z - BEG);
#ifdef CLASH_DETECTION
if (NILP (handler))
{
- if (!NILP (current_buffer->file_truename))
- unlock_file (current_buffer->file_truename);
+ if (!NILP (BVAR (current_buffer, file_truename)))
+ unlock_file (BVAR (current_buffer, file_truename));
unlock_file (filename);
}
#endif /* CLASH_DETECTION */
specbind (Qinhibit_modification_hooks, Qt);
/* Save old undo list and don't record undo for decoding. */
- old_undo = current_buffer->undo_list;
- current_buffer->undo_list = Qt;
+ old_undo = BVAR (current_buffer, undo_list);
+ BVAR (current_buffer, undo_list) = Qt;
if (NILP (replace))
{
if (NILP (visit))
{
- current_buffer->undo_list = old_undo;
+ BVAR (current_buffer, undo_list) = old_undo;
if (CONSP (old_undo) && inserted != old_inserted)
{
/* Adjust the last undo record for the size change during
else
/* If undo_list was Qt before, keep it that way.
Otherwise start with an empty undo_list. */
- current_buffer->undo_list = EQ (old_undo, Qt) ? Qt : Qnil;
+ BVAR (current_buffer, undo_list) = EQ (old_undo, Qt) ? Qt : Qnil;
unbind_to (count, Qnil);
}
Lisp_Object eol_parent = Qnil;
if (auto_saving
- && NILP (Fstring_equal (current_buffer->filename,
- current_buffer->auto_save_file_name)))
+ && NILP (Fstring_equal (BVAR (current_buffer, filename),
+ BVAR (current_buffer, auto_save_file_name))))
{
val = Qutf_8_emacs;
eol_parent = Qunix;
int using_default_coding = 0;
int force_raw_text = 0;
- val = current_buffer->buffer_file_coding_system;
+ val = BVAR (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))
+ if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
force_raw_text = 1;
}
{
/* 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;
+ val = BVAR (current_buffer, buffer_file_coding_system);
using_default_coding = 1;
}
format, we use that of
`default-buffer-file-coding-system'. */
if (! using_default_coding
- && ! NILP (buffer_defaults.buffer_file_coding_system))
+ && ! NILP (BVAR (&buffer_defaults, buffer_file_coding_system)))
val = (coding_inherit_eol_type
- (val, buffer_defaults.buffer_file_coding_system));
+ (val, BVAR (&buffer_defaults, buffer_file_coding_system)));
/* If we decide not to encode text, use `raw-text' or one of its
subsidiaries. */
val = coding_inherit_eol_type (val, eol_parent);
setup_coding_system (val, coding);
- if (!STRINGP (start) && !NILP (current_buffer->selective_display))
+ if (!STRINGP (start) && !NILP (BVAR (current_buffer, selective_display)))
coding->mode |= CODING_MODE_SELECTIVE_DISPLAY;
return val;
}
register int desc;
int failure;
int save_errno = 0;
- const unsigned char *fn;
+ const char *fn;
struct stat st;
int count = SPECPDL_INDEX ();
int count1;
int quietly = !NILP (visit);
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
struct buffer *given_buffer;
-#ifdef DOS_NT
- int buffer_file_type = O_BINARY;
-#endif /* DOS_NT */
struct coding_system coding;
if (current_buffer->base_buffer && visiting)
if (visiting)
{
SAVE_MODIFF = MODIFF;
- XSETFASTINT (current_buffer->save_length, Z - BEG);
- current_buffer->filename = visit_file;
+ XSETFASTINT (BVAR (current_buffer, save_length), Z - BEG);
+ BVAR (current_buffer, filename) = visit_file;
}
UNGCPRO;
return val;
encoded_filename = ENCODE_FILE (filename);
- fn = SDATA (encoded_filename);
+ fn = SSDATA (encoded_filename);
desc = -1;
if (!NILP (append))
#ifdef DOS_NT
- desc = emacs_open (fn, O_WRONLY | buffer_file_type, 0);
+ desc = emacs_open (fn, O_WRONLY | O_BINARY, 0);
#else /* not DOS_NT */
desc = emacs_open (fn, O_WRONLY, 0);
#endif /* not DOS_NT */
if (desc < 0 && (NILP (append) || errno == ENOENT))
#ifdef DOS_NT
desc = emacs_open (fn,
- O_WRONLY | O_CREAT | buffer_file_type
+ O_WRONLY | O_CREAT | O_BINARY
| (EQ (mustbenew, Qexcl) ? O_EXCL : O_TRUNC),
S_IREAD | S_IWRITE);
#else /* not DOS_NT */
if (visiting)
{
SAVE_MODIFF = MODIFF;
- XSETFASTINT (current_buffer->save_length, Z - BEG);
- current_buffer->filename = visit_file;
+ XSETFASTINT (BVAR (current_buffer, save_length), Z - BEG);
+ BVAR (current_buffer, filename) = visit_file;
update_mode_lines++;
}
else if (quietly)
{
if (auto_saving
- && ! NILP (Fstring_equal (current_buffer->filename,
- current_buffer->auto_save_file_name)))
+ && ! NILP (Fstring_equal (BVAR (current_buffer, filename),
+ BVAR (current_buffer, auto_save_file_name))))
SAVE_MODIFF = MODIFF;
return Qnil;
}
/* Now do the same for annotation functions implied by the file-format */
- if (auto_saving && (!EQ (current_buffer->auto_save_file_format, Qt)))
- p = current_buffer->auto_save_file_format;
+ if (auto_saving && (!EQ (BVAR (current_buffer, auto_save_file_format), Qt)))
+ p = BVAR (current_buffer, auto_save_file_format);
else
- p = current_buffer->file_format;
+ p = BVAR (current_buffer, file_format);
for (i = 0; CONSP (p); p = XCDR (p), ++i)
{
struct buffer *given_buffer = current_buffer;
coding->produced -=
emacs_write (desc,
STRINGP (coding->dst_object)
- ? SDATA (coding->dst_object)
- : BYTE_POS_ADDR (coding->dst_pos_byte),
+ ? SSDATA (coding->dst_object)
+ : (char *) BYTE_POS_ADDR (coding->dst_pos_byte),
coding->produced);
if (coding->produced)
}
\f
DEFUN ("verify-visited-file-modtime", Fverify_visited_file_modtime,
- Sverify_visited_file_modtime, 1, 1, 0,
+ Sverify_visited_file_modtime, 0, 1, 0,
doc: /* Return t if last mod time of BUF's visited file matches what BUF records.
This means that the file has not been changed since it was visited or saved.
+If BUF is omitted or nil, it defaults to the current buffer.
See Info node `(elisp)Modification Time' for more details. */)
(Lisp_Object buf)
{
Lisp_Object handler;
Lisp_Object filename;
- CHECK_BUFFER (buf);
- b = XBUFFER (buf);
+ if (NILP (buf))
+ b = current_buffer;
+ else
+ {
+ CHECK_BUFFER (buf);
+ b = XBUFFER (buf);
+ }
- if (!STRINGP (b->filename)) return Qt;
+ if (!STRINGP (BVAR (b, filename))) return Qt;
if (b->modtime == 0) return Qt;
/* If the file name has special constructs in it,
call the corresponding file handler. */
- handler = Ffind_file_name_handler (b->filename,
+ handler = Ffind_file_name_handler (BVAR (b, filename),
Qverify_visited_file_modtime);
if (!NILP (handler))
return call2 (handler, Qverify_visited_file_modtime, buf);
- filename = ENCODE_FILE (b->filename);
+ filename = ENCODE_FILE (BVAR (b, filename));
- if (stat (SDATA (filename), &st) < 0)
+ if (stat (SSDATA (filename), &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. */
struct stat st;
Lisp_Object handler;
- filename = Fexpand_file_name (current_buffer->filename, Qnil);
+ filename = Fexpand_file_name (BVAR (current_buffer, filename), Qnil);
/* If the file name has special constructs in it,
call the corresponding file handler. */
filename = ENCODE_FILE (filename);
- if (stat (SDATA (filename), &st) >= 0)
+ if (stat (SSDATA (filename), &st) >= 0)
{
current_buffer->modtime = st.st_mtime;
current_buffer->modtime_size = st.st_size;
ring_bell (XFRAME (selected_frame));
args[0] = build_string ("Auto-saving %s: %s");
- args[1] = current_buffer->name;
+ args[1] = BVAR (current_buffer, name);
args[2] = Ferror_message_string (error);
msg = Fformat (3, args);
GCPRO1 (msg);
auto_save_mode_bits = 0666;
/* Get visited file's mode to become the auto save file's mode. */
- if (! NILP (current_buffer->filename))
+ if (! NILP (BVAR (current_buffer, filename)))
{
- if (stat (SDATA (current_buffer->filename), &st) >= 0)
+ if (stat (SSDATA (BVAR (current_buffer, filename)), &st) >= 0)
/* But make sure we can overwrite it later! */
auto_save_mode_bits = st.st_mode | 0600;
- else if ((modes = Ffile_modes (current_buffer->filename),
+ else if ((modes = Ffile_modes (BVAR (current_buffer, filename)),
INTEGERP (modes)))
/* Remote files don't cooperate with stat. */
auto_save_mode_bits = XINT (modes) | 0600;
}
return
- Fwrite_region (Qnil, Qnil, current_buffer->auto_save_file_name, Qnil,
+ Fwrite_region (Qnil, Qnil, BVAR (current_buffer, auto_save_file_name), Qnil,
NILP (Vauto_save_visited_file_name) ? Qlambda : Qt,
Qnil, Qnil);
}
static Lisp_Object
do_auto_save_unwind (Lisp_Object arg) /* used as unwind-protect function */
-
+
{
FILE *stream = (FILE *) XSAVE_VALUE (arg)->pointer;
auto_saving = 0;
static Lisp_Object
do_auto_save_unwind_1 (Lisp_Object value) /* used as unwind-protect function */
-
+
{
minibuffer_auto_raise = XINT (value);
return Qnil;
UNGCPRO;
}
- stream = fopen (SDATA (listfile), "w");
+ stream = fopen (SSDATA (listfile), "w");
}
record_unwind_protect (do_auto_save_unwind,
/* Record all the buffers that have auto save mode
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)
+ if (STRINGP (BVAR (b, auto_save_file_name))
&& stream != NULL && do_handled_files == 0)
{
BLOCK_INPUT;
- if (!NILP (b->filename))
+ if (!NILP (BVAR (b, filename)))
{
- fwrite (SDATA (b->filename), 1,
- SBYTES (b->filename), stream);
+ fwrite (SDATA (BVAR (b, filename)), 1,
+ SBYTES (BVAR (b, filename)), stream);
}
putc ('\n', stream);
- fwrite (SDATA (b->auto_save_file_name), 1,
- SBYTES (b->auto_save_file_name), stream);
+ fwrite (SDATA (BVAR (b, auto_save_file_name)), 1,
+ SBYTES (BVAR (b, auto_save_file_name)), stream);
putc ('\n', stream);
UNBLOCK_INPUT;
}
/* Check for auto save enabled
and file changed since last auto save
and file changed since last real save. */
- if (STRINGP (b->auto_save_file_name)
+ if (STRINGP (BVAR (b, auto_save_file_name))
&& BUF_SAVE_MODIFF (b) < BUF_MODIFF (b)
&& BUF_AUTOSAVE_MODIFF (b) < BUF_MODIFF (b)
/* -1 means we've turned off autosaving for a while--see below. */
- && XINT (b->save_length) >= 0
+ && XINT (BVAR (b, save_length)) >= 0
&& (do_handled_files
- || NILP (Ffind_file_name_handler (b->auto_save_file_name,
+ || NILP (Ffind_file_name_handler (BVAR (b, auto_save_file_name),
Qwrite_region))))
{
EMACS_TIME before_time, after_time;
set_buffer_internal (b);
if (NILP (Vauto_save_include_big_deletions)
- && (XFASTINT (b->save_length) * 10
+ && (XFASTINT (BVAR (b, save_length)) * 10
> (BUF_Z (b) - BUF_BEG (b)) * 13)
/* A short file is likely to change a large fraction;
spare the user annoying messages. */
- && XFASTINT (b->save_length) > 5000
+ && XFASTINT (BVAR (b, save_length)) > 5000
/* These messages are frequent and annoying for `*mail*'. */
- && !EQ (b->filename, Qnil)
+ && !EQ (BVAR (b, filename), Qnil)
&& NILP (no_message))
{
/* It has shrunk too much; turn off auto-saving here. */
minibuffer_auto_raise = orig_minibuffer_auto_raise;
message_with_string ("Buffer %s has shrunk a lot; auto save disabled in that buffer until next real save",
- b->name, 1);
+ BVAR (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);
+ XSETINT (BVAR (b, save_length), -1);
Fsleep_for (make_number (1), Qnil);
continue;
}
internal_condition_case (auto_save_1, Qt, auto_save_error);
auto_saved++;
BUF_AUTOSAVE_MODIFF (b) = BUF_MODIFF (b);
- XSETFASTINT (current_buffer->save_length, Z - BEG);
+ XSETFASTINT (BVAR (current_buffer, save_length), Z - BEG);
set_buffer_internal (old);
EMACS_GET_TIME (after_time);
/* FIXME: This should not be called in indirect buffers, since
they're not autosaved. */
BUF_AUTOSAVE_MODIFF (current_buffer) = MODIFF;
- XSETFASTINT (current_buffer->save_length, Z - BEG);
+ XSETFASTINT (BVAR (current_buffer, save_length), Z - BEG);
current_buffer->auto_save_failure_time = -1;
return Qnil;
}
Qexcl = intern_c_string ("excl");
staticpro (&Qexcl);
-#ifdef DOS_NT
- Qfind_buffer_file_type = intern_c_string ("find-buffer-file-type");
- staticpro (&Qfind_buffer_file_type);
-#endif /* DOS_NT */
-
- DEFVAR_LISP ("file-name-coding-system", &Vfile_name_coding_system,
+ 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. */);
Vfile_name_coding_system = Qnil;
DEFVAR_LISP ("default-file-name-coding-system",
- &Vdefault_file_name_coding_system,
+ Vdefault_file_name_coding_system,
doc: /* Default coding system for encoding file names.
This variable is used only when `file-name-coding-system' is nil.
Fput (Qfile_date_error, Qerror_message,
make_pure_c_string ("Cannot set file date"));
- DEFVAR_LISP ("file-name-handler-alist", &Vfile_name_handler_alist,
+ DEFVAR_LISP ("file-name-handler-alist", Vfile_name_handler_alist,
doc: /* *Alist of elements (REGEXP . HANDLER) for file names handled specially.
If a file name matches REGEXP, then all I/O on that file is done by calling
HANDLER.
Vfile_name_handler_alist = Qnil;
DEFVAR_LISP ("set-auto-coding-function",
- &Vset_auto_coding_function,
+ Vset_auto_coding_function,
doc: /* If non-nil, a function to call to decide a coding system of file.
Two arguments are passed to this function: the file name
and the length of a file contents following the point.
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,
+ DEFVAR_LISP ("after-insert-file-functions", Vafter_insert_file_functions,
doc: /* A list of functions to be called at the end of `insert-file-contents'.
Each is passed one argument, the number of characters inserted,
with point at the start of the inserted text. Each function
functions in `after-insert-file-functions' if appropriate. */);
Vafter_insert_file_functions = Qnil;
- DEFVAR_LISP ("write-region-annotate-functions", &Vwrite_region_annotate_functions,
+ DEFVAR_LISP ("write-region-annotate-functions", Vwrite_region_annotate_functions,
doc: /* A list of functions to be called at the start of `write-region'.
Each is passed two arguments, START and END as for `write-region'.
These are usually two numbers but not always; see the documentation
= intern_c_string ("write-region-annotate-functions");
DEFVAR_LISP ("write-region-post-annotation-function",
- &Vwrite_region_post_annotation_function,
+ Vwrite_region_post_annotation_function,
doc: /* Function to call after `write-region' completes.
The function is called with no arguments. If one or more of the
annotation functions in `write-region-annotate-functions' changed the
staticpro (&Vwrite_region_annotation_buffers);
DEFVAR_LISP ("write-region-annotations-so-far",
- &Vwrite_region_annotations_so_far,
+ Vwrite_region_annotations_so_far,
doc: /* When an annotation function is called, this holds the previous annotations.
These are the annotations made by other annotation functions
that were already called. See also `write-region-annotate-functions'. */);
Vwrite_region_annotations_so_far = Qnil;
- DEFVAR_LISP ("inhibit-file-name-handlers", &Vinhibit_file_name_handlers,
+ DEFVAR_LISP ("inhibit-file-name-handlers", Vinhibit_file_name_handlers,
doc: /* A list of file name handlers that temporarily should not be used.
This applies only to the operation `inhibit-file-name-operation'. */);
Vinhibit_file_name_handlers = Qnil;
- DEFVAR_LISP ("inhibit-file-name-operation", &Vinhibit_file_name_operation,
+ DEFVAR_LISP ("inhibit-file-name-operation", Vinhibit_file_name_operation,
doc: /* The operation for which `inhibit-file-name-handlers' is applicable. */);
Vinhibit_file_name_operation = Qnil;
- DEFVAR_LISP ("auto-save-list-file-name", &Vauto_save_list_file_name,
+ DEFVAR_LISP ("auto-save-list-file-name", Vauto_save_list_file_name,
doc: /* File name in which we write a list of all auto save file names.
This variable is initialized automatically from `auto-save-list-file-prefix'
shortly after Emacs reads your `.emacs' file, if you have not yet given it
a non-nil value. */);
Vauto_save_list_file_name = Qnil;
- DEFVAR_LISP ("auto-save-visited-file-name", &Vauto_save_visited_file_name,
+ DEFVAR_LISP ("auto-save-visited-file-name", Vauto_save_visited_file_name,
doc: /* Non-nil says auto-save a buffer in the file it is visiting, when practical.
Normally auto-save files are written under other names. */);
Vauto_save_visited_file_name = Qnil;
- DEFVAR_LISP ("auto-save-include-big-deletions", &Vauto_save_include_big_deletions,
+ DEFVAR_LISP ("auto-save-include-big-deletions", Vauto_save_include_big_deletions,
doc: /* If non-nil, auto-save even if a large part of the text is deleted.
If nil, deleting a substantial portion of the text disables auto-save
in the buffer; this is the default behavior, because the auto-save
Vauto_save_include_big_deletions = Qnil;
#ifdef HAVE_FSYNC
- DEFVAR_BOOL ("write-region-inhibit-fsync", &write_region_inhibit_fsync,
+ 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.
A non-nil value may result in data loss! */);
write_region_inhibit_fsync = 0;
#endif
- DEFVAR_BOOL ("delete-by-moving-to-trash", &delete_by_moving_to_trash,
+ DEFVAR_BOOL ("delete-by-moving-to-trash", delete_by_moving_to_trash,
doc: /* Specifies whether to use the system's trash can.
When non-nil, certain file deletion commands use the function
`move-file-to-trash' instead of deleting files outright.
defsubr (&Sunix_sync);
#endif
}
-
-/* arch-tag: 64ba3fd7-f844-4fb2-ba4b-427eb928786c
- (do not change this comment) */
HCoop / bpt / emacs.git / blobdiff