view lispref/backups.texi @ 20697:6c8ba5a6147b

(Fbyte_code) <Bsave_current_buffer_1>: Use set_buffer_if_live.

@c -*-texinfo-*-
@c This is part of the GNU Emacs Lisp Reference Manual.
@c Copyright (C) 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc. 
@c See the file elisp.texi for copying conditions.
@setfilename ../info/backups
@node Backups and Auto-Saving, Buffers, Files, Top
@chapter Backups and Auto-Saving

  Backup files and auto-save files are two methods by which Emacs tries
to protect the user from the consequences of crashes or of the user's
own errors.  Auto-saving preserves the text from earlier in the current
editing session; backup files preserve file contents prior to the
current session.

@menu
* Backup Files::   How backup files are made; how their names are chosen.
* Auto-Saving::    How auto-save files are made; how their names are chosen.
* Reverting::      @code{revert-buffer}, and how to customize what it does.
@end menu

@node Backup Files
@section Backup Files
@cindex backup file

  A @dfn{backup file} is a copy of the old contents of a file you are
editing.  Emacs makes a backup file the first time you save a buffer
into its visited file.  Normally, this means that the backup file
contains the contents of the file as it was before the current editing
session.  The contents of the backup file normally remain unchanged once
it exists.

  Backups are usually made by renaming the visited file to a new name.
Optionally, you can specify that backup files should be made by copying
the visited file.  This choice makes a difference for files with
multiple names; it also can affect whether the edited file remains owned
by the original owner or becomes owned by the user editing it.

  By default, Emacs makes a single backup file for each file edited.
You can alternatively request numbered backups; then each new backup
file gets a new name.  You can delete old numbered backups when you
don't want them any more, or Emacs can delete them automatically.

@menu
* Making Backups::     How Emacs makes backup files, and when.
* Rename or Copy::     Two alternatives: renaming the old file or copying it.
* Numbered Backups::   Keeping multiple backups for each source file.
* Backup Names::       How backup file names are computed; customization.
@end menu

@node Making Backups
@subsection Making Backup Files

@defun backup-buffer
  This function makes a backup of the file visited by the current
buffer, if appropriate.  It is called by @code{save-buffer} before
saving the buffer the first time.
@end defun

@defvar buffer-backed-up
  This buffer-local variable indicates whether this buffer's file has
been backed up on account of this buffer.  If it is non-@code{nil}, then
the backup file has been written.  Otherwise, the file should be backed
up when it is next saved (if backups are enabled).  This is a
permanent local; @code{kill-local-variables} does not alter it.
@end defvar

@defopt make-backup-files
This variable determines whether or not to make backup files.  If it
is non-@code{nil}, then Emacs creates a backup of each file when it is
saved for the first time---provided that @code{backup-inhibited}
is @code{nil} (see below).

The following example shows how to change the @code{make-backup-files}
variable only in the @file{RMAIL} buffer and not elsewhere.  Setting it
@code{nil} stops Emacs from making backups of the @file{RMAIL} file,
which may save disk space.  (You would put this code in your
@file{.emacs} file.)

