--- a/man/xemacs/mini.texi	Mon Aug 13 11:19:22 2007 +0200
+++ b/man/xemacs/mini.texi	Mon Aug 13 11:20:41 2007 +0200
@@ -3,19 +3,20 @@
 @chapter The Minibuffer
 @cindex minibuffer
 
-  The @dfn{minibuffer} is the facility used by XEmacs commands to read
-arguments more complicated than a single number.  Minibuffer arguments
-can be file names, buffer names, Lisp function names, XEmacs command
-names, Lisp expressions, and many other things, depending on the command
-reading the argument.  You can use the usual XEmacs editing commands in
-the minibuffer to edit the argument text.
+  Emacs commands use the @dfn{minibuffer} to read arguments more
+complicated than a single number.  Minibuffer arguments can be file
+names, buffer names, Lisp function names, Emacs command names, Lisp
+expressions, and many other things, depending on the command reading the
+argument.  To edit the argument in the minibuffer, you can use Emacs
+editing commands.
+
 
 @cindex prompt
   When the minibuffer is in use, it appears in the echo area, and the
 cursor moves there.  The beginning of the minibuffer line displays a
-@dfn{prompt} which says what kind of input you should supply and how it
-will be used.  Often this prompt is derived from the name of the command
-that the argument is for.  The prompt normally ends with a colon.
+@dfn{prompt} indicating what kind of input you should supply and how it
+will be used.  The prompt is often derived from the name of the command
+the argument is for.  The prompt normally ends with a colon.
 
 @cindex default argument
   Sometimes a @dfn{default argument} appears in parentheses after the
@@ -25,14 +26,14 @@
 is the name of the buffer that will be used if you type just @key{RET}.
 
 @kindex C-g
-  The simplest way to enter a minibuffer argument is to type the text
-you want, terminated by @key{RET} which exits the minibuffer.  You can
-cancel the command that wants the argument, and get out of the
-minibuffer, by typing @kbd{C-g}.
+  The simplest way to give a minibuffer argument is to type the text you
+want, terminated by @key{RET} to exit the minibuffer.  To get out
+of the minibuffer and cancel the command that it was for, type
+@kbd{C-g}.
 
   Since the minibuffer uses the screen space of the echo area, it can
-conflict with other ways XEmacs customarily uses the echo area.  Here is
-how XEmacs handles such conflicts:
+conflict with other ways Emacs customarily uses the echo area.  Here is how
+Emacs handles such conflicts:
 
 @itemize @bullet
 @item
@@ -43,9 +44,9 @@
 anything.
 
 @item
-If in the minibuffer you use a command whose purpose is to print a
-message in the echo area, such as @kbd{C-x =}, the message is printed
-normally, and the minibuffer is hidden for a while.  It comes back
+If you use a command in the minibuffer whose purpose is to print a
+message in the echo area (for example @kbd{C-x =}) the message is
+displayed normally, and the minibuffer is hidden for a while.  It comes back
 after a few seconds, or as soon as you type anything.
 
 @item
@@ -57,7 +58,6 @@
 * File: Minibuffer File.  Entering file names with the minibuffer.
 * Edit: Minibuffer Edit.  How to edit in the minibuffer.
 * Completion::		  An abbreviation facility for minibuffer input.
-* Minibuffer History::    Reusing recent minibuffer arguments.
 * Repetition::		  Re-executing commands that used the minibuffer.
 @end menu
 
@@ -66,43 +66,37 @@
 
   Sometimes the minibuffer starts out with text in it.  For example, when
 you are supposed to give a file name, the minibuffer starts out containing
-the @dfn{default directory}, which ends with a slash.  This is to inform
-you which directory the file will be found in if you do not specify a
-directory.
-
-  For example, the minibuffer might start out with these contents:
+the @dfn{default directory}, which ends with a slash.  This informs
+you in which directory the file will be looked for if you do not specify
+a different one. For example, the minibuffer might start out with:
 
 @example
 Find File: /u2/emacs/src/
 @end example
 
 @noindent
