[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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.
26.1 Backup Files | How backup files are made; how their names are chosen. | |
26.2 Auto-Saving | How auto-save files are made; how their names are chosen. | |
26.3 Reverting | revert-buffer , and how to customize what it does.
|
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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.
26.1.1 Making Backup Files | How Emacs makes backup files, and when. | |
26.1.2 Backup by Renaming or by Copying? | Two alternatives: renaming the old file or copying it. | |
26.1.3 Making and Deleting Numbered Backup Files | Keeping multiple backups for each source file. | |
26.1.4 Naming Backup Files | How backup file names are computed; customization. |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This function makes a backup of the file visited by the current
buffer, if appropriate. It is called by save-buffer
before
saving the buffer the first time.
This buffer-local variable indicates whether this buffer’s file has
been backed up on account of this buffer. If it is non-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-all-local-variables
does not alter it.
This variable determines whether or not to make backup files. If it
is non-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 init file.)
(add-hook 'rmail-mode-hook (function (lambda () (make-local-variable 'make-backup-files) (setq make-backup-files nil)))) |
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
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 normal-backup-enable-predicate
, which checks
for files in temporary-file-directory
and
small-temporary-file-directory
.
If this variable is non-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.
This variable’s value is an alist of filename patterns and backup directory names. Each element looks like
(regexp . directory) |
Backups of files with names matching regexp will be made in directory. directory may be relative or absolute. If it is absolute, so that all matching files are backed up into the same directory, the file names in this directory will be the full name of the file backed up with all directory separators changed to ‘!’ to prevent clashes. This will not work correctly if your filesystem truncates the resulting name.
For the common case of all backups going into one directory, the alist should contain a single element pairing ‘"."’ with the appropriate directory name.
If this variable is nil
, or it fails to match a filename, the
backup is made in the original file’s directory.
On MS-DOS filesystems without long names this variable is always ignored.
This variable’s value is a function to use for making backups instead of
the default make-backup-file-name
. A value of nil gives the
default make-backup-file-name
behaviour.
This could be buffer-local to do something special for specific
files. If you define it, you may need to change
backup-file-name-p
and file-name-sans-versions
too.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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.
If this variable is non-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.
If this variable is non-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
.
If this variable is non-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
.
This variable, if non-nil
, specifies the same behavior as
backup-by-copying-when-mismatch
, but only for certain user-id
values: namely, those less than or equal to a certain number. You set
this variable to that number.
Thus, if you set backup-by-copying-when-privileged-mismatch
to 0, backup by copying is done for the superuser only,
when necessary to prevent a change in the owner of the file.
The default is 200.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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.
This variable controls whether to make a single non-numbered backup file or multiple numbered backups.
nil
Make numbered backups if the visited file already has numbered backups; otherwise, do not.
never
Do not make numbered backups.
Make numbered backups.
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.
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.
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.
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.
If this variable is t
, then saving a file deletes excess
backup versions silently. If it is nil
, that means
to ask for confirmation before deleting excess backups.
Otherwise, they are not deleted at all.
This variable specifies how many of the newest backup versions to keep
in the Dired command . (dired-clean-directory
). That’s the
same thing kept-new-versions
specifies when you make a new backup
file. The default value is 2.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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.
This function returns a non-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.
This function returns a string that is the name to use for a non-numbered backup file for file filename. On Unix, this is just filename with a tilde appended.
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..." (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.
This function computes the file name for a new backup file for
filename. It may also propose certain existing backup files for
deletion. 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~") |
This function returns the name of the most recent backup file for
filename, or 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.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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 Auto-Save: (emacs)Auto-Save 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.
This buffer-local variable is the name of the file used for
auto-saving the current buffer. It is nil
if the buffer
should not be auto-saved.
buffer-auto-save-file-name ⇒ "/xcssun/users/rms/lewis/#backups.texi#" |
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 arg, the command turns auto-saving
on if the value of arg is t
, a nonempty list, or a positive
integer. Otherwise, it turns auto-saving off.
This function returns a non-nil
value if filename is a
string that could be the name of an auto-save file. It assumes
the usual 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/#backups.texi#" (auto-save-file-name-p "#backups.texi#") ⇒ 0 (auto-save-file-name-p "backups.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.
This function returns the file name to use for auto-saving the current
buffer. This is just the file name with hash marks (‘#’) prepended
and appended to it. This function does not look at the variable
auto-save-visited-file-name
(described below); callers of this
function should check that variable first.
(make-auto-save-file-name) ⇒ "/xcssun/users/rms/lewis/#backups.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.." (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.
If this variable is non-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 new value does not take
effect in an existing buffer until the next time auto-save mode is
reenabled in it. If auto-save mode is already enabled, auto-saves
continue to go in the same file name until auto-save-mode
is
called again.
This function returns t
if the current buffer has been
auto-saved since the last time it was read in or 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 nil
.
The value of this variable specifies how often to do auto-saving, in terms of number of input events. Each time this many additional input events are read, Emacs does auto-saving for all buffers in which that is enabled.
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 does auto-saving for all buffers in which that is enabled. (If the current buffer is large, the specified timeout is multiplied by a factor that increases as the size increases; for a million-byte buffer, the factor is almost 4.)
If the value is zero or nil, then auto-saving is not done as a result
of idleness, only after a certain number of input events
as specified by auto-save-interval
.
This normal hook is run whenever an auto-save is about to happen.
If this variable is non-nil
, buffers that are visiting files
have auto-saving enabled by default. Otherwise, they do not.
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
‘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.
This function deletes the current buffer’s auto-save file if
delete-auto-save-files
is non-nil
. It is called every
time a buffer is saved.
This variable is used by the function
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.
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.
The value of this buffer-local variable is the length of the current buffer, when it was last 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 decrease in size. Explicitly saving the buffer stores a positive value in this variable, thus reenabling auto-saving. Turning auto-save mode off or on also updates this variable, so that the substantial decrease in size is forgotten.
This variable (if non-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.
When 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
this file to find them.
The default name for this file specifies your home directory and starts with ‘.saves-’. It also contains the Emacs process ID and the host name.
After Emacs reads your init file, it initializes
auto-save-list-file-name
(if you have not already set it
non-nil
) based on this prefix, adding the host name and process
ID. If you set this to nil
in your init file, then Emacs does
not initialize auto-save-list-file-name
.
[ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This document was generated by Yasutaka SHINDOH on April 18, 2010 using texi2html 1.82.