@c -*-texinfo-*-
@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, Auto-Saving, Backups and Auto-Saving, Backups and Auto-Saving
@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, Rename or Copy, Backup Files, Backup Files
@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 backup files are enabled).
@end defvar

@defvar make-backup-files
  This variable determines whether or not backup files will be created.
If it is non-@code{nil}, then Emacs will create a backup of each file
when it is saved for the first time.

  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.)

@example
(setq rmail-mode-hook 
      (function (lambda ()
                  (make-local-variable 'make-backup-files)
                  (setq make-backup-files nil)))
@end example
@end defvar

@node Rename or Copy, Numbered Backups, Making Backups, Backup Files
@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.  In this case, any
other names (i.e., hard links) of the original file will now refer to
the backup file.  The new file will be owned by the user doing the
editing, and its group will be the default for the user or the
directory.

@item
Emacs can copy the original file into a backup file, and then overwrite
the original file with new contents.  In this case, any other names
(i.e., hard links) of the original file will 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}.

  The variables @code{backup-by-copying-when-linked} and
@code{backup-by-copying-when-mismatch}, if 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
  This variable controls whether to make backup files by copying.  If it
is non-@code{nil}, then Emacs always copies the current contents of the
file into the backup file before writing the buffer to be saved to the
file.  (In many circumstances, this has the same effect as
@code{file-precious-flag}.)
@end defvar

@defvar backup-by-copying-when-linked
  This variable controls whether to make backups by copying for files
with multiple names (hard links).  If it is non-@code{nil}, then Emacs
will use copying to create backups for those files.

  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
  This variable controls whether to make backups by copying when
renaming would cause either the owner or the group of the file to
change.  If it is non-@code{nil} then Emacs will create backups by
copying in such cases.

  The value has no effect when renaming would not result in changing 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, Backup Names, Rename or Copy, Backup Files
@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}
Do 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.

@defopt kept-new-versions
  The value of this variable is the number of oldest 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

@defopt dired-kept-versions
  This variable plays a role in Dired's @code{dired-clean-directory}
(@kbd{.}) command like that played by @code{kept-old-versions} when a
backup file 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 will be
kept as old versions and those numbered 5 and 7 will be kept as new
versions; backup version 3 will be deleted.  The function
@code{find-backup-file-name} 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 excess backup versions are
deleted silently.  Otherwise, the user is asked whether to delete them.
@end defopt

@node Backup Names, , Numbered Backups, Backup Files
@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.

@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.

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

The standard definition of this function is as follows:

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

@noindent
Thus, the function returns a non-@code{nil} value if the file name ends
with a @samp{~}

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 which 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:

@example
(defun make-backup-file-name (file)
  "Create the non-numeric backup file name for FILE..."
  (concat file "~"))
@end example

You can change the backup file naming convention by redefining this
function.  In the following example, @code{make-backup-file-name} is
redefined to prepend a @samp{.} as well as to append a tilde.

@example
(defun make-backup-file-name (filename)
  (concat "." filename "~"))

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

If you do redefine @code{make-backup-file-name}, be sure to redefine
@code{backup-file-name-p} and @code{find-backup-file-name} as well.
@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 called @code{kept-old-versions} and
@code{kept-new-versions} determine which old backup versions will be
kept (by excluding them from the list of backup files ripe for
deletion).  @xref{Numbered Backups}.

  In this example, @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.

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

@node Auto-Saving, Reverting, Backup Files, Backups and 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.  @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
buffer-auto-save-file-name
=> "/xcssun/users/rms/lewis/#files.texi#"
@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
(make-auto-save-file-name)
     @result{} "/xcssun/users/rms/lewis/#files.texi#"
(auto-save-file-name-p "#files.texi#")
     @result{} 0
(auto-save-file-name-p "files.texi")
     @result{} nil
@end example

  The standard definition of this function is as follows:

@example
(defun auto-save-file-name-p (filename)
  "Return non-nil if FILENAME can be yielded by..."
  (string-match "^#.*#$" filename))
@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 @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}; that should be checked before this
function is called.

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

  The standard definition of this function is as follows:

@example
(defun make-auto-save-file-name ()
  "Return file name to use for auto-saves of current buffer..."
  (if buffer-file-name
      (concat (file-name-directory buffer-file-name)
              "#"
              (file-name-nondirectory buffer-file-name)
              "#")
    (expand-file-name (concat "#%" (buffer-name) "#"))))
@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 will auto-save buffers in
the files they are visiting.  That is, the auto-save is done in the same
file which 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-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
  This function auto-saves all buffers that need to be auto-saved.
This is all buffers for which auto-saving is enabled and that have
been changed since the last time they were auto-saved.

  Normally, if any buffers are auto-saved, a message
@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.
@end deffn

@defun delete-auto-save-file-if-necessary
  This function deletes the auto-save file for the current buffer if
variable @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 will delete auto-save files when a true save is done (in the
visited file).  This saves on 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

@node Reverting,  , Auto-Saving, Backups and Auto-Saving
@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 no-auto-save-offer-p 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.

  When the value of the @var{no-auto-save-offer-p} argument is
@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 latest backup file.  This
argument is the numeric prefix argument when the function is called
interactively.

  When the value of the @var{noconfirm} argument is non-@code{nil},
@code{revert-buffer} does not ask for confirmation for the reversion
action.  This means that the buffer contents are deleted and replaced by
the text from the file on the disk, with no further opportunities for
the user to prevent it.

  Since reverting works by deleting the entire text of the buffer and
inserting the file contents, all the buffer's markers are relocated to
point at the beginning of the buffer.  This is not ``correct'', but
then, there is no way to determine what would be correct.  It is not
possible to determine, from the text before and after, which characters
after reversion correspond to which characters before.

  If the value of the @code{revert-buffer-function} variable is
non-@code{nil}, it is called as a function with no arguments to do the
work.
@end deffn

@defvar revert-buffer-function
  The value of this variable is the function to use to revert this
buffer; but if the value of this variable is @code{nil}, then the
@code{revert-buffer} function carries out its default action.  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

@deffn Command recover-file filename
  This function visits @var{filename}, but gets the contents from its
last auto-save file.  This is useful after the system has crashed, to
resume editing the same file without losing all the work done in the
previous session.

  An error is signaled if there is no auto-save file for @var{filename},
or if @var{filename} is newer than its auto-save file.  If
@var{filename} does not exist, but its auto-save file does, then the
auto-save file is read as usual.  This last situation may occur if you
visited a nonexistent file and never actually saved it.
@end deffn