-where @samp{Find File:@: } is the prompt.  Typing @kbd{buffer.c}
-specifies the file @file{/u2/emacs/src/buffer.c}.  To find files in
-nearby directories, use @kbd{..}; thus, if you type
-@kbd{../lisp/simple.el}, you will get the file named
-@file{/u2/emacs/lisp/simple.el}.  Alternatively, you can kill with
-@kbd{M-@key{DEL}} the directory names you don't want (@pxref{Words}).
+where @samp{Find File:@: } is the prompt.  Typing @kbd{buffer.c} specifies
+the file 
+@*@file{/u2/emacs/src/buffer.c}.  To find files in nearby
+directories, use @samp{..}; thus, if you type @kbd{../lisp/simple.el}, the
+file that you visit will be the one named 
+@*@file{/u2/emacs/lisp/simple.el}.
+Alternatively, you can use  @kbd{M-@key{DEL}} to kill directory names you
+don't want (@pxref{Words}).@refill
 
-  If you don't want any of the default, you can kill it with @kbd{C-a
-C-k}.  But you don't need to kill the default; you can simply ignore it.
-Insert an absolute file name, one starting with a slash or a tilde,
-after the default directory.  For example, to specify the file
-@file{/etc/termcap}, just insert that name, giving these minibuffer
-contents:
+  You can also type an absolute file name, one starting with a slash or a
+tilde, ignoring the default directory.  For example, to find the file
+@file{/etc/termcap}, just type the name, giving:
 
 @example
 Find File: /u2/emacs/src//etc/termcap
 @end example
 
 @noindent
-@cindex // in file name
-@cindex double slash in file name
-@cindex slashes repeated in file name
-XEmacs gives a special meaning to a double slash (which is not normally
-a useful thing to write): it means, ``ignore everything before the
-second slash in the pair.''  Thus, @samp{/u2/emacs/src/} is ignored in
-the example above, and you get the file @file{/etc/termcap}.
+Two slashes in a row are not normally meaningful in Unix file names, but
+they are allowed in XEmacs.  They mean, ``ignore everything before the
+second slash in the pair.''  Thus, @samp{/u2/emacs/src/} is ignored, and
+you get the file @file{/etc/termcap}.
 
 @vindex insert-default-directory
 If you set @code{insert-default-directory} to @code{nil}, the default
@@ -113,144 +107,126 @@
 @node Minibuffer Edit, Completion, Minibuffer File, Minibuffer
 @section Editing in the Minibuffer
 
-  The minibuffer is an XEmacs buffer (albeit a peculiar one), and the
-usual XEmacs commands are available for editing the text of an argument
-you are entering.
+  The minibuffer is an Emacs buffer (albeit a peculiar one), and the usual
+Emacs commands are available for editing the text of an argument you are
+entering.
 
   Since @key{RET} in the minibuffer is defined to exit the minibuffer,
-you can't use it to insert a newline in the minibuffer.  To do that,
-type @kbd{C-o} or @kbd{C-q C-j}.  (Recall that a newline is really the
-character control-J.)
+you must use @kbd{C-o} or @kbd{C-q @key{LFD}} to insert a newline into
+the minibuffer. (Recall that a newline is really the @key{LFD}
+character.)
 
-  The minibuffer has its own window which always has space on the screen
-but acts as if it were not there when the minibuffer is not in use.
-When the minibuffer is in use, its window is just like the others; you
-can switch to another window with @kbd{C-x o}, edit text in other
-windows and perhaps even visit more files, before returning to the
-minibuffer to submit the argument.  You can kill text in another window,
-return to the minibuffer window, and then yank the text to use it in the
-argument.  @xref{Windows}.
+  The minibuffer has its own window, which always has space on the screen
+but acts as if it were not there when the minibuffer is not in use.  The
+minibuffer window is just like the others; you can switch to another 
+window with @kbd{C-x o}, edit text in other windows, and perhaps even
+visit more files before returning to the minibuffer to submit the
+argument.  You can kill text in another window, return to the minibuffer
+window, and then yank the text to use it in the argument.  @xref{Windows}.
 
