Commands for Fixing Typos
*************************

In this chapter we describe commands that are useful when you catch a mistake while editing.  The most fundamental of these commands is the undo command C-/ (also bound to C-x u and C-_). This undoes a single command, or a part of a command (as in the case of query-replace), or several consecutive character insertions.  Consecutive repetitions of C-/ undo earlier and earlier changes, back to the limit of the undo information available.

Aside from the commands described here, you can erase text using deletion commands such as DEL (delete-backward-char). These were described earlier in this manual.  See Erasing.

Undo
====

The undo command reverses recent changes in the buffer's text. Each buffer records changes individually, and the undo command always applies to the current buffer.  You can undo all the changes in a buffer for as far back as the buffer's records go.  Usually, each editing command makes a separate entry in the undo records, but some commands such as query-replace divide their changes into multiple entries for flexibility in undoing.  Consecutive character insertion commands are usually grouped together into a single undo record, to make undoing less tedious.

C-/
C-x u
C-_
     Undo one entry in the current buffer's undo records (undo).

To begin to undo, type C-/ (or its aliases, C-_ or C-x u) (Aside from C-/, the undo command is also bound to C-x u because that is more straightforward for beginners to remember: u stands for ``undo''.  It is also bound to C-_ because typing C-/ on some text terminals actually enters C-_.).  This undoes the most recent change in the buffer, and moves point back to where it was before that change. Consecutive repetitions of C-/ (or its aliases) undo earlier and earlier changes in the current buffer.  If all the recorded changes have already been undone, the undo command signals an error.

Any command other than an undo command breaks the sequence of undo commands.  Starting from that moment, the entire sequence of undo commands that you have just performed are themselves placed into the undo record, as a single set of changes.  Therefore, to re-apply changes you have undone, type C-f or any other command that harmlessly breaks the sequence of undoing; then type C-/ to undo the undo command.

Alternatively, if you want to resume undoing, without redoing previous undo commands, use M-x undo-only.  This is like undo, but will not redo changes you have just undone.

If you notice that a buffer has been modified accidentally, the easiest way to recover is to type C-/ repeatedly until the stars disappear from the front of the mode line (see Mode Line). Whenever an undo command makes the stars disappear from the mode line, it means that the buffer contents are the same as they were when the file was last read in or saved.  If you do not remember whether you changed the buffer deliberately, type C-/ once.  When you see the last change you made undone, you will see whether it was an intentional change.  If it was an accident, leave it undone.  If it was deliberate, redo the change as described above.

When there is an active region, any use of undo performs selective undo: it undoes the most recent change within the region, instead of the entire buffer.  However, when Transient Mark mode is off (see Disabled Transient Mark), C-/ always operates on the entire buffer, ignoring the region.  In this case, you can perform selective undo by supplying a prefix argument to the undo command: C-u C-/.  To undo further changes in the same region, repeat the undo command (no prefix argument is needed).

Some specialized buffers do not make undo records.  Buffers whose names start with spaces never do; these buffers are used internally by Emacs to hold text that users don't normally look at or edit.

When the undo information for a buffer becomes too large, Emacs discards the oldest records from time to time (during garbage collection).  You can specify how much undo information to keep by setting the variables undo-limit, undo-strong-limit, and undo-outer-limit.  Their values are expressed in bytes.

The variable undo-limit sets a soft limit: Emacs keeps undo data for enough commands to reach this size, and perhaps exceed it, but does not keep data for any earlier commands beyond that.  Its default value is 80000.  The variable undo-strong-limit sets a stricter limit: any previous command (though not the most recent one) that pushes the size past this amount is forgotten.  The default value of undo-strong-limit is 120000.

Regardless of the values of those variables, the most recent change is never discarded unless it gets bigger than undo-outer-limit (normally 12,000,000).  At that point, Emacs discards the undo data and warns you about it.  This is the only situation in which you cannot undo the last command.  If this happens, you can increase the value of undo-outer-limit to make it even less likely to happen in the future.  But if you didn't expect the command to create such large undo data, then it is probably a bug and you should report it. See Reporting Bugs.

Transposing Text
================

C-t
     Transpose two characters (transpose-chars).

M-t
     Transpose two words (transpose-words).

C-M-t
     Transpose two balanced expressions (transpose-sexps).

C-x C-t
     Transpose two lines (transpose-lines).

The common error of transposing two characters can be fixed, when they are adjacent, with the C-t command (transpose-chars).  Normally, C-t transposes the two characters on either side of point.  When given at the end of a line, rather than transposing the last character of the line with the newline, which would be useless, C-t transposes the last two characters on the line.  So, if you catch your transposition error right away, you can fix it with just a C-t.  If you don't catch it so fast, you must move the cursor back between the two transposed characters before you type C-t.  If you transposed a space with the last character of the word before it, the word motion commands are a good way of getting there.  Otherwise, a reverse search (C-r) is often the best way.  See Search.

M-t transposes the word before point with the word after point (transpose-words).  It moves point forward over a word, dragging the word preceding or containing point forward as well.  The punctuation characters between the words do not move.  For example, FOO, BAR transposes into BAR, FOO rather than BAR FOO,.

C-M-t (transpose-sexps) is a similar command for transposing two expressions (see Expressions), and C-x C-t (transpose-lines) exchanges lines.  They work like M-t except as regards what units of text they transpose.

A numeric argument to a transpose command serves as a repeat count: it tells the transpose command to move the character (word, expression, line) before or containing point across several other characters (words, expressions, lines).  For example, C-u 3 C-t moves the character before point forward across three other characters.  It would change f-!-oobar into oobf-!-ar.  This is equivalent to repeating C-t three times.  C-u - 4 M-t moves the word before point backward across four words.  C-u - C-M-t would cancel the effect of plain C-M-t.

