This is ../info/emacs, produced by makeinfo version 4.3 from emacs.texi. This is the Fourteenth edition of the `GNU Emacs Manual', updated for Emacs version 21.3. INFO-DIR-SECTION Emacs START-INFO-DIR-ENTRY * Emacs: (emacs). The extensible self-documenting text editor. END-INFO-DIR-ENTRY Published by the Free Software Foundation 59 Temple Place, Suite 330 Boston, MA 02111-1307 USA Copyright (C) 1985,1986,1987,1993,1994,1995,1996,1997,1998,1999,2000,2001,2002 Free Software Foundation, Inc. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with the Invariant Sections being "The GNU Manifesto", "Distribution" and "GNU GENERAL PUBLIC LICENSE", with the Front-Cover texts being "A GNU Manual," and with the Back-Cover Texts as in (a) below. A copy of the license is included in the section entitled "GNU Free Documentation License." (a) The FSF's Back-Cover Text is: "You have freedom to copy and modify this GNU Manual, like GNU software. Copies published by the Free Software Foundation raise funds for GNU development."  File: emacs, Node: Spelling, Prev: Fixing Case, Up: Fixit Checking and Correcting Spelling ================================ This section describes the commands to check the spelling of a single word or of a portion of a buffer. These commands work with the spelling checker program Ispell, which is not part of Emacs. *Note Ispell: (ispell.info)Top. `M-x flyspell-mode' Enable Flyspell mode, which highlights all misspelled words. `M-$' Check and correct spelling of the word at point (`ispell-word'). `M-' Complete the word before point based on the spelling dictionary (`ispell-complete-word'). `M-x ispell' Spell-check the active region or the current buffer. `M-x ispell-buffer' Check and correct spelling of each word in the buffer. `M-x ispell-region' Check and correct spelling of each word in the region. `M-x ispell-message' Check and correct spelling of each word in a draft mail message, excluding cited material. `M-x ispell-change-dictionary DICT ' Restart the Ispell process, using DICT as the dictionary. `M-x ispell-kill-ispell' Kill the Ispell subprocess. Flyspell mode is a fully-automatic way to check spelling as you edit in Emacs. It operates by checking words as you change or insert them. When it finds a word that it does not recognize, it highlights that word. This does not interfere with your editing, but when you see the highlighted word, you can move to it and fix it. Type `M-x flyspell-mode' to enable or disable this mode in the current buffer. When Flyspell mode highlights a word as misspelled, you can click on it with `Mouse-2' to display a menu of possible corrections and actions. You can also correct the word by editing it manually in any way you like. The other Emacs spell-checking features check or look up words when you give an explicit command to do so. Checking all or part of the buffer is useful when you have text that was written outside of this Emacs session and might contain any number of misspellings. To check the spelling of the word around or next to point, and optionally correct it as well, use the command `M-$' (`ispell-word'). If the word is not correct, the command offers you various alternatives for what to do about it. To check the entire current buffer, use `M-x ispell-buffer'. Use `M-x ispell-region' to check just the current region. To check spelling in an email message you are writing, use `M-x ispell-message'; that command checks the whole buffer, except for material that is indented or appears to be cited from other messages. The `M-x ispell' command spell-checks the active region if the Transient Mark mode is on (*note Transient Mark::), otherwise it spell-checks the current buffer. Each time these commands encounter an incorrect word, they ask you what to do. They display a list of alternatives, usually including several "near-misses"--words that are close to the word being checked. Then you must type a single-character response. Here are the valid responses: `' Skip this word--continue to consider it incorrect, but don't change it here. `r NEW ' Replace the word (just this time) with NEW. `R NEW ' Replace the word with NEW, and do a `query-replace' so you can replace it elsewhere in the buffer if you wish. `DIGIT' Replace the word (just this time) with one of the displayed near-misses. Each near-miss is listed with a digit; type that digit to select it. `a' Accept the incorrect word--treat it as correct, but only in this editing session. `A' Accept the incorrect word--treat it as correct, but only in this editing session and for this buffer. `i' Insert this word in your private dictionary file so that Ispell will consider it correct from now on, even in future sessions. `u' Insert the lower-case version of this word in your private dictionary file. `m' Like `i', but you can also specify dictionary completion information. `l WORD ' Look in the dictionary for words that match WORD. These words become the new list of "near-misses"; you can select one of them as the replacement by typing a digit. You can use `*' in WORD as a wildcard. `C-g' Quit interactive spell checking. You can restart it again afterward with `C-u M-$'. `X' Same as `C-g'. `x' Quit interactive spell checking and move point back to where it was when you started spell checking. `q' Quit interactive spell checking and kill the Ispell subprocess. `C-l' Refresh the screen. `C-z' This key has its normal command meaning (suspend Emacs or iconify this frame). The command `ispell-complete-word', which is bound to the key `M-' in Text mode and related modes, shows a list of completions based on spelling correction. Insert the beginning of a word, and then type `M-'; the command displays a completion list window. To choose one of the completions listed, click `Mouse-2' on it, or move the cursor there in the completions window and type . *Note Text Mode::. Once started, the Ispell subprocess continues to run (waiting for something to do), so that subsequent spell checking commands complete more quickly. If you want to get rid of the Ispell process, use `M-x ispell-kill-ispell'. This is not usually necessary, since the process uses no time except when you do spelling correction. Ispell uses two dictionaries: the standard dictionary and your private dictionary. The variable `ispell-dictionary' specifies the file name of the standard dictionary to use. A value of `nil' says to use the default dictionary. The command `M-x ispell-change-dictionary' sets this variable and then restarts the Ispell subprocess, so that it will use a different dictionary. The dictionary used by `ispell-complete-word' can be customized separately by setting the value of the variable `ispell-complete-word-dict'.  File: emacs, Node: Files, Next: Buffers, Prev: Fixit, Up: Top File Handling ************* The operating system stores data permanently in named "files", so most of the text you edit with Emacs comes from a file and is ultimately stored in a file. To edit a file, you must tell Emacs to read the file and prepare a buffer containing a copy of the file's text. This is called "visiting" the file. Editing commands apply directly to text in the buffer; that is, to the copy inside Emacs. Your changes appear in the file itself only when you "save" the buffer back into the file. In addition to visiting and saving files, Emacs can delete, copy, rename, and append to files, keep multiple versions of them, and operate on file directories. * Menu: * File Names:: How to type and edit file-name arguments. * Visiting:: Visiting a file prepares Emacs to edit the file. * Saving:: Saving makes your changes permanent. * Reverting:: Reverting cancels all the changes not saved. * Auto Save:: Auto Save periodically protects against loss of data. * File Aliases:: Handling multiple names for one file. * Version Control:: Version control systems (RCS, CVS and SCCS). * Directories:: Creating, deleting, and listing file directories. * Comparing Files:: Finding where two files differ. * Misc File Ops:: Other things you can do on files. * Compressed Files:: Accessing compressed files. * File Archives:: Operating on tar, zip, jar etc. archive files. * Remote Files:: Accessing files on other sites. * Quoted File Names:: Quoting special characters in file names. * File Name Cache:: Completion against a list of files you often use. * File Conveniences:: Convenience Features for Finding Files.  File: emacs, Node: File Names, Next: Visiting, Up: Files File Names ========== Most Emacs commands that operate on a file require you to specify the file name. (Saving and reverting are exceptions; the buffer knows which file name to use for them.) You enter the file name using the minibuffer (*note Minibuffer::). "Completion" is available (*note Completion::) to make it easier to specify long file names. When completing file names, Emacs ignores those whose file-name extensions appear in the variable `completion-ignored-extensions'; see *Note Completion Options::. For most operations, there is a "default file name" which is used if you type just to enter an empty argument. Normally the default file name is the name of the file visited in the current buffer; this makes it easy to operate on that file with any of the Emacs file commands. Each buffer has a default directory which is normally the same as the directory of the file visited in that buffer. When you enter a file name without a directory, the default directory is used. If you specify a directory in a relative fashion, with a name that does not start with a slash, it is interpreted with respect to the default directory. The default directory is kept in the variable `default-directory', which has a separate value in every buffer. For example, if the default file name is `/u/rms/gnu/gnu.tasks' then the default directory is `/u/rms/gnu/'. If you type just `foo', which does not specify a directory, it is short for `/u/rms/gnu/foo'. `../.login' would stand for `/u/rms/.login'. `new/foo' would stand for the file name `/u/rms/gnu/new/foo'. The command `M-x pwd' displays the current buffer's default directory, and the command `M-x cd' sets it (to a value read using the minibuffer). A buffer's default directory changes only when the `cd' command is used. A file-visiting buffer's default directory is initialized to the directory of the file that is visited in that buffer. If you create a buffer with `C-x b', its default directory is copied from that of the buffer that was current at the time. The default directory actually appears in the minibuffer when the minibuffer becomes active to read a file name. This serves two purposes: it _shows_ you what the default is, so that you can type a relative file name and know with certainty what it will mean, and it allows you to _edit_ the default to specify a different directory. This insertion of the default directory is inhibited if the variable `insert-default-directory' is set to `nil'. Note that it is legitimate to type an absolute file name after you enter the minibuffer, ignoring the presence of the default directory name as part of the text. The final minibuffer contents may look invalid, but that is not so. For example, if the minibuffer starts out with `/usr/tmp/' and you add `/x1/rms/foo', you get `/usr/tmp//x1/rms/foo'; but Emacs ignores everything through the first slash in the double slash; the result is `/x1/rms/foo'. *Note Minibuffer File::. `$' in a file name is used to substitute environment variables. For example, if you have used the shell command `export FOO=rms/hacks' to set up an environment variable named `FOO', then you can use `/u/$FOO/test.c' or `/u/${FOO}/test.c' as an abbreviation for `/u/rms/hacks/test.c'. The environment variable name consists of all the alphanumeric characters after the `$'; alternatively, it may be enclosed in braces after the `$'. Note that shell commands to set environment variables affect Emacs only if done before Emacs is started. You can use the `~/' in a file name to mean your home directory, or `~USER-ID/' to mean the home directory of a user whose login name is `user-id'. (On DOS and Windows systems, where a user doesn't have a home directory, Emacs substitutes `~/' with the value of the environment variable `HOME'; see *Note General Variables::.) To access a file with `$' in its name, type `$$'. This pair is converted to a single `$' at the same time as variable substitution is performed for a single `$'. Alternatively, quote the whole file name with `/:' (*note Quoted File Names::). File names which begin with a literal `~' should also be quoted with `/:'. The Lisp function that performs the substitution is called `substitute-in-file-name'. The substitution is performed only on file names read as such using the minibuffer. You can include non-ASCII characters in file names if you set the variable `file-name-coding-system' to a non-`nil' value. *Note Specify Coding::.  File: emacs, Node: Visiting, Next: Saving, Prev: File Names, Up: Files Visiting Files ============== `C-x C-f' Visit a file (`find-file'). `C-x C-r' Visit a file for viewing, without allowing changes to it (`find-file-read-only'). `C-x C-v' Visit a different file instead of the one visited last (`find-alternate-file'). `C-x 4 f' Visit a file, in another window (`find-file-other-window'). Don't alter what is displayed in the selected window. `C-x 5 f' Visit a file, in a new frame (`find-file-other-frame'). Don't alter what is displayed in the selected frame. `M-x find-file-literally' Visit a file with no conversion of the contents. "Visiting" a file means copying its contents into an Emacs buffer so you can edit them. Emacs makes a new buffer for each file that you visit. We often say that this buffer "is visiting" that file, or that the buffer's "visited file" is that file. Emacs constructs the buffer name from the file name by throwing away the directory, keeping just the name proper. For example, a file named `/usr/rms/emacs.tex' would get a buffer named `emacs.tex'. If there is already a buffer with that name, Emacs constructs a unique name--the normal method is to append `<2>', `<3>', and so on, but you can select other methods (*note Uniquify::). Each window's mode line shows the name of the buffer that is being displayed in that window, so you can always tell what buffer you are editing. The changes you make with editing commands are made in the Emacs buffer. They do not take effect in the file that you visited, or any place permanent, until you "save" the buffer. Saving the buffer means that Emacs writes the current contents of the buffer into its visited file. *Note Saving::. If a buffer contains changes that have not been saved, we say the buffer is "modified". This is important because it implies that some changes will be lost if the buffer is not saved. The mode line displays two stars near the left margin to indicate that the buffer is modified. To visit a file, use the command `C-x C-f' (`find-file'). Follow the command with the name of the file you wish to visit, terminated by a . The file name is read using the minibuffer (*note Minibuffer::), with defaulting and completion in the standard manner (*note File Names::). While in the minibuffer, you can abort `C-x C-f' by typing `C-g'. File-name completion ignores certain filenames; for more about this, see *Note Completion Options::. When Emacs is built with a suitable GUI toolkit, it pops up the standard File Selection dialog of that toolkit instead of prompting for the file name in the minibuffer. On Unix and GNU/Linux platforms, Emacs does that when built with LessTif and Motif toolkits; on MS-Windows, the GUI version does that by default. Your confirmation that `C-x C-f' has completed successfully is the appearance of new text on the screen and a new buffer name in the mode line. If the specified file does not exist and could not be created, or cannot be read, then you get an error, with an error message displayed in the echo area. If you visit a file that is already in Emacs, `C-x C-f' does not make another copy. It selects the existing buffer containing that file. However, before doing so, it checks that the file itself has not changed since you visited or saved it last. If the file has changed, a warning message is shown. *Note Simultaneous Editing: Interlocking. Since Emacs reads the visited file in its entirety, files whose size is larger than the maximum Emacs buffer size (*note Buffers::) cannot be visited; if you try, Emacs will display an error message saying that the maximum buffer size has been exceeded. What if you want to create a new file? Just visit it. Emacs displays `(New file)' in the echo area, but in other respects behaves as if you had visited an existing empty file. If you make any changes and save them, the file is created. Emacs recognizes from the contents of a file which convention it uses to separate lines--newline (used on GNU/Linux and on Unix), carriage-return linefeed (used on Microsoft systems), or just carriage-return (used on the Macintosh)--and automatically converts the contents to the normal Emacs convention, which is that the newline character separates lines. This is a part of the general feature of coding system conversion (*note Coding Systems::), and makes it possible to edit files imported from different operating systems with equal convenience. If you change the text and save the file, Emacs performs the inverse conversion, changing newlines back into carriage-return linefeed or just carriage-return if appropriate. If the file you specify is actually a directory, `C-x C-f' invokes Dired, the Emacs directory browser, so that you can "edit" the contents of the directory (*note Dired::). Dired is a convenient way to delete, look at, or operate on the files in the directory. However, if the variable `find-file-run-dired' is `nil', then it is an error to try to visit a directory. Files which are actually collections of other files, or "file archives", are visited in special modes which invoke a Dired-like environment to allow operations on archive members. *Note File Archives::, for more about these features. If the file name you specify contains shell-style wildcard characters, Emacs visits all the files that match it. Wildcards include `?', `*', and `[...]' sequences. *Note Quoted File Names::, for information on how to visit a file whose name actually contains wildcard characters. You can disable the wildcard feature by customizing `find-file-wildcards'. If you visit a file that the operating system won't let you modify, Emacs makes the buffer read-only, so that you won't go ahead and make changes that you'll have trouble saving afterward. You can make the buffer writable with `C-x C-q' (`vc-toggle-read-only'). *Note Misc Buffer::. Occasionally you might want to visit a file as read-only in order to protect yourself from entering changes accidentally; do so by visiting the file with the command `C-x C-r' (`find-file-read-only'). If you visit a nonexistent file unintentionally (because you typed the wrong file name), use the `C-x C-v' command (`find-alternate-file') to visit the file you really wanted. `C-x C-v' is similar to `C-x C-f', but it kills the current buffer (after first offering to save it if it is modified). When `C-x C-v' reads the file name to visit, it inserts the entire default file name in the buffer, with point just after the directory part; this is convenient if you made a slight error in typing the name. If you find a file which exists but cannot be read, `C-x C-f' signals an error. `C-x 4 f' (`find-file-other-window') is like `C-x C-f' except that the buffer containing the specified file is selected in another window. The window that was selected before `C-x 4 f' continues to show the same buffer it was already showing. If this command is used when only one window is being displayed, that window is split in two, with one window showing the same buffer as before, and the other one showing the newly requested file. *Note Windows::. `C-x 5 f' (`find-file-other-frame') is similar, but opens a new frame, or makes visible any existing frame showing the file you seek. This feature is available only when you are using a window system. *Note Frames::. If you wish to edit a file as a sequence of ASCII characters with no special encoding or conversion, use the `M-x find-file-literally' command. It visits a file, like `C-x C-f', but does not do format conversion (*note Formatted Text::), character code conversion (*note Coding Systems::), or automatic uncompression (*note Compressed Files::), and does not add a final newline because of `require-final-newline'. If you already have visited the same file in the usual (non-literal) manner, this command asks you whether to visit it literally instead. Two special hook variables allow extensions to modify the operation of visiting files. Visiting a file that does not exist runs the functions in the list `find-file-not-found-hooks'; this variable holds a list of functions, and the functions are called one by one (with no arguments) until one of them returns non-`nil'. This is not a normal hook, and the name ends in `-hooks' rather than `-hook' to indicate that fact. Successful visiting of any file, whether existing or not, calls the functions in the list `find-file-hooks', with no arguments. This variable is really a normal hook, but it has an abnormal name for historical compatibility. In the case of a nonexistent file, the `find-file-not-found-hooks' are run first. *Note Hooks::. There are several ways to specify automatically the major mode for editing the file (*note Choosing Modes::), and to specify local variables defined for that file (*note File Variables::).  File: emacs, Node: Saving, Next: Reverting, Prev: Visiting, Up: Files Saving Files ============ "Saving" a buffer in Emacs means writing its contents back into the file that was visited in the buffer. `C-x C-s' Save the current buffer in its visited file on disk (`save-buffer'). `C-x s' Save any or all buffers in their visited files (`save-some-buffers'). `M-~' Forget that the current buffer has been changed (`not-modified'). With prefix argument (`C-u'), mark the current buffer as changed. `C-x C-w' Save the current buffer as a specified file name (`write-file'). `M-x set-visited-file-name' Change the file name under which the current buffer will be saved. When you wish to save the file and make your changes permanent, type `C-x C-s' (`save-buffer'). After saving is finished, `C-x C-s' displays a message like this: Wrote /u/rms/gnu/gnu.tasks If the selected buffer is not modified (no changes have been made in it since the buffer was created or last saved), saving is not really done, because it would have no effect. Instead, `C-x C-s' displays a message like this in the echo area: (No changes need to be saved) The command `C-x s' (`save-some-buffers') offers to save any or all modified buffers. It asks you what to do with each buffer. The possible responses are analogous to those of `query-replace': `y' Save this buffer and ask about the rest of the buffers. `n' Don't save this buffer, but ask about the rest of the buffers. `!' Save this buffer and all the rest with no more questions. `' Terminate `save-some-buffers' without any more saving. `.' Save this buffer, then exit `save-some-buffers' without even asking about other buffers. `C-r' View the buffer that you are currently being asked about. When you exit View mode, you get back to `save-some-buffers', which asks the question again. `C-h' Display a help message about these options. `C-x C-c', the key sequence to exit Emacs, invokes `save-some-buffers' and therefore asks the same questions. If you have changed a buffer but you do not want to save the changes, you should take some action to prevent it. Otherwise, each time you use `C-x s' or `C-x C-c', you are liable to save this buffer by mistake. One thing you can do is type `M-~' (`not-modified'), which clears out the indication that the buffer is modified. If you do this, none of the save commands will believe that the buffer needs to be saved. (`~' is often used as a mathematical symbol for `not'; thus `M-~' is `not', metafied.) You could also use `set-visited-file-name' (see below) to mark the buffer as visiting a different file name, one which is not in use for anything important. Alternatively, you can cancel all the changes made since the file was visited or saved, by reading the text from the file again. This is called "reverting". *Note Reverting::. You could also undo all the changes by repeating the undo command `C-x u' until you have undone all the changes; but reverting is easier. `M-x set-visited-file-name' alters the name of the file that the current buffer is visiting. It reads the new file name using the minibuffer. Then it marks the buffer as visiting that file name, and changes the buffer name correspondingly. `set-visited-file-name' does not save the buffer in the newly visited file; it just alters the records inside Emacs in case you do save later. It also marks the buffer as "modified" so that `C-x C-s' in that buffer _will_ save. If you wish to mark the buffer as visiting a different file and save it right away, use `C-x C-w' (`write-file'). It is precisely equivalent to `set-visited-file-name' followed by `C-x C-s'. `C-x C-s' used on a buffer that is not visiting a file has the same effect as `C-x C-w'; that is, it reads a file name, marks the buffer as visiting that file, and saves it there. The default file name in a buffer that is not visiting a file is made by combining the buffer name with the buffer's default directory (*note File Names::). If the new file name implies a major mode, then `C-x C-w' switches to that major mode, in most cases. The command `set-visited-file-name' also does this. *Note Choosing Modes::. If Emacs is about to save a file and sees that the date of the latest version on disk does not match what Emacs last read or wrote, Emacs notifies you of this fact, because it probably indicates a problem caused by simultaneous editing and requires your immediate attention. *Note Simultaneous Editing: Interlocking. If the value of the variable `require-final-newline' is `t', Emacs silently puts a newline at the end of any file that doesn't already end in one, every time a file is saved or written. If the value is `nil', Emacs leaves the end of the file unchanged; if it's neither `nil' nor `t', Emacs asks you whether to add a newline. The default is `nil'. * Menu: * Backup:: How Emacs saves the old version of your file. * Interlocking:: How Emacs protects against simultaneous editing of one file by two users. * Shadowing: File Shadowing. Copying files to "shadows" automatically. * Time Stamps:: Emacs can update time stamps on saved files.  File: emacs, Node: Backup, Next: Interlocking, Up: Saving Backup Files ------------ On most operating systems, rewriting a file automatically destroys all record of what the file used to contain. Thus, saving a file from Emacs throws away the old contents of the file--or it would, except that Emacs carefully copies the old contents to another file, called the "backup" file, before actually saving. For most files, the variable `make-backup-files' determines whether to make backup files. On most operating systems, its default value is `t', so that Emacs does write backup files. For files managed by a version control system (*note Version Control::), the variable `vc-make-backup-files' determines whether to make backup files. By default it is `nil', since backup files are redundant when you store all the previous versions in a version control system. *Note General VC Options::. The default value of the `backup-enable-predicate' variable prevents backup files being written for files in the directories used for temporary files, specified by `temporary-file-directory' or `small-temporary-file-directory'. At your option, Emacs can keep either a single backup file or a series of numbered backup files for each file that you edit. Emacs makes a backup for a file only the first time the file is saved from one buffer. No matter how many times you save a file, its backup file continues to contain the contents from before the file was visited. Normally this means that the backup file contains the contents from before the current editing session; however, if you kill the buffer and then visit the file again, a new backup file will be made by the next save. You can also explicitly request making another backup file from a buffer even though it has already been saved at least once. If you save the buffer with `C-u C-x C-s', the version thus saved will be made into a backup file if you save the buffer again. `C-u C-u C-x C-s' saves the buffer, but first makes the previous file contents into a new backup file. `C-u C-u C-u C-x C-s' does both things: it makes a backup from the previous contents, and arranges to make another from the newly saved contents if you save again. * Menu: * Names: Backup Names. How backup files are named; choosing single or numbered backup files. * Deletion: Backup Deletion. Emacs deletes excess numbered backups. * Copying: Backup Copying. Backups can be made by copying or renaming.  File: emacs, Node: Backup Names, Next: Backup Deletion, Up: Backup Single or Numbered Backups .......................... If you choose to have a single backup file (this is the default), the backup file's name is normally constructed by appending `~' to the file name being edited; thus, the backup file for `eval.c' would be `eval.c~'. You can change this behavior by defining the variable `make-backup-file-name-function' to a suitable function. Alternatively you can customize the variable `backup-directory-alist' to specify that files matching certain patterns should be backed up in specific directories. A typical use is to add an element `("." . DIR)' to make all backups in the directory with absolute name DIR; Emacs modifies the backup file names to avoid clashes between files with the same names originating in different directories. Alternatively, adding, say, `("." . ".~")' would make backups in the invisible subdirectory `.~' of the original file's directory. Emacs creates the directory, if necessary, to make the backup. If access control stops Emacs from writing backup files under the usual names, it writes the backup file as `%backup%~' in your home directory. Only one such file can exist, so only the most recently made such backup is available. If you choose to have a series of numbered backup files, backup file names contain `.~', the number, and another `~' after the original file name. Thus, the backup files of `eval.c' would be called `eval.c.~1~', `eval.c.~2~', and so on, all the way through names like `eval.c.~259~' and beyond. The variable `backup-directory-alist' applies to numbered backups just as usual. The choice of single backup or numbered backups is controlled by the variable `version-control'. Its possible values are `t' Make numbered backups. `nil' Make numbered backups for files that have numbered backups already. Otherwise, make single backups. `never' Never make numbered backups; always make single backups. You can set `version-control' locally in an individual buffer to control the making of backups for that buffer's file. For example, Rmail mode locally sets `version-control' to `never' to make sure that there is only one backup for an Rmail file. *Note Locals::. If you set the environment variable `VERSION_CONTROL', to tell various GNU utilities what to do with backup files, Emacs also obeys the environment variable by setting the Lisp variable `version-control' accordingly at startup. If the environment variable's value is `t' or `numbered', then `version-control' becomes `t'; if the value is `nil' or `existing', then `version-control' becomes `nil'; if it is `never' or `simple', then `version-control' becomes `never'.  File: emacs, Node: Backup Deletion, Next: Backup Copying, Prev: Backup Names, Up: Backup Automatic Deletion of Backups ............................. To prevent excessive consumption of disk space, Emacs can delete numbered backup versions automatically. Generally Emacs keeps the first few backups and the latest few backups, deleting any in between. This happens every time a new backup is made. The two variables `kept-old-versions' and `kept-new-versions' control this deletion. Their values are, respectively, the number of oldest (lowest-numbered) backups to keep and the number of newest (highest-numbered) ones to keep, each time a new backup is made. The backups in the middle (excluding those oldest and newest) are the excess middle versions--those backups are deleted. These variables' values are used when it is time to delete excess versions, just after a new backup version is made; the newly made backup is included in the count in `kept-new-versions'. By default, both variables are 2. If `delete-old-versions' is non-`nil', Emacs deletes the excess backup files silently. If it is `nil', the default, Emacs asks you whether it should delete the excess backup versions. Dired's `.' (Period) command can also be used to delete old versions. *Note Dired Deletion::.  File: emacs, Node: Backup Copying, Prev: Backup Deletion, Up: Backup Copying vs. Renaming .................... Backup files can be made by copying the old file or by renaming it. This makes a difference when the old file has multiple names (hard links). If the old file is renamed into the backup file, then the alternate names become names for the backup file. If the old file is copied instead, then the alternate names remain names for the file that you are editing, and the contents accessed by those names will be the new contents. The method of making a backup file may also affect the file's owner and group. If copying is used, these do not change. If renaming is used, you become the file's owner, and the file's group becomes the default (different operating systems have different defaults for the group). Having the owner change is usually a good idea, because then the owner always shows who last edited the file. Also, the owners of the backups show who produced those versions. Occasionally there is a file whose owner should not change; it is a good idea for such files to contain local variable lists to set `backup-by-copying-when-mismatch' locally (*note File Variables::). The choice of renaming or copying is controlled by four variables. Renaming is the default choice. If the variable `backup-by-copying' is non-`nil', copying is used. Otherwise, if the variable `backup-by-copying-when-linked' is non-`nil', then copying is used for files that have multiple names, but renaming may still be used when the file being edited has only one name. If the variable `backup-by-copying-when-mismatch' is non-`nil', then copying is used if renaming would cause the file's owner or group to change. `backup-by-copying-when-mismatch' is `t' by default if you start Emacs as the superuser. The fourth variable, `backup-by-copying-when-privileged-mismatch', gives the highest numeric user-id for which `backup-by-copying-when-mismatch' will be forced on. This is useful when low-numbered user-ids are assigned to special system users, such as `root', `bin', `daemon', etc., which must maintain ownership of files. When a file is managed with a version control system (*note Version Control::), Emacs does not normally make backups in the usual way for that file. But check-in and check-out are similar in some ways to making backups. One unfortunate similarity is that these operations typically break hard links, disconnecting the file name you visited from any alternate names for the same file. This has nothing to do with Emacs--the version control system does it.  File: emacs, Node: Interlocking, Next: File Shadowing, Prev: Backup, Up: Saving Protection against Simultaneous Editing --------------------------------------- Simultaneous editing occurs when two users visit the same file, both make changes, and then both save them. If nobody were informed that this was happening, whichever user saved first would later find that his changes were lost. On some systems, Emacs notices immediately when the second user starts to change the file, and issues an immediate warning. On all systems, Emacs checks when you save the file, and warns if you are about to overwrite another user's changes. You can prevent loss of the other user's work by taking the proper corrective action instead of saving the file. When you make the first modification in an Emacs buffer that is visiting a file, Emacs records that the file is "locked" by you. (It does this by creating a symbolic link in the same directory with a different name.) Emacs removes the lock when you save the changes. The idea is that the file is locked whenever an Emacs buffer visiting it has unsaved changes. If you begin to modify the buffer while the visited file is locked by someone else, this constitutes a "collision". When Emacs detects a collision, it asks you what to do, by calling the Lisp function `ask-user-about-lock'. You can redefine this function for the sake of customization. The standard definition of this function asks you a question and accepts three possible answers: `s' Steal the lock. Whoever was already changing the file loses the lock, and you gain the lock. `p' Proceed. Go ahead and edit the file despite its being locked by someone else. `q' Quit. This causes an error (`file-locked'), and the buffer contents remain unchanged--the modification you were trying to make does not actually take place. Note that locking works on the basis of a file name; if a file has multiple names, Emacs does not realize that the two names are the same file and cannot prevent two users from editing it simultaneously under different names. However, basing locking on names means that Emacs can interlock the editing of new files that will not really exist until they are saved. Some systems are not configured to allow Emacs to make locks, and there are cases where lock files cannot be written. In these cases, Emacs cannot detect trouble in advance, but it still can detect the collision when you try to save a file and overwrite someone else's changes. If Emacs or the operating system crashes, this may leave behind lock files which are stale, so you may occasionally get warnings about spurious collisions. When you determine that the collision is spurious, just use `p' to tell Emacs to go ahead anyway. Every time Emacs saves a buffer, it first checks the last-modification date of the existing file on disk to verify that it has not changed since the file was last visited or saved. If the date does not match, it implies that changes were made in the file in some other way, and these changes are about to be lost if Emacs actually does save. To prevent this, Emacs displays a warning message and asks for confirmation before saving. Occasionally you will know why the file was changed and know that it does not matter; then you can answer `yes' and proceed. Otherwise, you should cancel the save with `C-g' and investigate the situation. The first thing you should do when notified that simultaneous editing has already taken place is to list the directory with `C-u C-x C-d' (*note Directories::). This shows the file's current author. You should attempt to contact him to warn him not to continue editing. Often the next step is to save the contents of your Emacs buffer under a different name, and use `diff' to compare the two files.  File: emacs, Node: File Shadowing, Next: Time Stamps, Prev: Interlocking, Up: Saving Shadowing Files --------------- `M-x shadow-initialize' Set up file shadowing. `M-x shadow-define-literal-group' Declare a single file to be shared between sites. `M-x shadow-define-regexp-group' Make all files that match each of a group of files be shared between hosts. `M-x shadow-define-cluster NAME ' Define a shadow file cluster NAME. `M-x shadow-copy-files' Copy all pending shadow files. `M-x shadow-cancel' Cancel the instruction to shadow some files. You can arrange to keep identical "shadow" copies of certain files in more than one place--possibly on different machines. To do this, first you must set up a "shadow file group", which is a set of identically-named files shared between a list of sites. The file group is permanent and applies to further Emacs sessions as well as the current one. Once the group is set up, every time you exit Emacs, it will copy the file you edited to the other files in its group. You can also do the copying without exiting Emacs, by typing `M-x shadow-copy-files'. To set up a shadow file group, use `M-x shadow-define-literal-group' or `M-x shadow-define-regexp-group'. See their documentation strings for further information. Before copying a file to its shadows, Emacs asks for confirmation. You can answer "no" to bypass copying of this file, this time. If you want to cancel the shadowing permanently for a certain file, use `M-x shadow-cancel' to eliminate or change the shadow file group. A "shadow cluster" is a group of hosts that share directories, so that copying to or from one of them is sufficient to update the file on all of them. Each shadow cluster has a name, and specifies the network address of a primary host (the one we copy files to), and a regular expression that matches the host names of all the other hosts in the cluster. You can define a shadow cluster with `M-x shadow-define-cluster'.  File: emacs, Node: Time Stamps, Prev: File Shadowing, Up: Saving Updating Time Stamps Automatically ---------------------------------- You can arrange to put a time stamp in a file, so that it will be updated automatically each time you edit and save the file. The time stamp has to be in the first eight lines of the file, and you should insert it like this: Time-stamp: <> or like this: Time-stamp: "" Then add the hook function `time-stamp' to the hook `write-file-hooks'; that hook function will automatically update the time stamp, inserting the current date and time when you save the file. You can also use the command `M-x time-stamp' to update the time stamp manually. For other customizations, see the Custom group `time-stamp'. Note that non-numeric fields in the time stamp are formatted according to your locale setting (*note Environment::).  File: emacs, Node: Reverting, Next: Auto Save, Prev: Saving, Up: Files Reverting a Buffer ================== 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. To do this, use `M-x revert-buffer', which operates on the current buffer. Since reverting a buffer unintentionally could lose a lot of work, you must confirm this command with `yes'. `revert-buffer' keeps point at the same distance (measured in characters) from the beginning of the file. If the file was edited only slightly, you will be at approximately the same piece of text after reverting as before. If you have made drastic changes, the same value of point in the old file may address a totally different piece of text. Reverting marks the buffer as "not modified" until another change is made. Some kinds of buffers whose contents reflect data bases other than files, such as Dired buffers, can also be reverted. For them, reverting means recalculating their contents from the appropriate data base. Buffers created explicitly with `C-x b' cannot be reverted; `revert-buffer' reports an error when asked to do so. When you edit a file that changes automatically and frequently--for example, a log of output from a process that continues to run--it may be useful for Emacs to revert the file without querying you, whenever you visit the file again with `C-x C-f'. To request this behavior, set the variable `revert-without-query' to a list of regular expressions. When a file name matches one of these regular expressions, `find-file' and `revert-buffer' will revert it automatically if it has changed--provided the buffer itself is not modified. (If you have edited the text, it would be wrong to discard your changes.) You may find it useful to have Emacs revert files automatically when they change. Two minor modes are available to do this. In Global Auto-Revert mode, Emacs periodically checks all file buffers and reverts any when the corresponding file has changed. The local variant, Auto-Revert mode, applies only to buffers in which it was activated. Checking the files is done at intervals determined by the variable `auto-revert-interval'.  File: emacs, Node: Auto Save, Next: File Aliases, Prev: Reverting, Up: Files Auto-Saving: Protection Against Disasters ========================================= Emacs saves all the visited files from time to time (based on counting your keystrokes) without being asked. This is called "auto-saving". It prevents you from losing more than a limited amount of work if the system crashes. When Emacs determines that it is time for auto-saving, each buffer is considered, and is auto-saved if auto-saving is turned on for it and it has been changed since the last time it was auto-saved. The message `Auto-saving...' is displayed in the echo area during auto-saving, if any files are actually auto-saved. Errors occurring during auto-saving are caught so that they do not interfere with the execution of commands you have been typing. * Menu: * Files: Auto Save Files. The file where auto-saved changes are actually made until you save the file. * Control: Auto Save Control. Controlling when and how often to auto-save. * Recover:: Recovering text from auto-save files.  File: emacs, Node: Auto Save Files, Next: Auto Save Control, Up: Auto Save Auto-Save Files --------------- Auto-saving does not normally save in the files that you visited, because it can be very undesirable to save a program that is in an inconsistent state when you have made half of a planned change. Instead, auto-saving is done in a different file called the "auto-save file", and the visited file is changed only when you request saving explicitly (such as with `C-x C-s'). Normally, the auto-save file name is made by appending `#' to the front and rear of the visited file name. Thus, a buffer visiting file `foo.c' is auto-saved in a file `#foo.c#'. Most buffers that are not visiting files are auto-saved only if you request it explicitly; when they are auto-saved, the auto-save file name is made by appending `#%' to the front and `#' to the rear of buffer name. For example, the `*mail*' buffer in which you compose messages to be sent is auto-saved in a file named `#%*mail*#'. Auto-save file names are made this way unless you reprogram parts of Emacs to do something different (the functions `make-auto-save-file-name' and `auto-save-file-name-p'). The file name to be used for auto-saving in a buffer is calculated when auto-saving is turned on in that buffer. When you delete a substantial part of the text in a large buffer, auto save turns off temporarily in that buffer. This is because if you deleted the text unintentionally, you might find the auto-save file more useful if it contains the deleted text. To reenable auto-saving after this happens, save the buffer with `C-x C-s', or use `C-u 1 M-x auto-save'. If you want auto-saving to be done in the visited file rather than in a separate auto-save file, set the variable `auto-save-visited-file-name' to a non-`nil' value. In this mode, there is no real difference between auto-saving and explicit saving. A buffer's auto-save file is deleted when you save the buffer in its visited file. To inhibit this, set the variable `delete-auto-save-files' to `nil'. Changing the visited file name with `C-x C-w' or `set-visited-file-name' renames any auto-save file to go with the new visited name.