-  There are some restrictions on the use of the minibuffer window,
-however.  You cannot switch buffers in it---the minibuffer and its
-window are permanently attached.  Also, you cannot split or kill the
-minibuffer window. But you can make it taller in the normal fashion with
-@kbd{C-x ^}.  If you enable Resize-Minibuffer mode, then the
-minibuffer window expands vertically as necessary to hold the text that
-you put in the minibuffer.  Use @kbd{M-x resize-minibuffer-mode} to
-enable or disable this minor mode (@pxref{Minor Modes}).
+  There are, however, some restrictions on the use of the minibuffer window.
+You cannot switch buffers in it---the minibuffer and its window are
+permanently attached.  You also cannot split or kill the minibuffer
+window, but you can make it taller with @kbd{C-x ^}.
 
 @kindex C-M-v
-  If while in the minibuffer you issue a command that displays help text
-of any sort in another window, you can use the @kbd{C-M-v} command while
-in the minibuffer to scroll the help text.  This lasts until you exit
-the minibuffer.  This feature is especially useful if a completing
-minibuffer gives you a list of possible completions.  @xref{Other Window}.
+  If you are in the minibuffer and issue a command that displays help
+text in another window, that window will be scrolled if you type
+@kbd{M-C-v} while in the minibuffer until you exit the minibuffer.  This
+feature is helpful if a completing minibuffer gives you a long list of
+possible completions.
 
-@vindex minibuffer-confirm-incomplete
 If the variable @code{minibuffer-confirm-incomplete} is @code{t}, you
 are asked for confirmation if there is no known completion for the text
 you typed. For example, if you attempted to visit a non-existent file,
 the minibuffer might read:
 @example
-        Find File: chocolate_bar.c [no completions, confirm]
+        Find File:chocolate_bar.c [no completions, confirm]
 @end example
 If you press @kbd{Return} again, that confirms the filename. Otherwise,
 you can continue editing it. 
 
- XEmacs supports recursive use of the minibuffer.  However, it is easy
-to do this by accident (because of autorepeating keyboards, for example)
-and get confused.  Therefore, most XEmacs commands that use the
-minibuffer refuse to operate if the minibuffer window is selected.  If
-the minibuffer is active but you have switched to a different window,
-recursive use of the minibuffer is allowed---if you know enough to try
-to do this, you probably will not get confused.
+ Emacs supports recursive use of the minibuffer.  However, it is
+easy to do this by accident (because of autorepeating keyboards, for
+example) and get confused.  Therefore, most Emacs commands that use the
+minibuffer refuse to operate if the minibuffer window is selected.  If the
+minibuffer is active but you have switched to a different window, recursive
+use of the minibuffer is allowed---if you know enough to try to do this,
+you probably will not get confused.
 
 @vindex enable-recursive-minibuffers
-  If you set the variable @code{enable-recursive-minibuffers} to a
+  If you set the variable @code{enable-recursive-minibuffers} to be
 non-@code{nil}, recursive use of the minibuffer is always allowed.
 
-@node Completion, Minibuffer History, Minibuffer Edit, Minibuffer
+@node Completion, Repetition, Minibuffer Edit, Minibuffer
 @section Completion
 @cindex completion
 
-  For certain kinds of arguments, you can use @dfn{completion} to enter
-the argument value.  Completion means that you type part of the
-argument, then XEmacs visibly fills in the rest, or as much as
-can be determined from the part you have typed.
+  When appropriate, the minibuffer provides a @dfn{completion} facility.
+You type the beginning of an argument and one of the completion keys,
+and Emacs visibly fills in the rest, depending on what you have already
+typed.
 
   When completion is available, certain keys---@key{TAB}, @key{RET}, and
