-/* Copyright (C) 1985, 1986, 1987, 1993 Free Software Foundation, Inc.
+/* Copyright (C) 1985, 1986, 1987, 1993, 1994 Free Software Foundation, Inc.
This file is part of GNU Emacs.
You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING. If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
#include <sys/types.h>
extern char *egetenv ();
extern char *strcpy ();
-#if defined (__bsdi__) || defined (DECLARE_GETPWUID_WITH_UID_T)
+#ifdef DECLARE_GETPWUID_WITH_UID_T
extern struct passwd *getpwuid (uid_t);
#else
extern struct passwd *getpwuid ();
/* The name of the directory in which we keep lock files, with a '/'
appended. */
-char *lock_path;
+char *lock_dir;
/* The name of the file in the lock directory which is used to
arbitrate access to the entire directory. */
#define SUPERLOCK_NAME "!!!SuperLock!!!"
-/* The path to the superlock file. This is SUPERLOCK_NAME appended to
- lock_path. */
-char *superlock_path;
+/* The name of the superlock file. This is SUPERLOCK_NAME appended to
+ lock_dir. */
+char *superlock_file;
/* Set LOCK to the name of the lock file for the filename FILE.
char *LOCK; Lisp_Object FILE; */
#ifndef HAVE_LONG_FILE_NAMES
-#define MAKE_LOCK_PATH(lock, file) \
- (lock = (char *) alloca (14 + strlen (lock_path) + 1), \
+#define MAKE_LOCK_NAME(lock, file) \
+ (lock = (char *) alloca (14 + strlen (lock_dir) + 1), \
fill_in_lock_short_file_name (lock, (file)))
crc.byte[1] = crc.byte[0];
crc.byte[0] = new;
}
- sprintf (lockfile, "%s%.2x%.2x%.2x%.2x%.2x%.2x%.2x", lock_path,
+ sprintf (lockfile, "%s%.2x%.2x%.2x%.2x%.2x%.2x%.2x", lock_dir,
crc.byte[0], crc.byte[1], crc.byte[2], crc.byte[3],
crc.byte[4], crc.byte[5], crc.byte[6]);
}
#else /* defined HAVE_LONG_FILE_NAMES */
-#define MAKE_LOCK_PATH(lock, file) \
- (lock = (char *) alloca (XSTRING (file)->size + strlen (lock_path) + 1), \
+#define MAKE_LOCK_NAME(lock, file) \
+ (lock = (char *) alloca (XSTRING (file)->size + strlen (lock_dir) + 1), \
fill_in_lock_file_name (lock, (file)))
{
register char *p;
- strcpy (lockfile, lock_path);
+ strcpy (lockfile, lock_dir);
p = lockfile + strlen (lockfile);
lock_file (fn)
register Lisp_Object fn;
{
- register Lisp_Object attack;
+ register Lisp_Object attack, orig_fn;
register char *lfname;
- MAKE_LOCK_PATH (lfname, fn);
+ orig_fn = fn;
+ fn = Fexpand_file_name (fn, Qnil);
+
+ MAKE_LOCK_NAME (lfname, fn);
/* See if this file is visited and has changed on disk since it was
visited. */
{
- register Lisp_Object subject_buf = Fget_file_buffer (fn);
+ register Lisp_Object subject_buf;
+ subject_buf = get_truename_buffer (orig_fn);
if (!NILP (subject_buf)
&& NILP (Fverify_visited_file_modtime (subject_buf))
&& !NILP (Ffile_exists_p (fn)))
{
lock_superlock (lfname);
lock_file_1 (lfname, O_WRONLY) ;
- unlink (superlock_path);
+ unlink (superlock_file);
return;
}
/* User says ignore the lock */
{
register char *lfname;
- MAKE_LOCK_PATH (lfname, fn);
+ fn = Fexpand_file_name (fn, Qnil);
+
+ MAKE_LOCK_NAME (lfname, fn);
lock_superlock (lfname);
if (current_lock_owner_1 (lfname) == getpid ())
unlink (lfname);
- unlink (superlock_path);
+ unlink (superlock_file);
}
lock_superlock (lfname)
register int i, fd;
DIR *lockdir;
- for (i = -20; i < 0 && (fd = open (superlock_path,
+ for (i = -20; i < 0 && (fd = open (superlock_file,
O_WRONLY | O_EXCL | O_CREAT, 0666)) < 0;
i++)
{
/* This seems to be necessary to prevent Emacs from hanging when the
competing process has already deleted the superlock, but it's still
in the NFS cache. So we force NFS to synchronize the cache. */
- if (lockdir = opendir (lock_path))
+ if (lockdir = opendir (lock_dir))
closedir (lockdir);
sleep (1);
if (fd >= 0)
{
#ifdef USG
- chmod (superlock_path, 0666);
+ chmod (superlock_file, 0666);
#else
fchmod (fd, 0666);
#endif
register Lisp_Object tail;
register struct buffer *b;
- for (tail = Vbuffer_alist; XGCTYPE (tail) == Lisp_Cons;
- tail = XCONS (tail)->cdr)
+ for (tail = Vbuffer_alist; GC_CONSP (tail); tail = XCONS (tail)->cdr)
{
b = XBUFFER (XCONS (XCONS (tail)->car)->cdr);
- if (XTYPE (b->filename) == Lisp_String &&
- b->save_modified < BUF_MODIFF (b))
- unlock_file (b->filename);
+ if (STRINGP (b->file_truename) && BUF_SAVE_MODIFF (b) < BUF_MODIFF (b))
+ unlock_file (b->file_truename);
}
}
"Lock FILE, if current buffer is modified.\n\
FILE defaults to current buffer's visited file,\n\
or else nothing is done if current buffer isn't visiting a file.")
- (fn)
- Lisp_Object fn;
+ (file)
+ Lisp_Object file;
{
- if (NILP (fn))
- fn = current_buffer->filename;
+ if (NILP (file))
+ file = current_buffer->file_truename;
else
- CHECK_STRING (fn, 0);
- if (current_buffer->save_modified < MODIFF
- && !NILP (fn))
- lock_file (fn);
+ CHECK_STRING (file, 0);
+ if (SAVE_MODIFF < MODIFF
+ && !NILP (file))
+ lock_file (file);
return Qnil;
}
if it should normally be locked.")
()
{
- if (current_buffer->save_modified < MODIFF &&
- XTYPE (current_buffer->filename) == Lisp_String)
- unlock_file (current_buffer->filename);
+ if (SAVE_MODIFF < MODIFF
+ && STRINGP (current_buffer->file_truename))
+ unlock_file (current_buffer->file_truename);
return Qnil;
}
unlock_buffer (buffer)
struct buffer *buffer;
{
- if (buffer->save_modified < BUF_MODIFF (buffer) &&
- XTYPE (buffer->filename) == Lisp_String)
- unlock_file (buffer->filename);
+ if (BUF_SAVE_MODIFF (buffer) < BUF_MODIFF (buffer)
+ && STRINGP (buffer->file_truename))
+ unlock_file (buffer->file_truename);
}
DEFUN ("file-locked-p", Ffile_locked_p, Sfile_locked_p, 0, 1, 0,
"Return nil if the FILENAME is not locked,\n\
t if it is locked by you, else a string of the name of the locker.")
- (fn)
- Lisp_Object fn;
+ (filename)
+ Lisp_Object filename;
{
register char *lfname;
int owner;
- fn = Fexpand_file_name (fn, Qnil);
+ filename = Fexpand_file_name (filename, Qnil);
- MAKE_LOCK_PATH (lfname, fn);
+ MAKE_LOCK_NAME (lfname, filename);
owner = current_lock_owner (lfname);
if (owner <= 0)
init_filelock ()
{
- lock_path = egetenv ("EMACSLOCKDIR");
- if (! lock_path)
- lock_path = PATH_LOCK;
+ char *new_name;
+
+ lock_dir = egetenv ("EMACSLOCKDIR");
+ if (! lock_dir)
+ lock_dir = PATH_LOCK;
+
+ /* Copy the name in case egetenv got it from a Lisp string. */
+ new_name = (char *) xmalloc (strlen (lock_dir) + 2);
+ strcpy (new_name, lock_dir);
+ lock_dir = new_name;
/* Make sure it ends with a slash. */
- if (lock_path[strlen (lock_path) - 1] != '/')
- {
- char *new_path = (char *) xmalloc (strlen (lock_path) + 2);
- strcpy (new_path, lock_path);
- lock_path = new_path;
- strcat (lock_path, "/");
- }
+ if (lock_dir[strlen (lock_dir) - 1] != '/')
+ strcat (lock_dir, "/");
- superlock_path = (char *) xmalloc ((strlen (lock_path)
+ superlock_file = (char *) xmalloc ((strlen (lock_dir)
+ sizeof (SUPERLOCK_NAME)));
- strcpy (superlock_path, lock_path);
- strcat (superlock_path, SUPERLOCK_NAME);
+ strcpy (superlock_file, lock_dir);
+ strcat (superlock_file, SUPERLOCK_NAME);
}
syms_of_filelock ()
HCoop / bpt / emacs.git / blobdiff