(Fixit): Favor C-/ keybinding for undo throughout. Link to Erasing

node.
(Undo): Reorganize paragraphs for logical flow.  Move keybinding
rationale to a footnote.
(Kill Errors): Remove node, due to redundancy with Erasing.
(Spelling): Move discussion of flyspell to end.  Note new behavior of
M-$ in active region.  Remove non-ispell-specific keybindings from
table.

1 files changed, 154 insertions, 217 deletions

diff --git a/doc/emacs/fixit.texi b/doc/emacs/fixit.texi
index a6bd52b1bc4..114ba9247dd 100644
--- a/doc/emacs/fixit.texi
+++ b/doc/emacs/fixit.texi
@@ -7,21 +7,24 @@
 @cindex typos, fixing
 @cindex mistakes, correcting
 
-  In this chapter we describe the commands that are especially useful for
-the times when you catch a mistake in your text just after you have made
-it, or change your mind while composing text on the fly.
+  In this chapter we describe the commands that are especially useful
+when you catch a mistake in your text after you have made it, or
+change your mind while composing text on the fly.
 
   The most fundamental command for correcting erroneous editing is the
-undo command, @kbd{C-x u} or @kbd{C-_} or @kbd{C-/}.  This command
-undoes a single command (usually), a part of a command (in the case of
-@code{query-replace}), or several consecutive self-inserting
-characters.  Consecutive repetitions of the undo command undo earlier
-and earlier changes, back to the limit of the undo information
-available.  @xref{Undo}, for more information.
+undo command @kbd{C-/} (which is also bound to @kbd{C-x u} and
+@kbd{C-_}).  This undoes a single command, or a part of a command (as
+in the case of @code{query-replace}), or several consecutive
+self-inserting characters.  Consecutive repetitions of @kbd{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 @key{DEL} (@code{delete-backward-char}).
+These were described earlier in this manual.  @xref{Erasing}.
 
 @menu
 * Undo::        The Undo commands.
-* Kill Errors:: Commands to kill a batch of recently entered text.
 * Transpose::   Exchanging two characters, words, lines, lists...
 * Fixing Case:: Correcting case of last word entered.
 * Spelling::    Apply spelling checker to a word, or a whole file.
@@ -32,19 +35,20 @@ available.  @xref{Undo}, for more information.
 @cindex undo
 @cindex changes, undoing
 
-  The @dfn{undo} commands undo recent changes in the buffer's text.
+  The @dfn{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 as back these records go.  Usually each editing
+buffer for as far as back its records go.  Usually, each editing
 command makes a separate entry in the undo records, but some commands
 such as @code{query-replace} divide their changes into multiple
-entries for flexibility in undoing.  Meanwhile, self-inserting
-characters are usually grouped to make undoing less tedious.
+entries for flexibility in undoing.  Consecutive character insertion
+commands are usually grouped together into a single undo record, to
+make undoing less tedious.
 
 @table @kbd
-@item C-x u
+@item C-/
+@itemx C-x u
 @itemx C-_
-@itemx C-/
 Undo one entry in the current buffer's undo records (@code{undo}).
 @end table
 
@@ -52,74 +56,75 @@ Undo one entry in the current buffer's undo records (@code{undo}).
 @kindex C-_
 @kindex C-/
 @findex undo
-  To begin to undo, type the command @kbd{C-/} (or its aliases,
-@kbd{C-_} or @kbd{C-x u}).  This undoes the most recent change in the
-buffer, and moves point back to where it was before that change.
+  To begin to undo, type @kbd{C-/} (or its aliases, @kbd{C-_} or
+@kbd{C-x u})@footnote{Aside from @kbd{C-/}, the @code{undo} command is
+also bound to @kbd{C-x u} because that is more straightforward for
+beginners to remember: @samp{u} stands for ``undo''.  It is also bound
+to @kbd{C-_} because typing @kbd{C-/} on some text-only terminals
+actually enters @kbd{C-_}.}.  This undoes the most recent change in
+the buffer, and moves point back to where it was before that change.
 
   Consecutive repetitions of @kbd{C-/} (or its aliases) undo earlier
-and earlier changes in the current buffer, back to the limit of the
-current buffer's undo records.  If all the recorded changes have
-already been undone, the undo command just signals an error.
-
-  If you notice that a buffer has been modified accidentally, the
-easiest way to recover is to type @kbd{C-/} repeatedly until the stars
-disappear from the front of the mode line.  At this time, all the
-modifications you made have been canceled.  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 @kbd{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
-below.
+and earlier changes in the current buffer.  If all the recorded
+changes have already been undone, the undo command signals an error.
 
+@cindex redo
 @findex undo-only
   Any command other than an undo command breaks the sequence of undo
-commands.  Starting from that moment, the previous undo commands
-become ordinary changes that you can undo.  Thus, to redo changes you
-have undone, type @kbd{C-f} or any other command that will harmlessly
-break the sequence of undoing, then type undo commands again.  On the
-other hand, if you want to resume undoing, without redoing previous
-undo commands, use @kbd{M-x undo-only}.  This is like @code{undo}, but
-will not redo changes you have just undone.
+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 @kbd{C-f} or any other command that
+harmlessly breaks the sequence of undoing; then type @kbd{C-/} to undo
+the undo command.
+
+  On the other hand, if you want to resume undoing, without redoing
+previous undo commands, use @kbd{M-x undo-only}.  This is like
+@code{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 @kbd{C-/} repeatedly until the stars
+disappear from the front of the mode line (@pxref{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 @kbd{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.
 
 @cindex selective undo
 @kindex C-u C-/
   When there is an active region, any use of @code{undo} performs
-@dfn{selective undo}, undoing the most recent change within the
+@dfn{selective undo}: it undoes the most recent change within the
 region, instead of the entire buffer.  However, when Transient Mark
 mode is off (@pxref{Persistent Mark}), @kbd{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 @code{undo}
-command: @kbd{C-u C-/} or @kbd{C-u C-x u}.  To undo further changes in
-the same region, repeat the @code{undo} command (no prefix argument is
-needed).
+command: @kbd{C-u C-/}.  To undo further changes in the same region,
+repeat the @code{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 and its extensions to hold text that users don't
-normally look at or edit.
+  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.
 
 @vindex undo-limit
 @vindex undo-strong-limit
 @vindex undo-outer-limit
 @cindex undo limit
-  When the undo records for a buffer becomes too large, Emacs
-discards the oldest undo records from time to time (during garbage
-collection).  You can specify how much undo records to keep by
-setting three variables: @code{undo-limit}, @code{undo-strong-limit},
-and @code{undo-outer-limit}.  Their values are expressed in units of
-bytes of space.
+  When the undo records for a buffer becomes too large, Emacs discards
+the oldest undo records from time to time (during @dfn{garbage
+collection}).  You can specify how much undo records to keep by
+setting the variables @code{undo-limit}, @code{undo-strong-limit}, and
+@code{undo-outer-limit}.  Their values are expressed in bytes.
 
   The variable @code{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 20000.  The variable @code{undo-strong-limit} sets a
-stricter limit: a previous command (not the most recent one) which
-pushes the size past this amount is itself forgotten.  The default
-value of @code{undo-strong-limit} is 30000.
+stricter limit: any previous command (though not the most recent one)
+that pushes the size past this amount is forgotten.  The default value
+of @code{undo-strong-limit} is 30000.
 
   Regardless of the values of those variables, the most recent change
 is never discarded unless it gets bigger than @code{undo-outer-limit}
@@ -131,46 +136,6 @@ 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.
 @xref{Bugs,, Reporting Bugs}.
 
-  The reason the @code{undo} command has three key bindings, @kbd{C-x
-u}, @kbd{C-_} and @kbd{C-/}, is that it is worthy of a
-single-character key, but @kbd{C-x u} is more straightforward for
-beginners to remember and type.  Meanwhile, @kbd{C--} on a text-only
-terminal is really @kbd{C-_}, which makes it a natural and easily
-typed binding for undoing.
-
-@node Kill Errors
-@section Killing Your Mistakes
-
-@table @kbd
-@item @key{DEL}
-Delete last character (@code{delete-backward-char}).
-@item M-@key{DEL}
-Kill last word (@code{backward-kill-word}).
-@item C-x @key{DEL}
-Kill to beginning of sentence (@code{backward-kill-sentence}).
-@end table
-
-  The @key{DEL} character (@code{delete-backward-char}) is the most
-important correction command.  It deletes the character before point.
-When @key{DEL} follows a self-inserting character command, you can think
-of it as canceling that command.  However, avoid the confusion of thinking
-of @key{DEL} as a general way to cancel a command!
-
-  When your mistake is longer than a couple of characters, it might be
-more convenient to use @kbd{M-@key{DEL}} or @kbd{C-x @key{DEL}}.
-@kbd{M-@key{DEL}} kills back to the start of the last word, and @kbd{C-x
-@key{DEL}} kills back to the start of the last sentence.  @kbd{C-x
-@key{DEL}} is particularly useful when you change your mind about the
-phrasing of the text you are writing.  @kbd{M-@key{DEL}} and @kbd{C-x
-@key{DEL}} save the killed text for @kbd{C-y} and @kbd{M-y} to
-retrieve.  @xref{Yanking}.@refill
-
-  @kbd{M-@key{DEL}} is often useful even when you have typed only a few
-characters wrong, if you know you are confused in your typing and aren't
-sure exactly what you typed.  At such a time, you cannot correct with
-@key{DEL} except by looking at the screen to see what you did.  Often it
-requires less thought to kill the whole word and start again.
-
 @node Transpose
 @section Transposing Text
 
@@ -262,103 +227,82 @@ case-convert it and go on typing.  @xref{Case}.@refill
 @cindex checking spelling
 @cindex 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 programs Aspell and Ispell, which are not part of Emacs.
+  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 or Ispell is installed.  Neither
+Aspell nor Ispell are part of Emacs, but one or the other is usually
+installed in GNU/Linux and other free operating systems.
 @ifnottex
 @xref{Top, Aspell,, aspell, The Aspell Manual}.
 @end ifnottex
 
 @table @kbd
-@item M-x flyspell-mode
-Enable Flyspell mode, which highlights all misspelled words.
-@item M-x flyspell-prog-mode
-Enable Flyspell mode for comments and strings only.
 @item M-$
-Check and correct spelling of the word at point (@code{ispell-word}).
-@item M-@key{TAB}
-@itemx @key{ESC} @key{TAB}
-Complete the word before point based on the spelling dictionary
-(@code{ispell-complete-word}).
+Check and correct spelling of the active region or the word at point
+(@code{ispell-word}).
 @item M-x ispell
-Spell-check the active region or the current buffer.
+Check and correct spelling in the active region or the entire buffer.
 @item M-x ispell-buffer
-Check and correct spelling of each word in the buffer.
+Check and correct spelling in the buffer.
 @item M-x ispell-region
-Check and correct spelling of each word in the region.
+Check and correct spelling in the region.
 @item M-x ispell-message
-Check and correct spelling of each word in a draft mail message,
-excluding cited material.
+Check and correct spelling in a draft mail message, excluding cited
+material.
 @item M-x ispell-change-dictionary @key{RET} @var{dict} @key{RET}
 Restart the Aspell or Ispell process, using @var{dict} as the dictionary.
 @item M-x ispell-kill-ispell
 Kill the Aspell or Ispell subprocess.
+@item M-@key{TAB}
+@itemx @key{ESC} @key{TAB}
+Complete the word before point based on the spelling dictionary
+(@code{ispell-complete-word}).
+@item M-x flyspell-mode
+Enable Flyspell mode, which highlights all misspelled words.
+@item M-x flyspell-prog-mode
+Enable Flyspell mode for comments and strings only.
 @end table
 
-@cindex Flyspell mode
-@findex flyspell-mode
-  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 @kbd{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 @kbd{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.
-
-@findex flyspell-prog-mode
-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 @kbd{M-x flyspell-prog-mode} to
-enable or disable this mode in the current buffer.
-
-  The other Emacs spell-checking features check or look up words when
-you give an explicit command to do so.
-
 @kindex M-$
 @findex ispell-word
   To check the spelling of the word around or before point, and
-optionally correct it as well, use the command @kbd{M-$}
-(@code{ispell-word}).  If the word is not correct, Emacs offers you
-various alternatives for what to do about it.  If a region is active,
-@kbd{M-$} checks the spelling of all words within the region
-(@pxref{Mark}).  (However, when Transient Mark mode is off, @kbd{M-$}
-always acts on the word around or before point, ignoring the region.
-@xref{Persistent Mark}.)
+optionally correct it as well, type @kbd{M-$} (@code{ispell-word}).
+If a region is active, @kbd{M-$} checks the spelling of all words
+within the region.  @xref{Mark}.  (When Transient Mark mode is off,
+@kbd{M-$} always acts on the word around or before point, ignoring the
+region.  @xref{Persistent Mark}.)
 
 @findex ispell
-@cindex spell-checking the active region
-  The @kbd{M-x ispell} command performs spell-checking on the entire
-buffer if no region is active, or on region if one is active.  (When
-Transient Mark mode is off, it always acts on the entire buffer,
-ignoring the region.)
-
 @findex ispell-buffer
 @findex ispell-region
-  The commands @kbd{M-x ispell-buffer} and @kbd{M-x ispell-region}
+@cindex spell-checking the active region
+  Similarly, the command @kbd{M-x ispell} performs spell-checking in
+the region if one is active, or in the entire buffer otherwise.  The
+commands @kbd{M-x ispell-buffer} and @kbd{M-x ispell-region}
 explicitly perform spell-checking on the entire buffer or the region
-respectively.
+respectively.  To check spelling in an email message you are writing,
+use @kbd{M-x ispell-message}; that command checks the whole buffer,
+except for material that is indented or appears to be cited from other
+messages.  @xref{Sending Mail}.
 
-  To check spelling in an email message you are writing, use @kbd{M-x
-ispell-message}; that command checks the whole buffer, except for
-material that is indented or appears to be cited from other messages.
-
-  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:
+  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:
 
 @table @kbd
+@item @var{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.
+
 @item @key{SPC}
 Skip this word---continue to consider it incorrect, but don't change it
 here.
 
 @item r @var{new} @key{RET}
-Replace the word (just this time) with @var{new}.  (The replacement
+Replace the word, just this time, with @var{new}.  (The replacement
 string will be rescanned for more spelling errors.)
 
 @item R @var{new} @key{RET}
@@ -366,11 +310,6 @@ Replace the word with @var{new}, and do a @code{query-replace} so you
 can replace it elsewhere in the buffer if you wish.  (The replacements
 will be rescanned for more spelling errors.)
 
-@item @var{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.
-
 @item a
 Accept the incorrect word---treat it as correct, but only in this
 editing session.
@@ -383,14 +322,14 @@ editing session and for this buffer.
 Insert this word in your private dictionary file so that Aspell or Ispell will
 consider it correct from now on, even in future sessions.
 
-@item u
-Insert the lower-case version of this word in your private dic@-tion@-ary
-file.
-
 @item m
 Like @kbd{i}, but you can also specify dictionary completion
 information.
 
+@item u
+Insert the lower-case version of this word in your private dic@-tion@-ary
+file.
+
 @item l @var{word} @key{RET}
 Look in the dictionary for words that match @var{word}.  These words
 become the new list of ``near-misses''; you can select one of them as
@@ -398,13 +337,11 @@ the replacement by typing a digit.  You can use @samp{*} in @var{word} as a
 wildcard.
 
 @item C-g
+@itemx X
 Quit interactive spell checking, leaving point at the word that was
 being checked.  You can restart checking again afterward with @kbd{C-u
 M-$}.
 
-@item X
-Same as @kbd{C-g}.
-
 @item x
 Quit interactive spell checking and move point back to where it was
 when you started spell checking.
@@ -412,65 +349,65 @@ when you started spell checking.
 @item q
 Quit interactive spell checking and kill the Ispell subprocess.
 
-@item C-l
-Refresh the screen.
-
-@item C-z
-This key has its normal command meaning (suspend Emacs or iconify this
-frame).
-
 @item ?
 Show the list of options.
 @end table
 
 @findex ispell-complete-word
-  The command @code{ispell-complete-word}, which is bound to the key
-@kbd{M-@key{TAB}} in Text mode and related modes, shows a list of
-completions based on spelling correction.  Insert the beginning of a
-word, and then type @kbd{M-@key{TAB}}; the command displays a
-completion list window.  (If your window manager intercepts
-@kbd{M-@key{TAB}}, type @kbd{@key{ESC} @key{TAB}} or @kbd{C-M-i}.)  To
-choose one of the completions listed, click @kbd{Mouse-2} or
-@kbd{Mouse-1} fast on it, or move the cursor there in the completions
-window and type @key{RET}.  @xref{Text Mode}.
-
-@ignore
-@findex reload-ispell
-  The first time you use any of the spell checking commands, it starts
-an Ispell subprocess.  The first thing the subprocess does is read your
-private dictionary, which defaults to the file @file{~/ispell.words}.
-Words that you ``insert'' with the @kbd{i} command are added to that
-file, but not right away---only at the end of the interactive
-replacement procedure.  Use the @kbd{M-x reload-ispell} command to
-reload your private dictionary if you edit the file outside of Ispell.
-@end ignore
+  In Text mode and related modes, the command @kbd{M-@key{TAB}}
+(@code{ispell-complete-word}) shows a list of completions based on
+spelling correction.  Insert the beginning of a word, and then type
+@kbd{M-@key{TAB}}; the command displays a completion list window.  (If
+your window manager intercepts @kbd{M-@key{TAB}}, type @kbd{@key{ESC}
+@key{TAB}} or @kbd{C-M-i}.)  To choose one of the completions listed,
+click @kbd{Mouse-2} or @kbd{Mouse-1} fast on it, or move the cursor
+there in the completions window and type @key{RET}.  @xref{Text Mode}.
 
 @cindex @code{ispell} program
 @findex ispell-kill-ispell
-  Once started, the Aspell or Ispell subprocess continues to run
-(waiting for something to do), so that subsequent spell checking
+  Once started, the Aspell or 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
 process, use @kbd{M-x ispell-kill-ispell}.  This is not usually
 necessary, since the process uses no time except when you do spelling
 correction.
 
 @vindex ispell-dictionary
-  Ispell and Aspell use two dictionaries together for spell checking: the
-standard dictionary and your private dictionary.  The variable
+@vindex ispell-complete-word-dict
+  Ispell and Aspell use two dictionaries together for spell checking:
+the standard dictionary and your private dictionary.  The variable
 @code{ispell-dictionary} specifies the file name to use for the
 standard dictionary; a value of @code{nil} selects the default
 dictionary.  The command @kbd{M-x ispell-change-dictionary} sets this
-variable and then restarts the subprocess, so that it will use
-a different standard dictionary.
-
-@vindex ispell-complete-word-dict
-  Aspell and Ispell use a separate dictionary for word completion.
-The variable @code{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
+variable and then restarts the subprocess, so that it will use a
+different standard dictionary.  A separate dictionary is used for word
+completion.  The variable @code{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.
 
+@cindex Flyspell mode
+@findex flyspell-mode
+  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 @kbd{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 @kbd{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.
+
+@findex flyspell-prog-mode
+  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 @kbd{M-x
+flyspell-prog-mode} to enable or disable this mode in the current
+buffer.
+
 @ignore
    arch-tag: 3359a443-96ed-448f-9f05-c8111ba8eac0
 @end ignore