-@key{SPC}---are rebound to complete the text present in the
+@key{SPC}---are redefined to complete an abbreviation present in the
 minibuffer into a longer string that it stands for, by matching it
 against a set of @dfn{completion alternatives} provided by the command
 reading the argument.  @kbd{?} is defined to display a list of possible
 completions of what you have inserted.
 
-  For example, when @kbd{M-x} uses the minibuffer to read the name of a
-command, it provides a list of all available XEmacs command names to
-complete against.  The completion keys match the text in the minibuffer
-against all the command names, find any additional name characters
-implied by the ones already present in the minibuffer, and add those
-characters to the ones you have given.  This is what makes it possible
-to type @kbd{M-x inse @key{SPC} b @key{RET}} instead of @kbd{M-x
-insert-buffer @key{RET}} (for example).
+  For example, when the minibuffer is being used by @kbd{Meta-x} to read
+the name of a command, it is given a list of all available Emacs command
+names to complete against.  The completion keys match the text in the
+minibuffer against all the command names, find any additional characters of
+the name that are implied by the ones already present in the minibuffer,
+and add those characters to the ones you have given.
 
-  Case is normally significant in completion because it is significant
-in most of the names that you can complete (buffer names, file names and
-command names).  Thus, @samp{fo} does not complete to @samp{Foo}.  When
-you are completing a name in which case does not matter, case may be
-ignored for completion's sake if specified by program.
+  Case is normally significant in completion because it is significant in
+most of the names that you can complete (buffer names, file names, and
+command names).  Thus, @samp{fo} will not complete to @samp{Foo}.  When you
+are completing a name in which case does not matter, case may be ignored
+for completion's sake if specified by program.
 
 When a completion list is displayed, the completions will highlight as
 you move the mouse over them.  Clicking the middle mouse button on any 
 highlighted completion will ``select'' it just as if you had typed it in
 and hit @key{RET}.
 
-@menu
-* Example: Completion Example.
-* Commands: Completion Commands.
-* Strict Completion::
-* Options: Completion Options.
-@end menu
-
-@node Completion Example, Completion Commands, Completion, Completion
-@subsection Completion Example
+@subsection A Completion Example
 
 @kindex TAB
 @findex minibuffer-complete
-  A concrete example may help here.  If you type @kbd{M-x au @key{TAB}},
-the @key{TAB} looks for alternatives (in this case, command names) that
-start with @samp{au}.  There are several, including
-@code{auto-fill-mode} and @code{auto-save-mode}---but they are all the
-same as far as @code{auto}, so the @samp{au} in the minibuffer changes
-to @samp{auto}.
+  Consider the following example.  If you type @kbd{Meta-x au @key{TAB}},
+@key{TAB} looks for alternatives (in this case, command names) that
+start with @samp{au}.  There are only two commands: @code{auto-fill-mode} and
+@code{auto-save-mode}.  They are the same as far as @code{auto-}, so the
+@samp{au} in the minibuffer changes to @samp{auto-}.@refill
 
-  If you type @key{TAB} again immediately, there are multiple
-possibilities for the very next character---it could be any of
-@samp{c-}---so no more characters are added; instead, @key{TAB}
-displays a list of all possible completions in another window.
+  If you type @key{TAB} again immediately, there are multiple possibilities
+for the very next character---it could be @samp{s} or @samp{f}---so no more
+characters are added; but a list of all possible completions is displayed
+in another window.
 
-  If you go on to type @kbd{-f @key{TAB}}, this @key{TAB} sees
+  If you go on to type @kbd{f @key{TAB}}, this @key{TAB} sees
 @samp{auto-f}.  The only command name starting this way is