A numeric argument of zero is assigned a special meaning (because otherwise a command with a repeat count of zero would do nothing): to transpose the character (word, expression, line) ending after point with the one ending after the mark.

Case Conversion
===============

M-- M-l
     Convert last word to lower case.  Note Meta-- is Meta-minus.

M-- M-u
     Convert last word to all upper case.

M-- M-c
     Convert last word to lower case with capital initial.

A very common error is to type words in the wrong case.  Because of this, the word case-conversion commands M-l, M-u and M-c have a special feature when used with a negative argument: they do not move the cursor.  As soon as you see you have mistyped the last word, you can simply case-convert it and go on typing.  See Case.

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 only work if the spelling checker program Aspell, Ispell or Hunspell is installed. These programs are not part of Emacs, but one of them is usually installed in GNU/Linux and other free operating systems. See Aspell (The Aspell Manual).

M-$
     Check and correct spelling of the word at point (ispell-word). If the region is active, do it for all words in the region instead.

M-x ispell
     Check and correct spelling of all words in the buffer.  If the region is active, do it for all words in the region instead.

M-x ispell-buffer
     Check and correct spelling in the buffer.

M-x ispell-region
     Check and correct spelling in the region.

M-x ispell-message
     Check and correct spelling in a draft mail message, excluding cited material.

M-x ispell-change-dictionary RET DICT RET
     Restart the Aspell/Ispell/Hunspell process, using DICT as the dictionary.

M-x ispell-kill-ispell
     Kill the Aspell/Ispell/Hunspell subprocess.

M-TAB
ESC TAB
     Complete the word before point based on the spelling dictionary (ispell-complete-word).

M-x flyspell-mode
     Enable Flyspell mode, which highlights all misspelled words.

M-x flyspell-prog-mode
     Enable Flyspell mode for comments and strings only.

To check the spelling of the word around or before point, and optionally correct it as well, type M-$ (ispell-word). If a region is active, M-$ checks the spelling of all words within the region.  See Mark.  (When Transient Mark mode is off, M-$ always acts on the word around or before point, ignoring the region; see Disabled Transient Mark.)

Similarly, the command M-x ispell performs spell-checking in the region if one is active, or in the entire buffer otherwise.  The commands M-x ispell-buffer and M-x ispell-region explicitly perform spell-checking on the entire buffer or the region respectively.  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.  See Sending Mail.

When one of these commands encounters what appears to be an incorrect word, it asks you what to do.  It usually displays a list of numbered near-misses---words that are close to the incorrect word. Then you must type a single-character response.  Here are the valid responses:

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.

SPC
     Skip this word---continue to consider it incorrect, but don't change it here.

r NEW RET
     Replace the word, just this time, with NEW.  (The replacement string will be rescanned for more spelling errors.)

R NEW RET
     Replace the word with NEW, and do a query-replace so you can replace it elsewhere in the buffer if you wish.  (The replacements will be rescanned for more spelling errors.)

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 Aspell or Ispell or Hunspell will consider it correct from now on, even in future sessions.

m
     Like i, but you can also specify dictionary completion information.

u
     Insert the lower-case version of this word in your private dictionary file.

l WORD RET
     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
X
     Quit interactive spell checking, leaving point at the word that was being checked.  You can restart checking again afterward with C-u M-$.

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 spell-checker subprocess.

?
     Show the list of options.

In Text mode and related modes, M-TAB (ispell-complete-word) performs in-buffer completion based on spelling correction.  Insert the beginning of a word, and then type M-TAB; this shows a list of completions.  (If your window manager intercepts M-TAB, type ESC TAB or C-M-i.)  Each completion is listed with a digit or character; type that digit or character to choose it.

Once started, the Aspell or Ispell or Hunspell 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 process, use M-x ispell-kill-ispell.  This is not usually necessary, since the process uses no processor time except when you do spelling correction.

Ispell, Aspell and Hunspell look up spelling in two dictionaries: the standard dictionary and your personal dictionary.  The standard dictionary is specified by the variable ispell-local-dictionary or, if that is nil, by the variable ispell-dictionary. If both are nil, the spelling program's default dictionary is used.  The command M-x ispell-change-dictionary sets the standard dictionary for the buffer and then restarts the subprocess, so that it will use a different standard dictionary.  Your personal dictionary is specified by the variable ispell-personal-dictionary.  If that is nil, the spelling program looks for a personal dictionary in a default location.

A separate dictionary is used for word completion.  The variable ispell-complete-word-dict specifies the file name of this dictionary.  The completion dictionary must be different because it cannot use root and affix information.  For some languages, there is a spell checking dictionary but no word completion dictionary.

Flyspell mode is a minor mode that performs automatic spell checking as you type.  When it finds a word that it does not recognize, it highlights that word.  Type M-x flyspell-mode to toggle Flyspell mode in the current buffer.  To enable Flyspell mode in all text mode buffers, add flyspell-mode to text-mode-hook. See Hooks.

When Flyspell mode highlights a word as misspelled, you can click on it with mouse-2 (flyspell-correct-word) to display a menu of possible corrections and actions.  In addition, C-. or ESC-TAB (flyspell-auto-correct-word) will propose various successive corrections for the word at point, and C-c $ (flyspell-correct-word-before-point) will pop up a menu of possible corrections.  Of course, you can always correct the misspelled word by editing it manually in any way you like.

Flyspell Prog mode works just like ordinary Flyspell mode, except that it only checks words in comments and string constants.  This feature is useful for editing programs.  Type M-x flyspell-prog-mode to enable or disable this mode in the current buffer.  To enable this mode in all programming mode buffers, add flyspell-prog-mode to prog-mode-hook (see Hooks).