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.
A 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.
save-buffer before saving the buffer
the first time.
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;
kill-local-variables does not alter it.
nil,
then Emacs creates a backup of each file when it is saved for the
first time--provided that backup-inhibited is
nil (see below). The following example shows how to change the
make-backup-files variable only in the Rmail buffers
and not elsewhere. Setting it nil stops Emacs from
making backups of these files, which may save disk space. (You
would put this code in your `.emacs' file.)
(add-hook 'rmail-mode-hook
(function (lambda ()
(make-local-variable
'make-backup-files)
(setq make-backup-files nil))))
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:
(lambda (name)
(or (< (length name) 5)
(not (string-equal "/tmp/"
(substring name 0 5)))))
nil, backups are inhibited. It records the result
of testing 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-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 make-backup-files instead.
There are two ways that Emacs can make a backup file:
The first method, renaming, is the default.
The variable backup-by-copying, if
non-nil, says to use the second method, which is to
copy the original file and overwrite it with the new buffer
contents. The variable file-precious-flag, if
non-nil, also has this effect (as a sideline of its
main significance). See section Saving
Buffers.
nil, Emacs always makes backup files by
copying.
The following two variables, when non-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.
nil, Emacs makes backups by copying for files with
multiple names (hard links). This variable is significant only if
backup-by-copying is nil, since copying
is always used when that variable is non-nil.
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
backup-by-copying is nil, since copying
is always used when that variable is non-nil.
If a file's name is `foo', the names of its numbered backup versions are `foo.~v~', for various integers v, like this: `foo.~1~', `foo.~2~', `foo.~3~', ..., `foo.~259~', and so on.
nilneverThe 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.
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
find-backup-file-name (see section Naming Backup Files) is responsible
for determining which backup versions to delete, but does not
delete them itself.
nil, then saving a file deletes excess backup
versions silently. Otherwise, it asks the user whether to delete
them.
dired-clean-directory). That's the same
thing kept-new-versions specifies when you make a new
backup file. The default value is 2.
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.
nil value if filename is a possible
name for a backup file. A file with the name filename
need not exist; the function just checks the name.
(backup-file-name-p "foo")
=> nil
(backup-file-name-p "foo~")
=> 3
The standard definition of this function is as follows:
(defun backup-file-name-p (file) "Return non-nil if FILE is a backup file \ name (numeric or not)..." (string-match "~$" file))
Thus, the function returns a non-nil value if the
file name ends with a `~'. (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.
The standard definition of this function, on most operating systems, is as follows:
(defun make-backup-file-name (file)
"Create the non-numeric backup file name for FILE@enddots{}"
(concat file "~"))
You can change the backup-file naming convention by redefining
this function. The following example redefines
make-backup-file-name to prepend a `.' in
addition to appending a tilde:
(defun make-backup-file-name (filename)
(expand-file-name
(concat "." (file-name-nondirectory filename) "~")
(file-name-directory filename)))
(make-backup-file-name "backups.texi")
=> ".backups.texi~"
Some parts of Emacs, including some Dired commands, assume that backup file names end with `~'. If you do not follow that convention, it will not cause serious problems, but these commands may give less-than-desirable results.
find-backup-file-name returns a list whose CAR is the
name for the new backup file and whose CDR is a list of backup
files whose deletion is proposed. Two variables, kept-old-versions and
kept-new-versions, determine which backup versions
should be kept. This function keeps those versions by excluding
them from the CDR of the value. See section Making and Deleting Numbered Backup
Files.
In this example, the value says that `~rms/foo.~5~' is the name to use for the new backup file, and `~rms/foo.~3~' is an "excess" version that the caller should consider deleting now.
(find-backup-file-name "~rms/foo")
=> ("~rms/foo.~5~" "~rms/foo.~3~")
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.
Emacs periodically saves all files that you are visiting; this is called 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. See section `Auto-Saving: Protection Against Disasters' in 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.
nil if the buffer should not be auto-saved. buffer-auto-save-file-name => "/xcssun/users/rms/lewis/#files.texi#"
t, a nonempty list,
or a positive integer. Otherwise, it turns auto-saving off.
nil value if 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 (`#') is a possible auto-save
file name. The argument filename should not contain a
directory part.
(make-auto-save-file-name)
=> "/xcssun/users/rms/lewis/#files.texi#"
(auto-save-file-name-p "#files.texi#")
=> 0
(auto-save-file-name-p "files.texi")
=> nil
The standard definition of this function is as follows:
(defun auto-save-file-name-p (filename) "Return non-nil if FILENAME can be yielded by..." (string-match "^#.*#$" filename))
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
make-auto-save-file-name correspondingly.
auto-save-visited-file-name (described below); you
should check that before calling this function.
(make-auto-save-file-name)
=> "/xcssun/users/rms/lewis/#backup.texi#"
The standard definition of this function is as follows:
(defun make-auto-save-file-name ()
"Return file name to use for auto-saves \
of current buffer@enddots{}"
(if buffer-file-name
(concat
(file-name-directory buffer-file-name)
"#"
(file-name-nondirectory buffer-file-name)
"#")
(expand-file-name
(concat "#%" (buffer-name) "#"))))
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 auto-save-file-name-p in a corresponding
way.
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 nil, so
auto-save files have distinct names that are created by
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
auto-save-mode is called again.
t if the current buffer has been auto-saved since the
last time it was read in or saved.
nil.
nil, buffers that are visiting files have
auto-saving enabled by default. Otherwise, they do not.
Normally, if any buffers are auto-saved, a message that says
`Auto-saving...' is displayed in the echo area while
auto-saving is going on. However, if no-message is
non-nil, the message is inhibited.
If current-only is non-nil, only the
current buffer is auto-saved.
delete-auto-save-files is non-nil. It is
called every time a buffer is saved.
delete-auto-save-file-if-necessary. If it
is non-nil, Emacs deletes auto-save files when a true
save is done (in the visited file). This saves disk space and
unclutters your directory.
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.
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
recover-session command uses these files.
The default name for this file is in your home directory and starts with `.saves-'. It also contains the Emacs process ID and the host name.
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 revert-buffer
command. See section `Reverting a Buffer' in The GNU Emacs
Manual.
By default, if the latest auto-save file is more recent than the
visited file, revert-buffer asks the user whether to
use that instead. But if the argument ignore-auto is
non-nil, then only the the visited file itself is
used. Interactively, ignore-auto is t
unless there is a numeric prefix argument; thus, the interactive
default is to check the auto-save file.
Normally, revert-buffer asks for confirmation
before it changes the buffer; but if the argument
noconfirm is non-nil,
revert-buffer does not ask for confirmation.
Reverting tries to preserve marker positions in the buffer by
using the replacement feature of 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.
You can customize how revert-buffer does its work
by setting these variables--typically, as buffer-local
variables.
revert-buffer reverts the file
without asking the user for confirmation, if the file has changed
on disk and the buffer is not modified.
nil, it is called as a function with no arguments
to do the work of reverting. If the value is 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.
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, t
if the user has asked to read the auto-save file.
revert-buffer before actually inserting the modified
contents--but only if revert-buffer-function is
nil. Font Lock mode uses this hook to record that the buffer contents are no longer fontified.
revert-buffer after actually inserting the modified
contents--but only if revert-buffer-function is
nil. Font Lock mode uses this hook to recompute the fonts for the updated buffer contents.