-@code{auto-fill-mode}, so completion fills in the rest of that.  You now
-have @samp{auto-fill-mode} in the minibuffer after typing just @kbd{au
-@key{TAB} f @key{TAB}}.  Note that @key{TAB} has this effect because in
-the minibuffer it is bound to the command @code{minibuffer-complete}
-when completion is available.
+@code{auto-fill-mode}, so completion inserts the rest of that command.  You
+now have @samp{auto-fill-mode} in the minibuffer after typing just @kbd{au
+@key{TAB} f @key{TAB}}.  Note that @key{TAB} has this effect because in the
+minibuffer it is bound to the function @code{minibuffer-complete} when
+completion is supposed to be done.@refill
 
-@node Completion Commands, Strict Completion, Completion Example, Completion
 @subsection Completion Commands
 
-  Here is a list of the completion commands defined in the minibuffer
+  Here is a list of all the completion commands defined in the minibuffer
 when completion is available.
 
 @table @kbd
 @item @key{TAB}
-Complete the text in the minibuffer as much as possible
+Complete the text in the minibuffer as much as possible @*
 (@code{minibuffer-complete}).
 @item @key{SPC}
-Complete the minibuffer text, but don't go beyond one word
-(@code{minibuffer-complete-word}).
+Complete the text in the minibuffer but don't add or fill out more
+than one word (@code{minibuffer-complete-word}).
 @item @key{RET}
 Submit the text in the minibuffer as the argument, possibly completing
 first as described below (@code{minibuffer-complete-and-exit}).
@@ -268,60 +244,14 @@
 
 @kindex SPC
 @findex minibuffer-complete-word
-  @key{SPC} completes much like @key{TAB}, but never goes beyond the
-next hyphen or space.  If you have @samp{auto-f} in the minibuffer and
-type @key{SPC}, it finds that the completion is @samp{auto-fill-mode},
-but it stops completing after @samp{fill-}.  This gives
-@samp{auto-fill-}.  Another @key{SPC} at this point completes all the
-way to @samp{auto-fill-mode}.  @key{SPC} in the minibuffer when
-completion is available runs the command
-@code{minibuffer-complete-word}.
-
-  Here are some commands you can use to choose a completion from a
-window that displays a list of completions:
-
-@table @kbd
-@findex mouse-choose-completion
-@item button2up
-Clicking mouse button 2 on a completion in the list of possible
-completions chooses that completion (@code{mouse-choose-completion}).
-You normally use this command while point is in the minibuffer; but you
-must click in the list of completions, not in the minibuffer itself.
-
-@findex switch-to-completions
-@item @key{PRIOR}
-@itemx M-v
-Typing @key{PRIOR} or @kbd{M-v}, while in the minibuffer, selects the
-window showing the completion list buffer
-(@code{switch-to-completions}).  This paves the way for using the
-commands below.  (Selecting that window in the usual ways has the same
-effect, but this way is more convenient.)
-
-@findex choose-completion
-@item @key{RET}
-Typing @key{RET} @emph{in the completion list buffer} chooses the
-completion that point is in or next to (@code{choose-completion}).  To
-use this command, you must first switch windows to the window that shows
-the list of completions.
-
-@findex next-list-mode-item
-@item @key{RIGHT}
-@itemx @key{TAB}
-@itemx C-f
-Typing the right-arrow key @key{RIGHT}, @key{TAB} or @kbd{C-f} @emph{in
-the completion list buffer} moves point to the following completion
-(@code{next-list-mode-item}).
-
-@findex previous-list-mode-item
-@item @key{LEFT}
-@itemx C-b
-Typing the left-arrow key @key{LEFT} or @kbd{C-b} @emph{in the
-completion list buffer} moves point toward the beginning of the buffer,
-to the previous completion (@code{previous-list-mode-item}).
-@end table
-
-@node Strict Completion, Completion Options, Completion Commands, Completion
-@subsection Strict Completion
+@key{SPC} completes in a way that is similar to @key{TAB}, but it never
+goes beyond the next hyphen or space.  If you have @samp{auto-f} in the 
+minibuffer and type @key{SPC}, it finds that the completion is
+ @samp{auto-fill-mode}, but it stops completing after @samp{fill-}. 
+The result is @samp{auto-fill-}. Another @key{SPC} at this point
+completes all the way to @samp{auto-fill-mode}.  @key{SPC} in the
+minibuffer runs the function @code{minibuffer-complete-word} when 
+completion is available.@refill
 
   There are three different ways that @key{RET} can work in completing
 minibuffers, depending on how the argument will be used.