@smallexample
@group
(add-hook 'rmail-mode-hook 
          (function (lambda ()
                      (make-local-variable 
                       'make-backup-files)
                      (setq make-backup-files nil))))
@end group
@end smallexample
@end defopt

@defvar backup-enable-predicate
This variable's value is a function to be called on certain occasions to
decide whether a file should have backup files.  The function receives
one argument, a file name to consider.  If the function returns
@code{nil}, backups are disabled for that file.  Otherwise, the other
variables in this section say whether and how to make backups.

The default value is this:

@example
(lambda (name)
  (or (< (length name) 5)
      (not (string-equal "/tmp/"
                         (substring name 0 5)))))
@end example
@end defvar

@defvar backup-inhibited
If this variable is non-@code{nil}, backups are inhibited.  It records
the result of testing @code{backup-enable-predicate} on the visited file
name.  It can also coherently be used by other mechanisms that inhibit
backups based on which file is visited.  For example, VC sets this
variable non-@code{nil} to prevent making backups for files managed
with a version control system.

This is a permanent local, so that changing the major mode does not lose
its value.  Major modes should not set this variable---they should set
@code{make-backup-files} instead.
@end defvar

@node Rename or Copy
@subsection Backup by Renaming or by Copying?
@cindex backup files, how to make them

  There are two ways that Emacs can make a backup file: 

@itemize @bullet
@item
Emacs can rename the original file so that it becomes a backup file, and
then write the buffer being saved into a new file.  After this
procedure, any other names (i.e., hard links) of the original file now
refer to the backup file.  The new file is owned by the user doing the
editing, and its group is the default for new files written by the user
in that directory.

@item
Emacs can copy the original file into a backup file, and then overwrite
the original file with new contents.  After this procedure, any other
names (i.e., hard links) of the original file still refer to the current
version of the file.  The file's owner and group will be unchanged.
@end itemize

  The first method, renaming, is the default.

  The variable @code{backup-by-copying}, if non-@code{nil}, says to use
the second method, which is to copy the original file and overwrite it
with the new buffer contents.  The variable @code{file-precious-flag},
if non-@code{nil}, also has this effect (as a sideline of its main
significance).  @xref{Saving Buffers}.

@defvar backup-by-copying
If this variable is non-@code{nil}, Emacs always makes backup files by
copying.
@end defvar

  The following two variables, when non-@code{nil}, cause the second
method to be used in certain special cases.  They have no effect on the
treatment of files that don't fall into the special cases.

@defvar backup-by-copying-when-linked
If this variable is non-@code{nil}, Emacs makes backups by copying for
files with multiple names (hard links).

This variable is significant only if @code{backup-by-copying} is
@code{nil}, since copying is always used when that variable is
non-@code{nil}.
@end defvar

@defvar backup-by-copying-when-mismatch
If this variable is non-@code{nil}, Emacs makes backups by copying in cases
where renaming would change either the owner or the group of the file.

The value has no effect when renaming would not alter the owner or
group of the file; that is, for files which are owned by the user and
whose group matches the default for a new file created there by the
user.

This variable is significant only if @code{backup-by-copying} is
@code{nil}, since copying is always used when that variable is
non-@code{nil}.
@end defvar

@node Numbered Backups
@subsection Making and Deleting Numbered Backup Files

  If a file's name is @file{foo}, the names of its numbered backup
versions are @file{foo.~@var{v}~}, for various integers @var{v}, like
this: @file{foo.~1~}, @file{foo.~2~}, @file{foo.~3~}, @dots{},
@file{foo.~259~}, and so on.

@defopt version-control
This variable controls whether to make a single non-numbered backup
file or multiple numbered backups.

@table @asis
@item @code{nil}
Make numbered backups if the visited file already has numbered backups;
otherwise, do not.

@item @code{never}
Do not make numbered backups.

@item @var{anything else}
Make numbered backups.
@end table
@end defopt

  The use of numbered backups ultimately leads to a large number of
backup versions, which must then be deleted.  Emacs can do this
automatically or it can ask the user whether to delete them.

@defopt kept-new-versions
The value of this variable is the number of newest versions to keep
when a new numbered backup is made.  The newly made backup is included
in the count.  The default value is 2.
@end defopt

@defopt kept-old-versions
The value of this variable is the number of oldest versions to keep
when a new numbered backup is made.  The default value is 2.
@end defopt

  If there are backups numbered 1, 2, 3, 5, and 7, and both of these
variables have the value 2, then the backups numbered 1 and 2 are kept
as old versions and those numbered 5 and 7 are kept as new versions;
backup version 3 is excess.  The function @code{find-backup-file-name}
(@pxref{Backup Names}) is responsible for determining which backup
versions to delete, but does not delete them itself.

@defopt trim-versions-without-asking
If this variable is non-@code{nil}, then saving a file deletes excess
backup versions silently.  Otherwise, it asks the user whether to delete
them.
@end defopt

@defopt dired-kept-versions
This variable specifies how many of the newest backup versions to keep
in the Dired command @kbd{.} (@code{dired-clean-directory}).  That's the
same thing @code{kept-new-versions} specifies when you make a new backup
file.  The default value is 2.
@end defopt

@node Backup Names
@subsection Naming Backup Files

  The functions in this section are documented mainly because you can
customize the naming conventions for backup files by redefining them.
If you change one, you probably need to change the rest.

@defun backup-file-name-p filename
This function returns a non-@code{nil} value if @var{filename} is a
possible name for a backup file.  A file with the name @var{filename}
need not exist; the function just checks the name.

@smallexample
@group
(backup-file-name-p "foo")
     @result{} nil
@end group
@group
(backup-file-name-p "foo~")
     @result{} 3
@end group
@end smallexample

The standard definition of this function is as follows:

@smallexample
@group
(defun backup-file-name-p (file)
  "Return non-nil if FILE is a backup file \
name (numeric or not)..."
  (string-match "~$" file))
@end group
@end smallexample

@noindent
Thus, the function returns a non-@code{nil} value if the file name ends
with a @samp{~}.  (We use a backslash to split the documentation
string's first line into two lines in the text, but produce just one
line in the string itself.)

This simple expression is placed in a separate function to make it easy
to redefine for customization.
@end defun

@defun make-backup-file-name filename
This function returns a string that is the name to use for a
non-numbered backup file for file @var{filename}.  On Unix, this is just
@var{filename} with a tilde appended.

The standard definition of this function is as follows:

@smallexample
@group
(defun make-backup-file-name (file)
  "Create the non-numeric backup file name for FILE.
@dots{}"
  (concat file "~"))
@end group
@end smallexample

You can change the backup-file naming convention by redefining this
function.  The following example redefines @code{make-backup-file-name}
to prepend a @samp{.} in addition to appending a tilde:

@smallexample
@group
(defun make-backup-file-name (filename)
  (concat "." filename "~"))
@end group

@group
(make-backup-file-name "backups.texi")
     @result{} ".backups.texi~"
@end group
@end smallexample
@end defun

@defun find-backup-file-name filename
This function computes the file name for a new backup file for
@var{filename}.  It may also propose certain existing backup files for
deletion.  @code{find-backup-file-name} returns a list whose @sc{car} is
the name for the new backup file and whose @sc{cdr} is a list of backup
files whose deletion is proposed.

Two variables, @code{kept-old-versions} and @code{kept-new-versions},
determine which backup versions should be kept.  This function keeps
those versions by excluding them from the @sc{cdr} of the value.
@xref{Numbered Backups}.

In this example, the value says that @file{~rms/foo.~5~} is the name
to use for the new backup file, and @file{~rms/foo.~3~} is an ``excess''
version that the caller should consider deleting now.

@smallexample
@group
(find-backup-file-name "~rms/foo")
     @result{} ("~rms/foo.~5~" "~rms/foo.~3~")
@end group
@end smallexample
@end defun

@c Emacs 19 feature
@defun file-newest-backup filename
This function returns the name of the most recent backup file for
@var{filename}, or @code{nil} if that file has no backup files.

Some file comparison commands use this function so that they can
automatically compare a file with its most recent backup.
@end defun 

@node Auto-Saving
@section Auto-Saving
@cindex auto-saving

  Emacs periodically saves all files that you are visiting; this is
called @dfn{auto-saving}.  Auto-saving prevents you from losing more
than a limited amount of work if the system crashes.  By default,
auto-saves happen every 300 keystrokes, or after around 30 seconds of
idle time.  @xref{Auto-Save, Auto-Save, Auto-Saving: Protection Against
Disasters, emacs, The GNU Emacs Manual}, for information on auto-save
for users.  Here we describe the functions used to implement auto-saving
and the variables that control them.

@defvar buffer-auto-save-file-name
This buffer-local variable is the name of the file used for
auto-saving the current buffer.  It is @code{nil} if the buffer
should not be auto-saved.

@example
@group
buffer-auto-save-file-name
=> "/xcssun/users/rms/lewis/#files.texi#"
@end group
@end example
@end defvar

@deffn Command auto-save-mode arg
When used interactively without an argument, this command is a toggle
switch: it turns on auto-saving of the current buffer if it is off, and
vice-versa.  With an argument @var{arg}, the command turns auto-saving
on if the value of @var{arg} is @code{t}, a nonempty list, or a positive
integer.  Otherwise, it turns auto-saving off.
@end deffn

@defun auto-save-file-name-p filename
This function returns a non-@code{nil} value if @var{filename} is a
string that could be the name of an auto-save file.  It works based on
knowledge of the naming convention for auto-save files: a name that
begins and ends with hash marks (@samp{#}) is a possible auto-save file
name.  The argument @var{filename} should not contain a directory part.

@example
@group
(make-auto-save-file-name)
     @result{} "/xcssun/users/rms/lewis/#files.texi#"
@end group
@group
(auto-save-file-name-p "#files.texi#")
     @result{} 0
@end group
@group
(auto-save-file-name-p "files.texi")
     @result{} nil
@end group
@end example

The standard definition of this function is as follows:

@example
@group
(defun auto-save-file-name-p (filename)
  "Return non-nil if FILENAME can be yielded by..."
  (string-match "^#.*#$" filename))
@end group
@end example

This function exists so that you can customize it if you wish to
change the naming convention for auto-save files.  If you redefine it,
be sure to redefine the function @code{make-auto-save-file-name}
correspondingly.
@end defun

@defun make-auto-save-file-name
This function returns the file name to use for auto-saving the current
buffer.  This is just the file name with hash marks (@samp{#}) appended
and prepended to it.  This function does not look at the variable
@code{auto-save-visited-file-name} (described below); you should check
that before calling this function.

@example
@group
(make-auto-save-file-name)
     @result{} "/xcssun/users/rms/lewis/#backup.texi#"
@end group
@end example

The standard definition of this function is as follows:

@example
@group
(defun make-auto-save-file-name ()
  "Return file name to use for auto-saves \
of current buffer.
@dots{}"
  (if buffer-file-name
@end group
@group
      (concat
       (file-name-directory buffer-file-name)
       "#"
       (file-name-nondirectory buffer-file-name)
       "#")
    (expand-file-name
     (concat "#%" (buffer-name) "#"))))
@end group
@end example

This exists as a separate function so that you can redefine it to
customize the naming convention for auto-save files.  Be sure to
change @code{auto-save-file-name-p} in a corresponding way.
@end defun

@defvar auto-save-visited-file-name
If this variable is non-@code{nil}, Emacs auto-saves buffers in
the files they are visiting.  That is, the auto-save is done in the same
file that you are editing.  Normally, this variable is @code{nil}, so
auto-save files have distinct names that are created by
@code{make-auto-save-file-name}.

When you change the value of this variable, the value does not take
effect until the next time auto-save mode is reenabled in any given
buffer.  If auto-save mode is already enabled, auto-saves continue to go
in the same file name until @code{auto-save-mode} is called again.
@end defvar

@defun recent-auto-save-p
This function returns @code{t} if the current buffer has been
auto-saved since the last time it was read in or saved.
@end defun

@defun set-buffer-auto-saved
This function marks the current buffer as auto-saved.  The buffer will
not be auto-saved again until the buffer text is changed again.  The
function returns @code{nil}.
@end defun

@defopt auto-save-interval
The value of this variable is the number of characters that Emacs
reads from the keyboard between auto-saves.  Each time this many more
characters are read, auto-saving is done for all buffers in which it is
enabled.
@end defopt

@defopt auto-save-timeout
The value of this variable is the number of seconds of idle time that
should cause auto-saving.  Each time the user pauses for this long,
Emacs auto-saves any buffers that need it.  (Actually, the specified
timeout is multiplied by a factor depending on the size of the current
buffer.)
@end defopt

@defvar auto-save-hook
This normal hook is run whenever an auto-save is about to happen.
@end defvar

@defopt auto-save-default
If this variable is non-@code{nil}, buffers that are visiting files
have auto-saving enabled by default.  Otherwise, they do not.
@end defopt

@deffn Command do-auto-save &optional no-message current-only
This function auto-saves all buffers that need to be auto-saved.  It
saves all buffers for which auto-saving is enabled and that have been
changed since the previous auto-save.

Normally, if any buffers are auto-saved, a message that says
@samp{Auto-saving...} is displayed in the echo area while auto-saving is
going on.  However, if @var{no-message} is non-@code{nil}, the message
is inhibited.

If @var{current-only} is non-@code{nil}, only the current buffer
is auto-saved.
@end deffn

@defun delete-auto-save-file-if-necessary
This function deletes the current buffer's auto-save file if
@code{delete-auto-save-files} is non-@code{nil}.  It is called every
time a buffer is saved.
@end defun

@defvar delete-auto-save-files
This variable is used by the function
@code{delete-auto-save-file-if-necessary}.  If it is non-@code{nil},
Emacs deletes auto-save files when a true save is done (in the visited
file).  This saves disk space and unclutters your directory.
@end defvar

@defun rename-auto-save-file
This function adjusts the current buffer's auto-save file name if the
visited file name has changed.  It also renames an existing auto-save
file.  If the visited file name has not changed, this function does
nothing.
@end defun

@defvar buffer-saved-size
The value of this buffer-local variable is the length of the current
buffer as of the last time it was read in, saved, or auto-saved.  This is
used to detect a substantial decrease in size, and turn off auto-saving
in response.

If it is -1, that means auto-saving is temporarily shut off in this
buffer due to a substantial deletion.  Explicitly saving the buffer
stores a positive value in this variable, thus reenabling auto-saving.
Turning auto-save mode off or on also alters this variable.
@end defvar

@defvar auto-save-list-file-name
This variable (if non-@code{nil}) specifies a file for recording the
names of all the auto-save files.  Each time Emacs does auto-saving, it
writes two lines into this file for each buffer that has auto-saving
enabled.  The first line gives the name of the visited file (it's empty
if the buffer has none), and the second gives the name of the auto-save
file.

If Emacs exits normally, it deletes this file.  If Emacs crashes, you
can look in the file to find all the auto-save files that might contain
work that was otherwise lost.  The @code{recover-session} command uses
these files.

The default name for this file is in your home directory and starts with
@samp{.saves-}.  It also contains the Emacs process @sc{id} and the host
name.
@end defvar

@node Reverting
@section Reverting

  If you have made extensive changes to a file and then change your mind
about them, you can get rid of them by reading in the previous version
of the file with the @code{revert-buffer} command.  @xref{Reverting, ,
Reverting a Buffer, emacs, The GNU Emacs Manual}.

@deffn Command revert-buffer &optional check-auto-save noconfirm
This command replaces the buffer text with the text of the visited
file on disk.  This action undoes all changes since the file was visited
or saved.

If the argument @var{check-auto-save} is non-@code{nil}, and the
latest auto-save file is more recent than the visited file,
@code{revert-buffer} asks the user whether to use that instead.
Otherwise, it always uses the text of the visited file itself.
Interactively, @var{check-auto-save} is set if there is a numeric prefix
argument.

Normally, @code{revert-buffer} asks for confirmation before it changes
the buffer; but if the argument @var{noconfirm} is non-@code{nil},
@code{revert-buffer} does not ask for confirmation.

Reverting tries to preserve marker positions in the buffer by using the
replacement feature of @code{insert-file-contents}.  If the buffer
contents and the file contents are identical before the revert
operation, reverting preserves all the markers.  If they are not
identical, reverting does change the buffer; then it preserves the
markers in the unchanged text (if any) at the beginning and end of the
buffer.  Preserving any additional markers would be problematical.
@end deffn

You can customize how @code{revert-buffer} does its work by setting
these variables---typically, as buffer-local variables.

@defvar revert-buffer-function
The value of this variable is the function to use to revert this buffer.
If non-@code{nil}, it is called as a function with no arguments to do
the work of reverting.  If the value is @code{nil}, reverting works the
usual way.

Modes such as Dired mode, in which the text being edited does not
consist of a file's contents but can be regenerated in some other
fashion, give this variable a buffer-local value that is a function to
regenerate the contents.
@end defvar

@defvar revert-buffer-insert-file-contents-function
The value of this variable, if non-@code{nil}, is the function to use to
insert the updated contents when reverting this buffer.  The function
receives two arguments: first the file name to use; second, @code{t} if
the user has asked to read the auto-save file.
@end defvar

@defvar before-revert-hook
This normal hook is run by @code{revert-buffer} before actually
inserting the modified contents---but only if
@code{revert-buffer-function} is @code{nil}.

Font Lock mode uses this hook to record that the buffer contents are no
longer fontified.
@end defvar

@defvar after-revert-hook
This normal hook is run by @code{revert-buffer} after actually inserting
the modified contents---but only if @code{revert-buffer-function} is
@code{nil}.

Font Lock mode uses this hook to recompute the fonts for the updated
buffer contents.
@end defvar