@@ -346,7 +276,7 @@
 already exist.
 
 @item
-@dfn{Permissive} completion is used when any string whatever is
+@dfn{Permissive} completion is used when any string is
 meaningful, and the list of completion alternatives is just a guide.
 For example, when @kbd{C-x C-f} reads the name of a file to visit, any
 file name is allowed, in case you want to create a file.  In
@@ -354,26 +284,21 @@
 exactly as given, without completing it.
 @end itemize
 
-  The completion commands display a list of all possible completions in
-a window whenever there is more than one possibility for the very next
-character.  Also, typing @kbd{?} explicitly requests such a list.  If
-the list of completions is long, you can scroll it with @kbd{C-M-v}
-(@pxref{Other Window}).
-
-@node Completion Options,  , Strict Completion, Completion
-@subsection Completion Options
+  The completion commands display a list of all possible completions in a
+window whenever there is more than one possibility for the very next
+character.  Typing @kbd{?} explicitly requests such a list.  The
+list of completions counts as help text, so @kbd{C-M-v} typed in the
+minibuffer scrolls the list.
 
 @vindex completion-ignored-extensions
   When completion is done on file names, certain file names are usually
-ignored.  The variable @code{completion-ignored-extensions} contains a
-list of strings; a file whose name ends in any of those strings is
-ignored as a possible completion.  The standard value of this variable
-has several elements including @code{".o"}, @code{".elc"}, @code{".dvi"}
-and @code{"~"}.  The effect is that, for example, @samp{foo} can
-complete to @samp{foo.c} even though @samp{foo.o} exists as well.
-However, if @emph{all} the possible completions end in ``ignored''
-strings, then they are not ignored.  Ignored extensions do not apply to
-lists of completions---those always mention all possible completions.
+ignored.  The variable @code{completion-ignored-extensions} contains a list
+of strings; a file whose name ends in any of those strings is ignored as a
+possible completion.  The standard value of this variable has several
+elements including @code{".o"}, @code{".elc"}, @code{".dvi"} and @code{"~"}.
+The effect is that, for example, @samp{foo} completes to @samp{foo.c}
+even though @samp{foo.o} exists as well.  If the only possible completions
+are files that end in ``ignored'' strings, they are not ignored.@refill
 
 @vindex completion-auto-help
   If a completion command finds the next character is undetermined, it
@@ -387,141 +312,47 @@
 not valid completions, an extra @key{RET} must be typed to confirm the
 response.  This is helpful for catching typos.
 
-@cindex Icomplete mode
-  Icomplete mode presents a constantly-updated display that tells you
-what completions are available for the text you've entered so far.  The
-command to enable or disable this minor mode is @kbd{M-x
-icomplete-mode}.
-
-@node Minibuffer History, Repetition, Completion, Minibuffer
-@section Minibuffer History
-@cindex minibuffer history
-@cindex history of minibuffer input
-
-  Every argument that you enter with the minibuffer is saved on a
-@dfn{minibuffer history list} so that you can use it again later in
-another argument.  Special commands load the text of an earlier argument
-in the minibuffer.  They discard the old minibuffer contents, so you can
-think of them as moving through the history of previous arguments.
-
-@table @kbd
-@item @key{UP}
-@itemx M-p
-Move to the next earlier argument string saved in the minibuffer history
-(@code{previous-history-element}).
-@item @key{DOWN}
-@itemx M-n
-Move to the next later argument string saved in the minibuffer history
-(@code{next-history-element}).
-@item M-r @var{regexp} @key{RET}
-Move to an earlier saved argument in the minibuffer history that has a
-match for @var{regexp} (@code{previous-matching-history-element}).
-@item M-s @var{regexp} @key{RET}
-Move to a later saved argument in the minibuffer history that has a
-match for @var{regexp} (@code{next-matching-history-element}).
-@end table
-
-@kindex M-p @r{(minibuffer history)}
-@kindex M-n @r{(minibuffer history)}
-@findex next-history-element
-@findex previous-history-element
-  The simplest way to reuse the saved arguments in the history list is
-to move through the history list one element at a time.  While in the
-minibuffer, use @kbd{M-p} or up-arrow (@code{previous-history-element})
-to ``move to'' the next earlier minibuffer input, and use @kbd{M-n} or
-down-arrow (@code{next-history-element}) to ``move to'' the next later
-input.
-
-  The previous input that you fetch from the history entirely replaces
-the contents of the minibuffer.  To use it as the argument, exit the
-minibuffer as usual with @key{RET}.  You can also edit the text before
-you reuse it; this does not change the history element that you
-``moved'' to, but your new argument does go at the end of the history
-list in its own right.
-
-  For many minibuffer arguments there is a ``default'' value.  In some
-cases, the minibuffer history commands know the default value.  Then you
-can insert the default value into the minibuffer as text by using
-@kbd{M-n} to move ``into the future'' in the history.
-
-@findex previous-matching-history-element
-@findex next-matching-history-element
-@kindex M-r @r{(minibuffer history)}
-@kindex M-s @r{(minibuffer history)}
-  There are also commands to search forward or backward through the
-history; they search for history elements that match a regular
-expression that you specify with the minibuffer.  @kbd{M-r}
-(@code{previous-matching-history-element}) searches older elements in
-the history, while @kbd{M-s} (@code{next-matching-history-element})
-searches newer elements.  By special dispensation, these commands can
-use the minibuffer to read their arguments even though you are already
-in the minibuffer when you issue them.  As with incremental searching,
-an uppercase letter in the regular expression makes the search
-case-sensitive (@pxref{Search Case}).
-
-  All uses of the minibuffer record your input on a history list, but
-there are separate history lists for different kinds of arguments.  For
-example, there is a list for file names, used by all the commands that
-read file names.
-
-  There are several other very specific history lists, including one for
-command names read by @kbd{M-x}, one for buffer names, one for arguments
-of commands like @code{query-replace}, and one for compilation commands
-read by @code{compile}.  Finally, there is one ``miscellaneous'' history
-list that most minibuffer arguments use.
-
-@c Do wee need this?
-@ignore
-@vindex history-length
-  The variable @code{history-length} specifies the maximum length of a
-minibuffer history list; once a list gets that long, the oldest element
-is deleted each time an element is added.  If the value of
-@code{history-length} is @code{t}, though, there is no maximum length
-and elements are never deleted.
-@end ignore
-
-@node Repetition,  , Minibuffer History, Minibuffer
+@node Repetition,, Completion, Minibuffer
 @section Repeating Minibuffer Commands
 @cindex command history
 @cindex history of commands
 
   Every command that uses the minibuffer at least once is recorded on a
-special history list, together with the values of its arguments, so that
-you can repeat the entire command.  In particular, every use of
-@kbd{M-x} is recorded there, since @kbd{M-x} uses the minibuffer to read
-the command name.
+special history list, together with the values of the minibuffer arguments,
+so that you can repeat the command easily.  In particular, every
+use of @kbd{Meta-x} is recorded, since @kbd{M-x} uses the minibuffer to
+read the command name.
 
 @findex list-command-history
 @c widecommands
 @table @kbd
-@item C-x @key{ESC} @key{ESC}
-Re-execute a recent minibuffer command (@code{repeat-complex-command}).
+@item C-x @key{ESC}
+Re-execute a recent minibuffer command @*(@code{repeat-complex-command}).
 @item M-p
-Within @kbd{C-x @key{ESC} @key{ESC}}, move to previous recorded command
+Within @kbd{C-x @key{ESC}}, move to previous recorded command
 (@code{previous-history-element}).
 @item M-n
-Within @kbd{C-x @key{ESC} @key{ESC}}, move to the next (more recent)
-recorded command (@code{next-history-element}).
+Within @kbd{C-x @key{ESC}}, move to the next (more recent) recorded
+command (@code{next-history-element}).@refill
 @item M-x list-command-history
 Display the entire command history, showing all the commands
-@kbd{C-x @key{ESC} @key{ESC}} can repeat, most recent first.
+@kbd{C-x @key{ESC}} can repeat, most recent first.@refill
 @end table
 
-@kindex C-x ESC ESC
+@kindex C-x ESC
 @findex repeat-complex-command
-  @kbd{C-x @key{ESC} @key{ESC}} is used to re-execute a recent
-minibuffer-using command.  With no argument, it repeats the last such
-command.  A numeric argument specifies which command to repeat; one
-means the last one, and larger numbers specify earlier ones.
+  @kbd{C-x @key{ESC}} is used to re-execute a recent command that used
+the minibuffer. With no argument, it repeats the last command.  A numeric
+argument specifies which command to repeat; 1 means the last one, and
+larger numbers specify earlier commands.
 
-  @kbd{C-x @key{ESC} @key{ESC}} works by turning the previous command
-into a Lisp expression and then entering a minibuffer initialized with
-the text for that expression.  If you type just @key{RET}, the command
-is repeated as before.  You can also change the command by editing the
-Lisp expression.  Whatever expression you finally submit is what will be
-executed.  The repeated command is added to the front of the command
-history unless it is identical to the most recently executed command
-already there.
+  @kbd{C-x @key{ESC}} works by turning the previous command into a Lisp
+expression and then entering a minibuffer initialized with the text for
+that expression.  If you type just @key{RET}, the command is repeated as
+before.  You can also change the command by editing the Lisp expression.
+The expression you finally submit will be executed.  The repeated
+command is added to the front of the command history unless it is
+identical to the most recently executed command already there.
 
   Even if you don't understand Lisp syntax, it will probably be obvious
 which command is displayed for repetition.  If you do not change the text,
@@ -531,17 +362,17 @@
 @kindex M-p
 @findex next-complex-command
 @findex previous-complex-command
-  If you are in the minibuffer for @kbd{C-x @key{ESC} @key{ESC}} and the
-command shown to you is not the one you want to repeat, you can move
-around the list of previous commands using @kbd{M-n} and @kbd{M-p}.
-@kbd{M-p} replaces the contents of the minibuffer with the next earlier
-recorded command, and @kbd{M-n} replaces it with the next later command.
-After finding the desired previous command, you can edit its expression
-and then resubmit it by typing @key{RET}.  Any editing you have done on
-the command to be repeated is lost if you use @kbd{M-n} or @kbd{M-p}.
+  If you are in the minibuffer for @kbd{C-x @key{ESC}} and the command shown
+to you is not the one you want to repeat, you can move around the list of
+previous commands using @kbd{M-n} and @kbd{M-p}.  @kbd{M-p} replaces the
+contents of the minibuffer with the next earlier recorded command, and
+@kbd{M-n} replaces it with the next later command.  After finding the
+desired previous command, you can edit its expression and then
+resubmit it by typing @key{RET}.  Any editing you have done on the
+command to be repeated is lost if you use @kbd{M-n} or @kbd{M-p}.
 
-@kbd{M-n} and @kbd{M-p} are specially defined within @kbd{C-x @key{ESC}
-@key{ESC}} to run the commands @code{previous-history-element} and
+@kbd{M-n} and @kbd{M-p} are specially defined within @kbd{C-x @key{ESC}}
+to run the commands @code{previous-history-element} and
 @code{next-history-element}.
 
 @vindex command-history