#

1 files changed, 1834 insertions, 0 deletions

diff --git a/man/misc.texi b/man/misc.texi
new file mode 100644
index 00000000000..996317adab9
--- /dev/null
+++ b/man/misc.texi
@@ -0,0 +1,1834 @@
+@c This is part of the Emacs manual.
+@c Copyright (C) 1985, 86, 87, 93, 94, 95, 1997 Free Software Foundation, Inc.
+@c See file emacs.texi for copying conditions.
+@iftex
+@chapter Miscellaneous Commands
+
+  This chapter contains several brief topics that do not fit anywhere
+else: reading netnews, running shell commands and shell subprocesses,
+using a single shared Emacs for utilities that expect to run an editor
+as a subprocess, printing hardcopy, sorting text, narrowing display to
+part of the buffer, editing double-column files and binary files, saving
+an Emacs session for later resumption, emulating other editors, and
+various diversions and amusements.
+
+@end iftex
+@node Gnus, Shell, Calendar/Diary, Top
+@section Gnus
+@cindex Gnus
+@cindex reading netnews
+
+Gnus is an Emacs package primarily designed for reading and posting
+Usenet news.  It can also be used to read and respond to messages from a
+number of other sources---mail, remote directories, digests, and so on.
+
+Here we introduce Gnus and describe several basic features.
+@ifinfo
+For full details, see @ref{Top, Gnus,, gnus, The Gnus Manual}.
+@end ifinfo
+@iftex
+For full details on Gnus, type @kbd{M-x info} and then select the Gnus
+manual.
+@end iftex
+
+@findex gnus
+To start Gnus, type @kbd{M-x gnus @key{RET}}.
+
+@menu
+* Buffers of Gnus::	The group, summary, and article buffers.
+* Gnus Startup::	What you should know about starting Gnus.
+* Summary of Gnus::	A short description of the basic Gnus commands.
+@end menu
+
+@node Buffers of Gnus
+@subsection Gnus Buffers
+
+As opposed to most normal Emacs packages, Gnus uses a number of
+different buffers to display information and to receive commands.  The
+three buffers users spend most of their time in are the @dfn{group
+buffer}, the @dfn{summary buffer} and the @dfn{article buffer}.  
+
+The @dfn{group buffer} contains a list of groups.  This is the first
+buffer Gnus displays when it starts up.  It normally displays only the
+groups to which you subscribe and that contain unread articles.  Use
+this buffer to select a specific group.
+
+The @dfn{summary buffer} lists one line for each article in a single
+group.  By default, the author, the subject and the line number are
+displayed for each article, but this is customizable, like most aspects
+of Gnus display.  The summary buffer is created when you select a group
+in the group buffer, and is killed when you exit the group.  Use this
+buffer to select an article.
+
+The @dfn{article buffer} displays the article.  In normal Gnus usage,
+you don't select this buffer---all useful article-oriented commands work
+in the summary buffer.  But you can select the article buffer, and
+execute all Gnus commands from that buffer, if you want to.
+
+@node Gnus Startup
+@subsection When Gnus Starts Up
+
+At startup, Gnus reads your @file{.newsrc} news initialization file
+and attempts to communicate with the local news server, which is a
+repository of news articles.  The news server need not be the same
+computer you are logged in on.
+
+If you start Gnus and connect to the server, but do not see any
+newsgroups listed in the group buffer, type @kbd{L} or @kbd{A k} to get
+a listing of all the groups.  Then type @kbd{u} to toggle
+subscription to groups.
+
+The first time you start Gnus, Gnus subscribes you to a few selected
+groups.  All other groups start out as @dfn{killed groups} for you; you
+can list them with @kbd{A k}.  All new groups that subsequently come to
+exist at the news server become @dfn{zombie groups} for you; type @kbd{A
+z} to list them.  You can subscribe to a group shown in these lists
+using the @kbd{u} command.
+
+When you quit Gnus with @kbd{q}, it automatically records in your
+@file{.newsrc} and @file{.newsrc.eld} initialization files the
+subscribed or unsubscribed status of all groups.  You should normally
+not edit these files manually, but you may if you know how.
+
+@node Summary of Gnus
+@subsection Summary of Gnus Commands
+
+Reading news is a two step process:
+
+@enumerate
+@item
+Choose a group in the group buffer.
+
+@item
+Select articles from the summary buffer.  Each article selected is
+displayed in the article buffer in a large window, below the summary
+buffer in its small window.
+@end enumerate
+
+  Each Gnus buffer has its own special commands; however, the meanings
+of any given key in the various Gnus buffers are usually analogous, even
+if not identical.  Here are commands for the group and summary buffers:
+
+@table @kbd
+@kindex q @r{(Gnus Group mode)}
+@findex gnus-group-exit
+@item q
+In the group buffer, update your @file{.newsrc} initialization file
+and quit Gnus.
+
+In the summary buffer, exit the current group and return to the
+group buffer.  Thus, typing @kbd{q} twice quits Gnus.
+
+@kindex L @r{(Gnus Group mode)}
+@findex gnus-group-list-all-groups
+@item L
+In the group buffer, list all the groups available on your news
+server (except those you have killed).  This may be a long list!
+
+@kindex l @r{(Gnus Group mode)}
+@findex gnus-group-list-groups
+@item l
+In the group buffer, list only the groups to which you subscribe and
+which contain unread articles.
+
+@kindex u @r{(Gnus Group mode)}
+@findex gnus-group-unsubscribe-current-group
+@cindex subscribe groups
+@cindex unsubscribe groups
+@item u
+In the group buffer, unsubscribe from (or subscribe to) the group listed
+in the line that point is on.  When you quit Gnus by typing @kbd{q},
+Gnus lists in your @file{.newsrc} file which groups you have subscribed
+to.  The next time you start Gnus, you won't see this group,
+because Gnus normally displays only subscribed-to groups.
+
+@kindex C-k @r{(Gnus)}
+@findex gnus-group-kill-group
+@item C-k
+In the group buffer, ``kill'' the current line's group---don't
+even list it in @file{.newsrc} from now on.  This affects future
+Gnus sessions as well as the present session.
+
+When you quit Gnus by typing @kbd{q}, Gnus writes information
+in the file @file{.newsrc} describing all newsgroups except those you
+have ``killed.''
+
+@kindex SPC @r{(Gnus)}
+@findex gnus-group-read-group
+@item @key{SPC}
+In the group buffer, select the group on the line under the cursor
+and display the first unread article in that group.
+
+@need 1000
+In the summary buffer, 
+
+@itemize @bullet
+@item
+Select the article on the line under the cursor if none is selected.
+
+@item
+Scroll the text of the selected article (if there is one).
+
+@item
+Select the next unread article if at the end of the current article.
+@end itemize
+
+Thus, you can move through all the articles by repeatedly typing @key{SPC}.
+
+@kindex DEL @r{(Gnus)}
+@item @key{DEL}
+In the group buffer, move point to the previous group containing
+unread articles.
+
+@findex gnus-summary-prev-page
+In the summary buffer, scroll the text of the article backwards.
+
+@kindex n @r{(Gnus)}
+@findex gnus-group-next-unread-group
+@findex gnus-summary-next-unread-article
+@item n
+Move point to the next unread group, or select the next unread article.
+
+@kindex p @r{(Gnus)}
+@findex gnus-group-prev-unread-group
+@findex gnus-summary-prev-unread-article
+@item p
+Move point to the previous unread group, or select the previous
+unread article.
+
+@kindex C-n @r{(Gnus Group mode)}
+@findex gnus-group-next-group
+@kindex C-p @r{(Gnus Group mode)}
+@findex gnus-group-prev-group
+@kindex C-n @r{(Gnus Summary mode)}
+@findex gnus-summary-next-subject
+@kindex C-p @r{(Gnus Summary mode)}
+@findex gnus-summary-prev-subject
+@item C-n
+@itemx C-p
+Move point to the next or previous item, even if it is marked as read.
+This does not select the article or group on that line.
+
+@kindex s @r{(Gnus Summary mode)}
+@findex gnus-summary-isearch-article
+@item s
+In the summary buffer, do an incremental search of the current text in
+the article buffer, just as if you switched to the article buffer and
+typed @kbd{C-s}.
+
+@kindex M-s @r{(Gnus Summary mode)}
+@findex gnus-summary-search-article-forward
+@item M-s @var{regexp} @key{RET}
+In the summary buffer, search forward for articles containing a match
+for @var{regexp}.
+
+@end table
+
+@ignore
+@node Where to Look
+@subsection Where to Look Further
+
+@c Too many references to the name of the manual if done with xref in TeX!
+Gnus is powerful and customizable.  Here are references to a few
+@ifinfo
+additional topics:
+
+@end ifinfo
+@iftex
+additional topics in @cite{The Gnus Manual}:
+
+@itemize @bullet
+@item
+Follow discussions on specific topics.@*
+See section ``Threading.''
+
+@item
+Read digests.  See section ``Document Groups.''
+
+@item
+Refer to and jump to the parent of the current article.@*
+See section ``Finding the Parent.''
+
+@item
+Refer to articles by using Message-IDs included in the messages.@*
+See section ``Article Keymap.''
+
+@item
+Save articles.  See section ``Saving Articles.''
+
+@item
+Have Gnus score articles according to various criteria, like author
+name, subject, or string in the body of the articles.@*
+See section ``Scoring.''
+
+@item
+Send an article to a newsgroup.@*
+See section ``Composing Messages.''
+@end itemize
+@end iftex
+@ifinfo
+@itemize @bullet
+@item
+Follow discussions on specific topics.@*
+@xref{Threading, , Reading Based on Conversation Threads,
+gnus, The Gnus Manual}.
+
+@item
+Read digests. @xref{Document Groups, , , gnus, The Gnus Manual}.
+
+@item
+Refer to and jump to the parent of the current article.@*
+@xref{Finding the Parent, , , gnus, The Gnus Manual}.
+
+@item
+Refer to articles by using Message-IDs included in the messages.@*
+@xref{Article Keymap, , , gnus, The Gnus Manual}.
+
+@item
+Save articles. @xref{Saving Articles, , , gnus, The Gnus Manual}.
+
+@item
+Have Gnus score articles according to various criteria, like author
+name, subject, or string in the body of the articles.@*
+@xref{Scoring, , , gnus, The Gnus Manual}. 
+
+@item
+Send an article to a newsgroup.@*
+@xref{Composing Messages, , , gnus, The Gnus Manual}.
+@end itemize
+@end ifinfo
+@end ignore
+
+@node Shell, Emacs Server, Gnus, Top
+@section Running Shell Commands from Emacs
+@cindex subshell
+@cindex shell commands
+
+  Emacs has commands for passing single command lines to inferior shell
+processes; it can also run a shell interactively with input and output to
+an Emacs buffer named @samp{*shell*}.
+
+@table @kbd
+@item M-! @var{cmd} @key{RET}
+Run the shell command line @var{cmd} and display the output
+(@code{shell-command}).
+@item M-| @var{cmd} @key{RET}
+Run the shell command line @var{cmd} with region contents as input;
+optionally replace the region with the output
+(@code{shell-command-on-region}).
+@item M-x shell
+Run a subshell with input and output through an Emacs buffer.
+You can then give commands interactively.
+@end table
+
+@menu
+* Single Shell::           How to run one shell command and return.
+* Interactive Shell::      Permanent shell taking input via Emacs.
+* Shell Mode::             Special Emacs commands used with permanent shell.
+* History: Shell History.  Repeating previous commands in a shell buffer.
+* Options: Shell Options.  Options for customizing Shell mode.
+* Remote Host::            Connecting to another computer.
+@end menu
+
+@node Single Shell
+@subsection Single Shell Commands
+
+@kindex M-!
+@findex shell-command
+  @kbd{M-!} (@code{shell-command}) reads a line of text using the
+minibuffer and executes it as a shell command in a subshell made just
+for that command.  Standard input for the command comes from the null
+device.  If the shell command produces any output, the output goes into
+an Emacs buffer named @samp{*Shell Command Output*}, which is displayed
+in another window but not selected.  A numeric argument, as in @kbd{M-1
+M-!}, directs this command to insert any output into the current buffer.
+In that case, point is left before the output and the mark is set after
+the output.
+
+  If the shell command line ends in @samp{&}, it runs asynchronously.
+For a synchronous shell command, @code{shell-command} returns the
+command's exit status (0 means success), when it is called from a Lisp
+program.
+
+@kindex M-|
+@findex shell-command-on-region
+  @kbd{M-|} (@code{shell-command-on-region}) is like @kbd{M-!} but
+passes the contents of the region as the standard input to the shell
+command, instead of no input.  If a numeric argument is used, meaning
+insert the output in the current buffer, then the old region is deleted
+first and the output replaces it as the contents of the region.  It
+returns the command's exit status when it is called from a Lisp program.
+
+@vindex shell-file-name
+@cindex environment
+  Both @kbd{M-!} and @kbd{M-|} use @code{shell-file-name} to specify the
+shell to use.  This variable is initialized based on your @code{SHELL}
+environment variable when Emacs is started.  If the file name does not
+specify a directory, the directories in the list @code{exec-path} are
+searched; this list is initialized based on the environment variable
+@code{PATH} when Emacs is started.  Your @file{.emacs} file can override
+either or both of these default initializations.@refill
+
+  Both @kbd{M-!} and @kbd{M-|} wait for the shell command to complete.
+To stop waiting, type @kbd{C-g} to quit; that terminates the shell
+command with the signal @code{SIGINT}---the same signal that @kbd{C-c}
+normally generates in the shell.  Emacs waits until the command actually
+terminates.  If the shell command doesn't stop (because it ignores the
+@code{SIGINT} signal), type @kbd{C-g} again; this sends the command a
+@code{SIGKILL} signal which is impossible to ignore.
+
+  To specify a coding system for @kbd{M-!} or @kbd{M-|}, use the command
+@kbd{C-x @key{RET} c} immediately beforehand.  @xref{Specify Coding}.
+
+@vindex shell-command-default-error-buffer
+  Error output from the command is normally intermixed with the regular
+output.  If you set the variable
+@code{shell-command-default-error-buffer} to a string, which is a buffer
+name, error output is inserted before point in the buffer of that name.
+
+@node Interactive Shell
+@subsection Interactive Inferior Shell
+
+@findex shell
+  To run a subshell interactively, putting its typescript in an Emacs
+buffer, use @kbd{M-x shell}.  This creates (or reuses) a buffer named
+@samp{*shell*} and runs a subshell with input coming from and output going
+to that buffer.  That is to say, any ``terminal output'' from the subshell
+goes into the buffer, advancing point, and any ``terminal input'' for
+the subshell comes from text in the buffer.  To give input to the subshell,
+go to the end of the buffer and type the input, terminated by @key{RET}.
+
+  Emacs does not wait for the subshell to do anything.  You can switch
+windows or buffers and edit them while the shell is waiting, or while it is
+running a command.  Output from the subshell waits until Emacs has time to
+process it; this happens whenever Emacs is waiting for keyboard input or
+for time to elapse.
+
+  To make multiple subshells, rename the buffer @samp{*shell*} to
+something different using @kbd{M-x rename-uniquely}.  Then type @kbd{M-x
+shell} again to create a new buffer @samp{*shell*} with its own
+subshell.  If you rename this buffer as well, you can create a third
+one, and so on.  All the subshells run independently and in parallel.
+
+@vindex explicit-shell-file-name
+@cindex @code{ESHELL} environment variable
+@cindex @code{SHELL} environment variable
+  The file name used to load the subshell is the value of the variable
+@code{explicit-shell-file-name}, if that is non-@code{nil}.  Otherwise,
+the environment variable @code{ESHELL} is used, or the environment
+variable @code{SHELL} if there is no @code{ESHELL}.  If the file name
+specified is relative, the directories in the list @code{exec-path} are
+searched; this list is initialized based on the environment variable
+@code{PATH} when Emacs is started.  Your @file{.emacs} file can override
+either or both of these default initializations.
+
+  To specify a coding system for the shell, you can use the command
+@kbd{C-x @key{RET} c} immediately before @kbd{M-x shell}.  You can also
+specify a coding system after starting the shell by using @kbd{C-x
+@key{RET} p} in the shell buffer.  @xref{Specify Coding}.
+
+  As soon as the subshell is started, it is sent as input the contents
+of the file @file{~/.emacs_@var{shellname}}, if that file exists, where
+@var{shellname} is the name of the file that the shell was loaded from.
+For example, if you use bash, the file sent to it is
+@file{~/.emacs_bash}.
+
+@vindex shell-pushd-regexp
+@vindex shell-popd-regexp
+@vindex shell-cd-regexp
+  @code{cd}, @code{pushd} and @code{popd} commands given to the inferior
+shell are watched by Emacs so it can keep the @samp{*shell*} buffer's
+default directory the same as the shell's working directory.  These
+commands are recognized syntactically by examining lines of input that are
+sent.  If you use aliases for these commands, you can tell Emacs to
+recognize them also.  For example, if the value of the variable
+@code{shell-pushd-regexp} matches the beginning of a shell command line,
+that line is regarded as a @code{pushd} command.  Change this variable when
+you add aliases for @samp{pushd}.  Likewise, @code{shell-popd-regexp} and
+@code{shell-cd-regexp} are used to recognize commands with the meaning of
+@samp{popd} and @samp{cd}.  These commands are recognized only at the
+beginning of a shell command line.@refill
+
+@vindex shell-set-directory-error-hook
+  If Emacs gets an error while trying to handle what it believes is a
+@samp{cd}, @samp{pushd} or @samp{popd} command, it runs the hook
+@code{shell-set-directory-error-hook} (@pxref{Hooks}).
+
+@findex dirs
+  If Emacs does not properly track changes in the current directory of
+the subshell, use the command @kbd{M-x dirs} to ask the shell what its
+current directory is.  This command works for shells that support the
+most common command syntax; it may not work for unusual shells.
+
+@findex dirtrack-mode
+  You can also use @kbd{M-x dirtrack-mode} to enable (or disable) an
+alternative and more aggressive method of tracking changes in the
+current directory.
+
+  Emacs defines the environment variable @code{EMACS} in the subshell,
+with value @code{t}.  A shell script can check this variable to
+determine whether it has been run from an Emacs subshell.
+
+@node Shell Mode
+@subsection Shell Mode
+@cindex Shell mode
+@cindex mode, Shell
+
+  Shell buffers use Shell mode, which defines several special keys
+attached to the @kbd{C-c} prefix.  They are chosen to resemble the usual
+editing and job control characters present in shells that are not under
+Emacs, except that you must type @kbd{C-c} first.  Here is a complete list
+of the special key bindings of Shell mode:
+
+@table @kbd
+@item @key{RET}
+@kindex RET @r{(Shell mode)}
+@findex comint-send-input
+At end of buffer send line as input; otherwise, copy current line to end
+of buffer and send it (@code{comint-send-input}).  When a line is
+copied, any text at the beginning of the line that matches the variable
+@code{shell-prompt-pattern} is left out; this variable's value should be
+a regexp string that matches the prompts that your shell uses.
+
+@item @key{TAB}
+@kindex TAB @r{(Shell mode)}
+@findex comint-dynamic-complete
+Complete the command name or file name before point in the shell buffer
+(@code{comint-dynamic-complete}).  @key{TAB} also completes history
+references (@pxref{History References}) and environment variable names.
+
+@vindex shell-completion-fignore
+@vindex comint-completion-fignore
+The variable @code{shell-completion-fignore} specifies a list of file
+name extensions to ignore in Shell mode completion.  The default setting
+ignores file names ending in @samp{~}, @samp{#} or @samp{%}.  Other
+related Comint modes use the variable @code{comint-completion-fignore}
+instead.
+
+@item M-?
+@kindex M-? @r{(Shell mode)}
+@findex comint-dynamic-list-filename@dots{}
+Display temporarily a list of the possible completions of the file name
+before point in the shell buffer
+(@code{comint-dynamic-list-filename-completions}).
+
+@item C-d
+@kindex C-d @r{(Shell mode)}
+@findex comint-delchar-or-maybe-eof
+Either delete a character or send @sc{EOF}
+(@code{comint-delchar-or-maybe-eof}).  Typed at the end of the shell
+buffer, @kbd{C-d} sends @sc{EOF} to the subshell.  Typed at any other
+position in the buffer, @kbd{C-d} deletes a character as usual.
+
+@item C-c C-a
+@kindex C-c C-a @r{(Shell mode)}
+@findex comint-bol
+Move to the beginning of the line, but after the prompt if any
+(@code{comint-bol}).  If you repeat this command twice in a row, the
+second time it moves back to the process mark, which is the beginning of
+the input that you have not yet sent to the subshell.  (Normally that is
+the same place---the end of the prompt on this line---but after @kbd{C-c
+@key{SPC}} the process mark may be in a previous line.)
+
+@item C-c @key{SPC}
+Accumulate multiple lines of input, then send them together.  This
+command inserts a newline before point, but does not send the preceding
+text as input to the subshell---at least, not yet.  Both lines, the one
+before this newline and the one after, will be sent together (along with
+the newline that separates them), when you type @key{RET}.
+
+@item C-c C-u
+@kindex C-c C-u @r{(Shell mode)}
+@findex comint-kill-input
+Kill all text pending at end of buffer to be sent as input
+(@code{comint-kill-input}).
+
+@item C-c C-w
+@kindex C-c C-w @r{(Shell mode)}
+Kill a word before point (@code{backward-kill-word}).
+
+@item C-c C-c
+@kindex C-c C-c @r{(Shell mode)}
+@findex comint-interrupt-subjob
+Interrupt the shell or its current subjob if any
+(@code{comint-interrupt-subjob}).  This command also kills
+any shell input pending in the shell buffer and not yet sent.
+
+@item C-c C-z
+@kindex C-c C-z @r{(Shell mode)}
+@findex comint-stop-subjob
+Stop the shell or its current subjob if any (@code{comint-stop-subjob}).
+This command also kills any shell input pending in the shell buffer and
+not yet sent.
+
+@item C-c C-\
+@findex comint-quit-subjob
+@kindex C-c C-\ @r{(Shell mode)}
+Send quit signal to the shell or its current subjob if any
+(@code{comint-quit-subjob}).  This command also kills any shell input
+pending in the shell buffer and not yet sent.
+
+@item C-c C-o
+@kindex C-c C-o @r{(Shell mode)}
+@findex comint-kill-output
+Kill the last batch of output from a shell command
+(@code{comint-kill-output}).  This is useful if a shell command spews
+out lots of output that just gets in the way.
+
+@item C-c C-r
+@itemx C-M-l
+@kindex C-c C-r @r{(Shell mode)}
+@kindex C-M-l @r{(Shell mode)}
+@findex comint-show-output
+Scroll to display the beginning of the last batch of output at the top
+of the window; also move the cursor there (@code{comint-show-output}).
+
+@item C-c C-e
+@kindex C-c C-e @r{(Shell mode)}
+@findex comint-show-maximum-output
+Scroll to put the end of the buffer at the bottom of the window
+(@code{comint-show-maximum-output}).
+
+@item C-c C-f
+@kindex C-c C-f @r{(Shell mode)}
+@findex shell-forward-command
+@vindex shell-command-regexp
+Move forward across one shell command, but not beyond the current line
+(@code{shell-forward-command}).  The variable @code{shell-command-regexp}
+specifies how to recognize the end of a command.
+
+@item C-c C-b
+@kindex C-c C-b @r{(Shell mode)}
+@findex shell-backward-command
+Move backward across one shell command, but not beyond the current line
+(@code{shell-backward-command}).
+
+@item C-c C-l
+@kindex C-c C-l @r{(Shell mode)}
+@findex comint-dynamic-list-input-ring
+Display the buffer's history of shell commands in another window
+(@code{comint-dynamic-list-input-ring}).
+
+@item M-x dirs
+Ask the shell what its current directory is, so that Emacs can agree
+with the shell.
+
+@item M-x send-invisible @key{RET} @var{text} @key{RET}
+@findex send-invisible
+Send @var{text} as input to the shell, after reading it without
+echoing.  This is useful when a shell command runs a program that asks
+for a password.
+
+Alternatively, you can arrange for Emacs to notice password prompts
+and turn off echoing for them, as follows:
+
+@example
+(add-hook 'comint-output-filter-functions
+          'comint-watch-for-password-prompt)
+@end example
+
+@item M-x comint-continue-subjob
+@findex comint-continue-subjob
+Continue the shell process.  This is useful if you accidentally suspend
+the shell process.@footnote{You should not suspend the shell process.
+Suspending a subjob of the shell is a completely different matter---that
+is normal practice, but you must use the shell to continue the subjob;
+this command won't do it.}
+
+@item M-x comint-strip-ctrl-m
+@findex comint-strip-ctrl-m
+Discard all control-M characters from the current group of shell output.
+The most convenient way to use this command is to make it run
+automatically when you get output from the subshell.  To do that,
+evaluate this Lisp expression:
+
+@example
+(add-hook 'comint-output-filter-functions
+          'comint-strip-ctrl-m)
+@end example
+
+@item M-x comint-truncate-buffer
+@findex comint-truncate-buffer
+This command truncates the shell buffer to a certain maximum number of
+lines, specified by the variable @code{comint-buffer-maximum-size}.
+Here's how to do this automatically each time you get output from the
+subshell:
+
+@example
+(add-hook 'comint-output-filter-functions
+          'comint-truncate-buffer)
+@end example
+@end table
+
+  Shell mode also customizes the paragraph commands so that only shell
+prompts start new paragraphs.  Thus, a paragraph consists of an input
+command plus the output that follows it in the buffer.
+
+@cindex Comint mode
+@cindex mode, Comint
+  Shell mode is a derivative of Comint mode, a general-purpose mode for
+communicating with interactive subprocesses.  Most of the features of
+Shell mode actually come from Comint mode, as you can see from the
+command names listed above.  The special features of Shell mode in
+particular include the choice of regular expression for detecting
+prompts, the directory tracking feature, and a few user commands.
+
+  Other Emacs features that use variants of Comint mode include GUD
+(@pxref{Debuggers}) and @kbd{M-x run-lisp} (@pxref{External Lisp}).
+
+@findex comint-run
+  You can use @kbd{M-x comint-run} to execute any program of your choice
+in a subprocess using unmodified Comint mode---without the
+specializations of Shell mode.
+
+@node Shell History
+@subsection Shell Command History
+
+  Shell buffers support three ways of repeating earlier commands.  You
+can use the same keys used in the minibuffer; these work much as they do
+in the minibuffer, inserting text from prior commands while point
+remains always at the end of the buffer.  You can move through the
+buffer to previous inputs in their original place, then resubmit them or
+copy them to the end.  Or you can use a @samp{!}-style history
+reference.
+
+@menu
+* Ring: Shell Ring.             Fetching commands from the history list.
+* Copy: Shell History Copying.  Moving to a command and then copying it.
+* History References::          Expanding @samp{!}-style history references.
+@end menu
+
+@node Shell Ring
+@subsubsection Shell History Ring
+
+@table @kbd
+@findex comint-previous-input
+@kindex M-p @r{(Shell mode)}
+@item M-p
+Fetch the next earlier old shell command.
+
+@kindex M-n @r{(Shell mode)}
+@findex comint-next-input
+@item M-n
+Fetch the next later old shell command.
+
+@kindex M-r @r{(Shell mode)}
+@kindex M-s @r{(Shell mode)}
+@findex comint-previous-matching-input
+@findex comint-next-matching-input
+@item M-r @var{regexp} @key{RET}
+@itemx M-s @var{regexp} @key{RET}
+Search backwards or forwards for old shell commands that match @var{regexp}.
+
+@item C-c C-x @r{(Shell mode)}
+@findex comint-get-next-from-history
+Fetch the next subsequent command from the history.
+@end table
+
+  Shell buffers provide a history of previously entered shell commands.  To
+reuse shell commands from the history, use the editing commands @kbd{M-p},
+@kbd{M-n}, @kbd{M-r} and @kbd{M-s}.  These work just like the minibuffer
+history commands except that they operate on the text at the end of the
+shell buffer, where you would normally insert text to send to the shell.
+
+  @kbd{M-p} fetches an earlier shell command to the end of the shell buffer.
+Successive use of @kbd{M-p} fetches successively earlier shell commands,
+each replacing any text that was already present as potential shell input.
+@kbd{M-n} does likewise except that it finds successively more recent shell
+commands from the buffer.
+
+  The history search commands @kbd{M-r} and @kbd{M-s} read a regular
+expression and search through the history for a matching command.  Aside
+from the choice of which command to fetch, they work just like @kbd{M-p}
+and @kbd{M-r}.  If you enter an empty regexp, these commands reuse the
+same regexp used last time.
+
+  When you find the previous input you want, you can resubmit it by
+typing @key{RET}, or you can edit it first and then resubmit it if you
+wish.
+
+  Often it is useful to reexecute several successive shell commands that
+were previously executed in sequence.  To do this, first find and
+reexecute the first command of the sequence.  Then type @kbd{C-c C-x};
+that will fetch the following command---the one that follows the command
+you just repeated.  Then type @key{RET} to reexecute this command.  You
+can reexecute several successive commands by typing @kbd{C-c C-x
+@key{RET}} over and over.
+
+  These commands get the text of previous shell commands from a special
+history list, not from the shell buffer itself.  Thus, editing the shell
+buffer, or even killing large parts of it, does not affect the history
+that these commands access.
+
+@vindex shell-input-ring-file-name
+  Some shells store their command histories in files so that you can
+refer to previous commands from previous shell sessions.  Emacs reads
+the command history file for your chosen shell, to initialize its own
+command history.  The file name is @file{~/.bash_history} for bash,
+@file{~/.sh_history} for ksh, and @file{~/.history} for other shells.
+
+@node Shell History Copying
+@subsubsection Shell History Copying
+
+@table @kbd
+@kindex C-c C-p @r{(Shell mode)}
+@findex comint-previous-prompt
+@item C-c C-p
+Move point to the previous prompt (@code{comint-previous-prompt}).
+
+@kindex C-c C-n @r{(Shell mode)}
+@findex comint-next-prompt
+@item C-c C-n
+Move point to the following prompt (@code{comint-next-prompt}).
+
+@kindex C-c RET @r{(Shell mode)}
+@findex comint-copy-old-input
+@item C-c @key{RET}
+Copy the input command which point is in, inserting the copy at the end
+of the buffer (@code{comint-copy-old-input}).  This is useful if you
+move point back to a previous command.  After you copy the command, you
+can submit the copy as input with @key{RET}.  If you wish, you can
+edit the copy before resubmitting it.
+@end table
+
+  Moving to a previous input and then copying it with @kbd{C-c
+@key{RET}} produces the same results---the same buffer contents---that
+you would get by using @kbd{M-p} enough times to fetch that previous
+input from the history list.  However, @kbd{C-c @key{RET}} copies the
+text from the buffer, which can be different from what is in the history
+list if you edit the input text in the buffer after it has been sent.
+
+@node History References
+@subsubsection Shell History References
+@cindex history reference
+
+  Various shells including csh and bash support @dfn{history references}
+that begin with @samp{!} and @samp{^}.  Shell mode can understand these
+constructs and perform the history substitution for you.  If you insert
+a history reference and type @key{TAB}, this searches the input history
+for a matching command, performs substitution if necessary, and places
+the result in the buffer in place of the history reference.  For
+example, you can fetch the most recent command beginning with @samp{mv}
+with @kbd{! m v @key{TAB}}.  You can edit the command if you wish, and
+then resubmit the command to the shell by typing @key{RET}.
+
+@vindex shell-prompt-pattern
+@vindex comint-prompt-regexp
+  History references take effect only following a shell prompt.  The
+variable @code{shell-prompt-pattern} specifies how to recognize a shell
+prompt.  Comint modes in general use the variable
+@code{comint-prompt-regexp} to specify how to find a prompt; Shell mode
+uses @code{shell-prompt-pattern} to set up the local value of
+@code{comint-prompt-regexp}.
+
+@vindex comint-input-autoexpand
+  Shell mode can optionally expand history references in the buffer when
+you send them to the shell.  To request this, set the variable
+@code{comint-input-autoexpand} to @code{input}.
+
+@findex comint-magic-space
+  You can make @key{SPC} perform history expansion by binding @key{SPC} to
+the command @code{comint-magic-space}.
+
+@node Shell Options
+@subsection Shell Mode Options
+
+@vindex comint-scroll-to-bottom-on-input
+  If the variable @code{comint-scroll-to-bottom-on-input} is
+non-@code{nil}, insertion and yank commands scroll the selected window
+to the bottom before inserting.
+
+@vindex comint-scroll-show-maximum-output
+  If @code{comint-scroll-show-maximum-output} is non-@code{nil}, then
+scrolling due to arrival of output tries to place the last line of text
+at the bottom line of the window, so as to show as much useful text as
+possible.  (This mimics the scrolling behavior of many terminals.)
+The default is @code{nil}.
+
+@vindex comint-scroll-to-bottom-on-output
+  By setting @code{comint-scroll-to-bottom-on-output}, you can opt for
+having point jump to the end of the buffer whenever output arrives---no
+matter where in the buffer point was before.  If the value is
+@code{this}, point jumps in the selected window.  If the value is
+@code{all}, point jumps in each window that shows the comint buffer.  If
+the value is @code{other}, point jumps in all nonselected windows that
+show the current buffer.  The default value is @code{nil}, which means
+point does not jump to the end.
+
+@vindex comint-input-ignoredups
+  The variable @code{comint-input-ignoredups} controls whether successive
+identical inputs are stored in the input history.  A non-@code{nil}
+value means to omit an input that is the same as the previous input.
+The default is @code{nil}, which means to store each input even if it is
+equal to the previous input.
+
+@vindex comint-completion-addsuffix
+@vindex comint-completion-recexact
+@vindex comint-completion-autolist
+  Three variables customize file name completion.  The variable
+@code{comint-completion-addsuffix} controls whether completion inserts a
+space or a slash to indicate a fully completed file or directory name
+(non-@code{nil} means do insert a space or slash).
+@code{comint-completion-recexact}, if non-@code{nil}, directs @key{TAB}
+to choose the shortest possible completion if the usual Emacs completion
+algorithm cannot add even a single character.
+@code{comint-completion-autolist}, if non-@code{nil}, says to list all
+the possible completions whenever completion is not exact.
+
+@findex comint-dynamic-complete-variable
+  The command @code{comint-dynamic-complete-variable} does variable-name
+completion using the environment variables as set within Emacs.  The
+variables controlling file name completion apply to variable-name
+completion too.  This command is normally available through the menu
+bar.
+
+@vindex shell-command-execonly
+  Command completion normally considers only executable files.
+If you set @code{shell-command-execonly} to @code{nil},
+it considers nonexecutable files as well.
+
+@findex shell-pushd-tohome
+@findex shell-pushd-dextract
+@findex shell-pushd-dunique
+  You can configure the behavior of @samp{pushd}.  Variables control
+whether @samp{pushd} behaves like @samp{cd} if no argument is given
+(@code{shell-pushd-tohome}), pop rather than rotate with a numeric
+argument (@code{shell-pushd-dextract}), and only add directories to the
+directory stack if they are not already on it
+(@code{shell-pushd-dunique}).  The values you choose should match the
+underlying shell, of course.
+
+@node Remote Host
+@subsection Remote Host Shell
+@cindex remote host
+@cindex connecting to remote host
+@cindex Telnet
+@cindex Rlogin
+
+  Emacs provides two commands for logging in to another computer
+and communicating with it through an Emacs buffer.
+
+@table @kbd
+@item M-x telnet @key{RET} @var{hostname} @key{RET}
+Set up a Telnet connection to the computer named @var{hostname}.
+@item M-x rlogin @key{RET} @var{hostname} @key{RET}
+Set up an Rlogin connection to the computer named @var{hostname}.
+@end table
+
+@findex telnet
+  Use @kbd{M-x telnet} to set up a Telnet connection to another
+computer.  (Telnet is the standard Internet protocol for remote login.)
+It reads the host name of the other computer as an argument with the
+minibuffer.  Once the connection is established, talking to the other
+computer works like talking to a subshell: you can edit input with the
+usual Emacs commands, and send it a line at a time by typing @key{RET}.
+The output is inserted in the Telnet buffer interspersed with the input.
+
+@findex rlogin
+@vindex rlogin-explicit-args
+  Use @kbd{M-x rlogin} to set up an Rlogin connection.  Rlogin is
+another remote login communication protocol, essentially much like the
+Telnet protocol but incompatible with it, and supported only by certain
+systems.  Rlogin's advantages are that you can arrange not to have to
+give your user name and password when communicating between two machines
+you frequently use, and that you can make an 8-bit-clean connection.
+(To do that in Emacs, set @code{rlogin-explicit-args} to @code{("-8")}
+before you run Rlogin.)
+
+  @kbd{M-x rlogin} sets up the default file directory of the Emacs
+buffer to access the remote host via FTP (@pxref{File Names}), and it
+tracks the shell commands that change the current directory, just like
+Shell mode.
+
+@findex rlogin-directory-tracking-mode
+  There are two ways of doing directory tracking in an Rlogin
+buffer---either with remote directory names
+@file{/@var{host}:@var{dir}/} or with local names (that works if the
+``remote'' machine shares file systems with your machine of origin).
+You can use the command @code{rlogin-directory-tracking-mode} to switch
+modes.  No argument means use remote directory names, a positive
+argument means use local names, and a negative argument means turn
+off directory tracking.
+
+@node Emacs Server, Hardcopy, Shell, Top
+@section Using Emacs as a Server
+@pindex emacsclient
+@cindex Emacs as a server
+@cindex server, using Emacs as
+@cindex @code{EDITOR} environment variable
+
+  Various programs such as @code{mail} can invoke your choice of editor
+to edit a particular piece of text, such as a message that you are
+sending.  By convention, most of these programs use the environment
+variable @code{EDITOR} to specify which editor to run.  If you set
+@code{EDITOR} to @samp{emacs}, they invoke Emacs---but in an
+inconvenient fashion, by starting a new, separate Emacs process.  This
+is inconvenient because it takes time and because the new Emacs process
+doesn't share the buffers in the existing Emacs process.
+
+  You can arrange to use your existing Emacs process as the editor for
+programs like @code{mail} by using the Emacs client and Emacs server
+programs.  Here is how.
+
+@cindex @code{TEXEDIT} environment variable
+  First, the preparation.  Within Emacs, call the function
+@code{server-start}.  (Your @file{.emacs} file can do this automatically
+if you add the expression @code{(server-start)} to it.)  Then, outside
+Emacs, set the @code{EDITOR} environment variable to @samp{emacsclient}.
+(Note that some programs use a different environment variable; for
+example, to make @TeX{} use @samp{emacsclient}, you should set the
+@code{TEXEDIT} environment variable to @samp{emacsclient +%d %s}.)
+
+@kindex C-x #
+@findex server-edit
+  Then, whenever any program invokes your specified @code{EDITOR}
+program, the effect is to send a message to your principal Emacs telling
+it to visit a file.  (That's what the program @code{emacsclient} does.)
+Emacs displays the buffer immediately and you can immediately begin
+editing it.
+
+  When you've finished editing that buffer, type @kbd{C-x #}
+(@code{server-edit}).  This saves the file and sends a message back to
+the @code{emacsclient} program telling it to exit.  The programs that
+use @code{EDITOR} wait for the ``editor'' (actually, @code{emacsclient})
+to exit.  @kbd{C-x #} also checks for other pending external requests
+to edit various files, and selects the next such file.
+
+  You can switch to a server buffer manually if you wish; you don't have
+to arrive at it with @kbd{C-x #}.  But @kbd{C-x #} is the only way to
+say that you are ``finished'' with one.
+
+@vindex server-window
+  If you set the variable @code{server-window} to a window or a frame,
+@kbd{C-x #} displays the server buffer in that window or in that frame.
+
+  While @code{mail} or another application is waiting for
+@code{emacsclient} to finish, @code{emacsclient} does not read terminal
+input.  So the terminal that @code{mail} was using is effectively
+blocked for the duration.  In order to edit with your principal Emacs,
+you need to be able to use it without using that terminal.  There are
+two ways to do this:
+
+@itemize @bullet
+@item
+Using a window system, run @code{mail} and the principal Emacs in two
+separate windows.  While @code{mail} is waiting for @code{emacsclient},
+the window where it was running is blocked, but you can use Emacs by
+switching windows.
+
+@item
+Use Shell mode in Emacs to run the other program such as @code{mail};
+then, @code{emacsclient} blocks only the subshell under Emacs, and you
+can still use Emacs to edit the file.
+@end itemize
+
+@vindex server-temp-file-regexp
+  Some programs write temporary files for you to edit.  After you edit
+the temporary file, the program reads it back and deletes it.  If the
+Emacs server is later asked to edit the same file name, it should assume
+this has nothing to do with the previous occasion for that file name.
+The server accomplishes this by killing the temporary file's buffer when
+you finish with the file.  Use the variable
+@code{server-temp-file-regexp} to specify which files are temporary in
+this sense; its value should be a regular expression that matches file
+names that are temporary.
+
+  If you run @code{emacsclient} with the option @samp{--no-wait}, it
+returns immediately without waiting for you to ``finish'' the buffer in
+Emacs.
+
+@menu
+* Invoking emacsclient::
+@end menu
+
+@node Invoking emacsclient,, Emacs Server, Emacs Server
+@section Invoking @code{emacsclient}
+
+  To run the @code{emacsclient} program, specify file names as arguments,
+and optionally line numbers as well.  Do it like this:
+
+@example
+emacsclient @r{@{}@r{[}+@var{line}@r{]} @var{filename}@r{@}}@dots{}
+@end example
+
+This tells Emacs to visit each of the specified files; if you specify a
+line number for a certain file, Emacs moves to that line in the file.
+
+Ordinarily, @code{emacsclient} does not return until you use the
+@kbd{C-x #} command on each of these buffers.  When that happens, Emacs
+sends a message to the @code{emacsclient} program telling it to return.
+
+But if you use the option @samp{-n} or @samp{--no-wait} when running
+@code{emacsclient}, then it returns immediately.  (You can take as long
+as you like to edit the files in Emacs.)
+
+
+@node Hardcopy, Postscript, Emacs Server, Top
+@section Hardcopy Output
+@cindex hardcopy
+
+  The Emacs commands for making hardcopy let you print either an entire
+buffer or just part of one, either with or without page headers.
+See also the hardcopy commands of Dired (@pxref{Misc File Ops})
+and the diary (@pxref{Diary Commands}).
+
+@table @kbd
+@item M-x print-buffer
+Print hardcopy of current buffer with page headings containing the file
+name and page number.
+@item M-x lpr-buffer
+Print hardcopy of current buffer without page headings.
+@item M-x print-region
+Like @code{print-buffer} but print only the current region.
+@item M-x lpr-region
+Like @code{lpr-buffer} but print only the current region.
+@end table
+
+@findex print-buffer
+@findex print-region
+@findex lpr-buffer
+@findex lpr-region
+@vindex lpr-switches
+  The hardcopy commands (aside from the Postscript commands) pass extra
+switches to the @code{lpr} program based on the value of the variable
+@code{lpr-switches}.  Its value should be a list of strings, each string
+an option starting with @samp{-}.  For example, to specify a line width
+of 80 columns for all the printing you do in Emacs, set
+@code{lpr-switches} like this:
+
+@example
+(setq lpr-switches '("-w80"))
+@end example
+
+@vindex printer-name
+  You can specify the printer to use by setting the variable
+@code{printer-name}.
+
+@vindex lpr-headers-switches
+@vindex lpr-commands
+@vindex lpr-add-switches
+  The variable @code{lpr-command} specifies the name of the printer
+program to run; the default value depends on your operating system type.
+On most systems, the default is @code{"lpr"}.  The variable
+@code{lpr-headers-switches} similarly specifies the extra switches to
+use to make page headers.  The variable @code{lpr-add-switches} controls
+whether to supply @samp{-T} and @samp{-J} options (suitable for
+@code{lpr}) to the printer program: @code{nil} means don't add them.
+@code{lpr-add-switches} should be @code{nil} if your printer program is
+not compatible with @code{lpr}.
+
+@node Postscript, Postscript Variables, Hardcopy, Top
+@section Postscript Hardcopy
+
+  These commands convert buffer contents to Postscript,
+either printing it or leaving it in another Emacs buffer.
+
+@table @kbd
+@item M-x ps-print-buffer
+Print hardcopy of the current buffer in Postscript form.
+@item M-x ps-print-region
+Print hardcopy of the current region in Postscript form.
+@item M-x ps-print-buffer-with-faces
+Print hardcopy of the current buffer in Postscript form, showing the
+faces used in the text by means of Postscript features.
+@item M-x ps-print-region-with-faces
+Print hardcopy of the current region in Postscript form, showing the
+faces used in the text.
+@item M-x ps-spool-buffer
+Generate Postscript for the current buffer text.
+@item M-x ps-spool-region
+Generate Postscript for the current region.
+@item M-x ps-spool-buffer-with-faces
+Generate Postscript for the current buffer, showing the faces used.
+@item M-x ps-spool-region-with-faces
+Generate Postscript for the current region, showing the faces used.
+@end table
+
+@findex ps-print-region
+@findex ps-print-buffer
+@findex ps-print-region-with-faces
+@findex ps-print-buffer-with-faces
+  The Postscript commands, @code{ps-print-buffer} and
+@code{ps-print-region}, print buffer contents in Postscript form.  One
+command prints the entire buffer; the other, just the region.  The
+corresponding @samp{-with-faces} commands,
+@code{ps-print-buffer-with-faces} and @code{ps-print-region-with-faces},
+use Postscript features to show the faces (fonts and colors) in the text
+properties of the text being printed.
+
+  If you are using a color display, you can print a buffer of program
+code with color highlighting by turning on Font-Lock mode in that
+buffer, and using @code{ps-print-buffer-with-faces}.
+
+@findex ps-spool-region
+@findex ps-spool-buffer
+@findex ps-spool-region-with-faces
+@findex ps-spool-buffer-with-faces
+  The commands whose names have @samp{spool} instead of @samp{print}
+generate the Postscript output in an Emacs buffer instead of sending
+it to the printer.
+
+@ifinfo
+  The following section describes variables for customizing these commands.
+@end ifinfo
+
+@node Postscript Variables, Sorting, Postscript, Top
+@section Variables for Postscript Hardcopy
+
+@vindex ps-lpr-command
+@vindex ps-lpr-switches
+@vindex ps-printer-name
+  All the Postscript hardcopy commands use the variables
+@code{ps-lpr-command} and @code{ps-lpr-switches} to specify how to print
+the output.  @code{ps-lpr-command} specifies the command name to run,
+@code{ps-lpr-switches} specifies command line options to use, and
+@code{ps-printer-name} specifies the printer.  If you don't set the
+first two variables yourself, they take their initial values from
+@code{lpr-command} and @code{lpr-switches}.  If @code{ps-printer-name}
+is @code{nil}, @code{printer-name} is used.
+
+@vindex ps-print-header
+@vindex ps-print-color-p
+  The variable @code{ps-print-header} controls whether these commands
+add header lines to each page---set it to @code{nil} to turn headers
+off.  You can turn off color processing by setting
+@code{ps-print-color-p} to @code{nil}.
+
+@vindex ps-paper-type
+@vindex ps-page-dimensions-database
+  The variable @code{ps-paper-type} specifies which size of paper to
+format for; legitimate values include @code{a4}, @code{a3},
+@code{a4small}, @code{b4}, @code{b5}, @code{executive}, @code{ledger},
+@code{legal}, @code{letter}, @code{letter-small}, @code{statement},
+@code{tabloid}.  The default is @code{letter}.  You can define
+additional paper sizes by changing the variable
+@code{ps-page-dimensions-database}.
+
+@vindex ps-landscape-mode
+  The variable @code{ps-landscape-mode} specifies the orientation of
+printing on the page.  The default is @code{nil}, which stands for
+``portrait'' mode.  Any non-@code{nil} value specifies ``landscape''
+mode.
+
+@vindex ps-number-of-columns
+  The variable @code{ps-number-of-columns} specifies the number of
+columns; it takes effect in both landscape and portrait mode.  The
+default is 1.
+
+@vindex ps-font-family
+@vindex ps-font-size
+@vindex ps-font-info-database
+  The variable @code{ps-font-family} specifies which font family to use
+for printing ordinary text.  Legitimate values include @code{Courier},
+@code{Helvetica}, @code{NewCenturySchlbk}, @code{Palatino} and
+@code{Times}.  The variable @code{ps-font-size} specifies the size of
+the font for ordinary text.  It defaults to 8.5 points.
+
+  Many other customization variables for these commands are defined and
+described in the Lisp file @file{ps-print.el}.
+
+@node Sorting, Narrowing, Postscript Variables, Top
+@section Sorting Text
+@cindex sorting
+
+  Emacs provides several commands for sorting text in the buffer.  All
+operate on the contents of the region (the text between point and the
+mark).  They divide the text of the region into many @dfn{sort records},
+identify a @dfn{sort key} for each record, and then reorder the records
+into the order determined by the sort keys.  The records are ordered so
+that their keys are in alphabetical order, or, for numeric sorting, in
+numeric order.  In alphabetic sorting, all upper-case letters `A' through
+`Z' come before lower-case `a', in accord with the ASCII character
+sequence.
+
+  The various sort commands differ in how they divide the text into sort
+records and in which part of each record is used as the sort key.  Most of
+the commands make each line a separate sort record, but some commands use
+paragraphs or pages as sort records.  Most of the sort commands use each
+entire sort record as its own sort key, but some use only a portion of the
+record as the sort key.
+
+@findex sort-lines
+@findex sort-paragraphs
+@findex sort-pages
+@findex sort-fields
+@findex sort-numeric-fields
+@table @kbd
+@item M-x sort-lines
+Divide the region into lines, and sort by comparing the entire
+text of a line.  A numeric argument means sort into descending order.
+
+@item M-x sort-paragraphs
+Divide the region into paragraphs, and sort by comparing the entire
+text of a paragraph (except for leading blank lines).  A numeric
+argument means sort into descending order.
+
+@item M-x sort-pages
+Divide the region into pages, and sort by comparing the entire
+text of a page (except for leading blank lines).  A numeric
+argument means sort into descending order.
+
+@item M-x sort-fields
+Divide the region into lines, and sort by comparing the contents of
+one field in each line.  Fields are defined as separated by
+whitespace, so the first run of consecutive non-whitespace characters
+in a line constitutes field 1, the second such run constitutes field
+2, etc.
+
+Specify which field to sort by with a numeric argument: 1 to sort by
+field 1, etc.  A negative argument means count fields from the right
+instead of from the left; thus, minus 1 means sort by the last field.
+If several lines have identical contents in the field being sorted, they
+keep same relative order that they had in the original buffer.
+
+@item M-x sort-numeric-fields
+Like @kbd{M-x sort-fields} except the specified field is converted
+to an integer for each line, and the numbers are compared.  @samp{10}
+comes before @samp{2} when considered as text, but after it when
+considered as a number.
+
+@item M-x sort-columns
+Like @kbd{M-x sort-fields} except that the text within each line
+used for comparison comes from a fixed range of columns.  See below
+for an explanation.
+
+@item M-x reverse-region
+Reverse the order of the lines in the region.  This is useful for
+sorting into descending order by fields or columns, since those sort
+commands do not have a feature for doing that.
+@end table
+
+  For example, if the buffer contains this:
+
+@smallexample
+On systems where clash detection (locking of files being edited) is
+implemented, Emacs also checks the first time you modify a buffer
+whether the file has changed on disk since it was last visited or
+saved.  If it has, you are asked to confirm that you want to change
+the buffer.
+@end smallexample
+
+@noindent
+applying @kbd{M-x sort-lines} to the entire buffer produces this:
+
+@smallexample
+On systems where clash detection (locking of files being edited) is
+implemented, Emacs also checks the first time you modify a buffer
+saved.  If it has, you are asked to confirm that you want to change
+the buffer.
+whether the file has changed on disk since it was last visited or
+@end smallexample
+
+@noindent
+where the upper-case @samp{O} sorts before all lower-case letters.  If
+you use @kbd{C-u 2 M-x sort-fields} instead, you get this:
+
+@smallexample
+implemented, Emacs also checks the first time you modify a buffer
+saved.  If it has, you are asked to confirm that you want to change
+the buffer.
+On systems where clash detection (locking of files being edited) is
+whether the file has changed on disk since it was last visited or
+@end smallexample
+
+@noindent
+where the sort keys were @samp{Emacs}, @samp{If}, @samp{buffer},
+@samp{systems} and @samp{the}.
+
+@findex sort-columns
+  @kbd{M-x sort-columns} requires more explanation.  You specify the
+columns by putting point at one of the columns and the mark at the other
+column.  Because this means you cannot put point or the mark at the
+beginning of the first line of the text you want to sort, this command
+uses an unusual definition of `region': all of the line point is in is
+considered part of the region, and so is all of the line the mark is in,
+as well as all the lines in between.
+
+  For example, to sort a table by information found in columns 10 to 15,
+you could put the mark on column 10 in the first line of the table, and
+point on column 15 in the last line of the table, and then run
+@code{sort-columns}.  Equivalently, you could run it with the mark on
+column 15 in the first line and point on column 10 in the last line.
+
+  This can be thought of as sorting the rectangle specified by point and
+the mark, except that the text on each line to the left or right of the
+rectangle moves along with the text inside the rectangle.
+@xref{Rectangles}.
+
+@vindex sort-fold-case
+  Many of the sort commands ignore case differences when comparing, if
+@code{sort-fold-case} is non-@code{nil}.
+
+@node Narrowing, Two-Column, Sorting, Top
+@section Narrowing
+@cindex widening
+@cindex restriction
+@cindex narrowing
+@cindex accessible portion
+
+  @dfn{Narrowing} means focusing in on some portion of the buffer,
+making the rest temporarily inaccessible.  The portion which you can
+still get to is called the @dfn{accessible portion}.  Canceling the
+narrowing, which makes the entire buffer once again accessible, is
+called @dfn{widening}.  The amount of narrowing in effect in a buffer at
+any time is called the buffer's @dfn{restriction}.
+
+  Narrowing can make it easier to concentrate on a single subroutine or
+paragraph by eliminating clutter.  It can also be used to restrict the
+range of operation of a replace command or repeating keyboard macro.
+
+@c WideCommands
+@table @kbd
+@item C-x n n
+Narrow down to between point and mark (@code{narrow-to-region}).
+@item C-x n w
+Widen to make the entire buffer accessible again (@code{widen}).
+@item C-x n p
+Narrow down to the current page (@code{narrow-to-page}).
+@item C-x n d
+Narrow down to the current defun (@code{narrow-to-defun}).
+@end table
+
+  When you have narrowed down to a part of the buffer, that part appears
+to be all there is.  You can't see the rest, you can't move into it
+(motion commands won't go outside the accessible part), you can't change
+it in any way.  However, it is not gone, and if you save the file all
+the inaccessible text will be saved.  The word @samp{Narrow} appears in
+the mode line whenever narrowing is in effect.
+
+@kindex C-x n n
+@findex narrow-to-region
+  The primary narrowing command is @kbd{C-x n n} (@code{narrow-to-region}).
+It sets the current buffer's restrictions so that the text in the current
+region remains accessible but all text before the region or after the region
+is inaccessible.  Point and mark do not change.
+
+@kindex C-x n p
+@findex narrow-to-page
+@kindex C-x n d
+@findex narrow-to-defun
+  Alternatively, use @kbd{C-x n p} (@code{narrow-to-page}) to narrow
+down to the current page.  @xref{Pages}, for the definition of a page.
+@kbd{C-x n d} (@code{narrow-to-defun}) narrows down to the defun
+containing point (@pxref{Defuns}).
+
+@kindex C-x n w
+@findex widen
+  The way to cancel narrowing is to widen with @kbd{C-x n w}
+(@code{widen}).  This makes all text in the buffer accessible again.
+
+  You can get information on what part of the buffer you are narrowed down
+to using the @kbd{C-x =} command.  @xref{Position Info}.
+
+  Because narrowing can easily confuse users who do not understand it,
+@code{narrow-to-region} is normally a disabled command.  Attempting to use
+this command asks for confirmation and gives you the option of enabling it;
+if you enable the command, confirmation will no longer be required for
+it.  @xref{Disabling}.
+
+@node Two-Column, Editing Binary Files, Narrowing, Top
+@section Two-Column Editing
+@cindex two-column editing
+@cindex splitting columns
+@cindex columns, splitting
+
+  Two-column mode lets you conveniently edit two side-by-side columns of
+text.  It uses two side-by-side windows, each showing its own
+buffer.
+
+  There are three ways to enter two-column mode:
+
+@table @asis
+@item @kbd{@key{F2} 2} or @kbd{C-x 6 2}
+@kindex F2 2
+@kindex C-x 6 2
+@findex 2C-two-columns
+Enter two-column mode with the current buffer on the left, and on the
+right, a buffer whose name is based on the current buffer's name
+(@code{2C-two-columns}).  If the right-hand buffer doesn't already
+exist, it starts out empty; the current buffer's contents are not
+changed.
+
+This command is appropriate when the current buffer is empty or contains
+just one column and you want to add another column.
+
+@item @kbd{@key{F2} s} or @kbd{C-x 6 s}
+@kindex F2 s
+@kindex C-x 6 s
+@findex 2C-split
+Split the current buffer, which contains two-column text, into two
+buffers, and display them side by side (@code{2C-split}).  The current
+buffer becomes the left-hand buffer, but the text in the right-hand
+column is moved into the right-hand buffer.  The current column
+specifies the split point.  Splitting starts with the current line and
+continues to the end of the buffer.
+
+This command is appropriate when you have a buffer that already contains
+two-column text, and you wish to separate the columns temporarily.
+
+@item @kbd{@key{F2} b @var{buffer} @key{RET}}
+@itemx @kbd{C-x 6 b @var{buffer} @key{RET}}
+@kindex F2 b
+@kindex C-x 6 b
+@findex 2C-associate-buffer
+Enter two-column mode using the current buffer as the left-hand buffer,
+and using buffer @var{buffer} as the right-hand buffer
+(@code{2C-associate-buffer}).
+@end table
+
+  @kbd{@key{F2} s} or @kbd{C-x 6 s} looks for a column separator, which
+is a string that appears on each line between the two columns.  You can
+specify the width of the separator with a numeric argument to
+@kbd{@key{F2} s}; that many characters, before point, constitute the
+separator string.  By default, the width is 1, so the column separator
+is the character before point.
+
+  When a line has the separator at the proper place, @kbd{@key{F2} s}
+puts the text after the separator into the right-hand buffer, and
+deletes the separator.  Lines that don't have the column separator at
+the proper place remain unsplit; they stay in the left-hand buffer, and
+the right-hand buffer gets an empty line to correspond.  (This is the
+way to write a line that ``spans both columns while in two-column
+mode'': write it in the left-hand buffer, and put an empty line in the
+right-hand buffer.)
+
+@kindex F2 RET
+@kindex C-x 6 RET
+@findex 2C-newline
+  The command @kbd{C-x 6 @key{RET}} or @kbd{@key{F2} @key{RET}}
+(@code{2C-newline}) inserts a newline in each of the two buffers at
+corresponding positions.  This is the easiest way to add a new line to
+the two-column text while editing it in split buffers.
+
+@kindex F2 1
+@kindex C-x 6 1
+@findex 2C-merge
+  When you have edited both buffers as you wish, merge them with
+@kbd{@key{F2} 1} or @kbd{C-x 6 1} (@code{2C-merge}).  This copies the
+text from the right-hand buffer as a second column in the other buffer.
+To go back to two-column editing, use @kbd{@key{F2} s}.
+
+@kindex F2 d
+@kindex C-x 6 d
+@findex 2C-dissociate
+  Use @kbd{@key{F2} d} or @kbd{C-x 6 d} to dissociate the two buffers,
+leaving each as it stands (@code{2C-dissociate}).  If the other buffer,
+the one not current when you type @kbd{@key{F2} d}, is empty,
+@kbd{@key{F2} d} kills it.
+
+@node Editing Binary Files, Saving Emacs Sessions, Two-Column, Top
+@section Editing Binary Files
+
+@cindex Hexl mode
+@cindex mode, Hexl
+@cindex editing binary files
+  There is a special major mode for editing binary files: Hexl mode.  To
+use it, use @kbd{M-x hexl-find-file} instead of @kbd{C-x C-f} to visit
+the file.  This command converts the file's contents to hexadecimal and
+lets you edit the translation.  When you save the file, it is converted
+automatically back to binary.
+
+  You can also use @kbd{M-x hexl-mode} to translate an existing buffer
+into hex.  This is useful if you visit a file normally and then discover
+it is a binary file.
+
+  Ordinary text characters overwrite in Hexl mode.  This is to reduce
+the risk of accidentally spoiling the alignment of data in the file.
+There are special commands for insertion.  Here is a list of the
+commands of Hexl mode:
+
+@c I don't think individual index entries for these commands are useful--RMS.
+@table @kbd
+@item C-M-d
+Insert a byte with a code typed in decimal.
+
+@item C-M-o
+Insert a byte with a code typed in octal.
+
+@item C-M-x
+Insert a byte with a code typed in hex.
+
+@item C-x [
+Move to the beginning of a 1k-byte ``page.''
+
+@item C-x ]
+Move to the end of a 1k-byte ``page.''
+
+@item M-g
+Move to an address specified in hex.
+
+@item M-j
+Move to an address specified in decimal.
+
+@item C-c C-c
+Leave Hexl mode, going back to the major mode this buffer had before you
+invoked @code{hexl-mode}.
+@end table
+
+@node Saving Emacs Sessions, Recursive Edit, Editing Binary Files, Top
+@section Saving Emacs Sessions
+@cindex saving sessions
+@cindex desktop
+
+  You can use the Desktop library to save the state of Emacs from one
+session to another.  Saving the state means that Emacs starts up with
+the same set of buffers, major modes, buffer positions, and so on that
+the previous Emacs session had.
+
+@vindex desktop-enable
+  To use Desktop, you should use the Customization buffer (@pxref{Easy
+Customization}) to set @code{desktop-enable} to a non-@code{nil} value,
+or add these lines at the end of your @file{.emacs} file:
+
+@example
+(desktop-load-default)
+(desktop-read)
+@end example
+
+@noindent
+@findex desktop-save
+The first time you save the state of the Emacs session, you must do it
+manually, with the command @kbd{M-x desktop-save}.  Once you have done
+that, exiting Emacs will save the state again---not only the present
+Emacs session, but also subsequent sessions.  You can also save the
+state at any time, without exiting Emacs, by typing @kbd{M-x
+desktop-save} again.
+
+  In order for Emacs to recover the state from a previous session, you
+must start it with the same current directory as you used when you
+started the previous session.  This is because @code{desktop-read} looks
+in the current directory for the file to read.  This means that you can
+have separate saved sessions in different directories; the directory in
+which you start Emacs will control which saved session to use.
+
+@vindex desktop-files-not-to-save
+  The variable @code{desktop-files-not-to-save} controls which files are
+excluded from state saving.  Its value is a regular expression that
+matches the files to exclude.  By default, remote (ftp-accessed) files
+are excluded; this is because visiting them again in the subsequent
+session would be slow.  If you want to include these files in state
+saving, set @code{desktop-files-not-to-save} to @code{"^$"}.
+@xref{Remote Files}.
+
+@node Recursive Edit, Emulation, Saving Emacs Sessions, Top
+@section Recursive Editing Levels
+@cindex recursive editing level
+@cindex editing level, recursive
+
+  A @dfn{recursive edit} is a situation in which you are using Emacs
+commands to perform arbitrary editing while in the middle of another
+Emacs command.  For example, when you type @kbd{C-r} inside of a
+@code{query-replace}, you enter a recursive edit in which you can change
+the current buffer.  On exiting from the recursive edit, you go back to
+the @code{query-replace}.
+
+@kindex C-M-c
+@findex exit-recursive-edit
+@cindex exiting recursive edit
+  @dfn{Exiting} the recursive edit means returning to the unfinished
+command, which continues execution.  The command to exit is @kbd{C-M-c}
+(@code{exit-recursive-edit}).
+
+  You can also @dfn{abort} the recursive edit.  This is like exiting,
+but also quits the unfinished command immediately.  Use the command
+@kbd{C-]} (@code{abort-recursive-edit}) to do this.  @xref{Quitting}.
+
+  The mode line shows you when you are in a recursive edit by displaying
+square brackets around the parentheses that always surround the major and
+minor mode names.  Every window's mode line shows this, in the same way,
+since being in a recursive edit is true of Emacs as a whole rather than
+any particular window or buffer.
+
+  It is possible to be in recursive edits within recursive edits.  For
+example, after typing @kbd{C-r} in a @code{query-replace}, you may type a
+command that enters the debugger.  This begins a recursive editing level
+for the debugger, within the recursive editing level for @kbd{C-r}.
+Mode lines display a pair of square brackets for each recursive editing
+level currently in progress.
+
+  Exiting the inner recursive edit (such as, with the debugger @kbd{c}
+command) resumes the command running in the next level up.  When that
+command finishes, you can then use @kbd{C-M-c} to exit another recursive
+editing level, and so on.  Exiting applies to the innermost level only.
+Aborting also gets out of only one level of recursive edit; it returns
+immediately to the command level of the previous recursive edit.  If you
+wish, you can then abort the next recursive editing level.
+
+  Alternatively, the command @kbd{M-x top-level} aborts all levels of
+recursive edits, returning immediately to the top-level command reader.
+
+  The text being edited inside the recursive edit need not be the same text
+that you were editing at top level.  It depends on what the recursive edit
+is for.  If the command that invokes the recursive edit selects a different
+buffer first, that is the buffer you will edit recursively.  In any case,
+you can switch buffers within the recursive edit in the normal manner (as
+long as the buffer-switching keys have not been rebound).  You could
+probably do all the rest of your editing inside the recursive edit,
+visiting files and all.  But this could have surprising effects (such as
+stack overflow) from time to time.  So remember to exit or abort the
+recursive edit when you no longer need it.
+
+  In general, we try to minimize the use of recursive editing levels in
+GNU Emacs.  This is because they constrain you to ``go back'' in a
+particular order---from the innermost level toward the top level.  When
+possible, we present different activities in separate buffers so that
+you can switch between them as you please.  Some commands switch to a
+new major mode which provides a command to switch back.  These
+approaches give you more flexibility to go back to unfinished tasks in
+the order you choose.
+
+@node Emulation, Dissociated Press, Recursive Edit, Top
+@section Emulation
+@cindex emulating other editors
+@cindex other editors
+@cindex EDT
+@cindex vi
+
+  GNU Emacs can be programmed to emulate (more or less) most other
+editors.  Standard facilities can emulate these:
+
+@table @asis
+@item EDT (DEC VMS editor)
+@findex edt-emulation-on
+@findex edt-emulation-off
+Turn on EDT emulation with @kbd{M-x edt-emulation-on}.  @kbd{M-x
+edt-emulation-off} restores normal Emacs command bindings.
+
+Most of the EDT emulation commands are keypad keys, and most standard
+Emacs key bindings are still available.  The EDT emulation rebindings
+are done in the global keymap, so there is no problem switching
+buffers or major modes while in EDT emulation.
+
+@item vi (Berkeley editor)
+@findex viper-mode
+Viper is the newest emulator for vi.  It implements several levels of
+emulation; level 1 is closest to vi itself, while level 5 departs
+somewhat from strict emulation to take advantage of the capabilities of
+Emacs.  To invoke Viper, type @kbd{M-x viper-mode}; it will guide you
+the rest of the way and ask for the emulation level.  @inforef{Top,
+Viper, viper}.
+
+@item vi (another emulator)
+@findex vi-mode
+@kbd{M-x vi-mode} enters a major mode that replaces the previously
+established major mode.  All of the vi commands that, in real vi, enter
+``input'' mode are programmed instead to return to the previous major
+mode.  Thus, ordinary Emacs serves as vi's ``input'' mode.
+
+Because vi emulation works through major modes, it does not work
+to switch buffers during emulation.  Return to normal Emacs first.
+
+If you plan to use vi emulation much, you probably want to bind a key
+to the @code{vi-mode} command.
+
+@item vi (alternate emulator)
+@findex vip-mode
+@kbd{M-x vip-mode} invokes another vi emulator, said to resemble real vi
+more thoroughly than @kbd{M-x vi-mode}.  ``Input'' mode in this emulator
+is changed from ordinary Emacs so you can use @key{ESC} to go back to
+emulated vi command mode.  To get from emulated vi command mode back to
+ordinary Emacs, type @kbd{C-z}.
+
+This emulation does not work through major modes, and it is possible
+to switch buffers in various ways within the emulator.  It is not
+so necessary to assign a key to the command @code{vip-mode} as
+it is with @code{vi-mode} because terminating insert mode does
+not use it.
+
+@inforef{Top, VIP, vip}, for full information.
+@end table
+
+@node Dissociated Press, Amusements, Emulation, Top
+@section Dissociated Press
+
+@findex dissociated-press
+  @kbd{M-x dissociated-press} is a command for scrambling a file of text
+either word by word or character by character.  Starting from a buffer of
+straight English, it produces extremely amusing output.  The input comes
+from the current Emacs buffer.  Dissociated Press writes its output in a
+buffer named @samp{*Dissociation*}, and redisplays that buffer after every
+couple of lines (approximately) so you can read the output as it comes out.
+
+  Dissociated Press asks every so often whether to continue generating
+output.  Answer @kbd{n} to stop it.  You can also stop at any time by
+typing @kbd{C-g}.  The dissociation output remains in the
+@samp{*Dissociation*} buffer for you to copy elsewhere if you wish.
+
+@cindex presidentagon
+  Dissociated Press operates by jumping at random from one point in the
+buffer to another.  In order to produce plausible output rather than
+gibberish, it insists on a certain amount of overlap between the end of
+one run of consecutive words or characters and the start of the next.
+That is, if it has just printed out `president' and then decides to jump
+to a different point in the file, it might spot the `ent' in `pentagon'
+and continue from there, producing `presidentagon'.@footnote{This
+dissociword actually appeared during the Vietnam War, when it was very
+appropriate.}  Long sample texts produce the best results.
+
+@cindex againformation
+  A positive argument to @kbd{M-x dissociated-press} tells it to operate
+character by character, and specifies the number of overlap characters.  A
+negative argument tells it to operate word by word and specifies the number
+of overlap words.  In this mode, whole words are treated as the elements to
+be permuted, rather than characters.  No argument is equivalent to an
+argument of two.  For your againformation, the output goes only into the
+buffer @samp{*Dissociation*}.  The buffer you start with is not changed.
+
+@cindex Markov chain
+@cindex ignoriginal
+@cindex techniquitous
+  Dissociated Press produces nearly the same results as a Markov chain
+based on a frequency table constructed from the sample text.  It is,
+however, an independent, ignoriginal invention.  Dissociated Press
+techniquitously copies several consecutive characters from the sample
+between random choices, whereas a Markov chain would choose randomly for
+each word or character.  This makes for more plausible sounding results,
+and runs faster.
+
+@cindex outragedy
+@cindex buggestion
+@cindex properbose
+@cindex mustatement
+@cindex developediment
+@cindex userenced
+  It is a mustatement that too much use of Dissociated Press can be a
+developediment to your real work.  Sometimes to the point of outragedy.
+And keep dissociwords out of your documentation, if you want it to be well
+userenced and properbose.  Have fun.  Your buggestions are welcome.
+
+@node Amusements, Customization, Dissociated Press, Top
+@section Other Amusements
+@cindex boredom
+@findex hanoi
+@findex yow
+@findex gomoku
+@findex mpuz
+@cindex tower of Hanoi
+
+  If you are a little bit bored, you can try @kbd{M-x hanoi}.  If you are
+considerably bored, give it a numeric argument.  If you are very very
+bored, try an argument of 9.  Sit back and watch.
+
+@cindex Go Moku
+  If you want a little more personal involvement, try @kbd{M-x gomoku},
+which plays the game Go Moku with you.
+
+@findex blackbox
+@findex mpuz
+@cindex puzzles
+  @kbd{M-x blackbox} and @kbd{M-x mpuz} are two kinds of puzzles.
+@code{blackbox} challenges you to determine the location of objects
+inside a box by tomography.  @code{mpuz} displays a multiplication
+puzzle with letters standing for digits in a code that you must
+guess---to guess a value, type a letter and then the digit you think it
+stands for.
+
+@findex dunnet
+  @kbd{M-x dunnet} runs an adventure-style exploration game, which is
+a bigger sort of puzzle.
+
+  When you are frustrated, try the famous Eliza program.  Just do
+@kbd{M-x doctor}.  End each input by typing @key{RET} twice.
+
+@cindex Zippy
+  When you are feeling strange, type @kbd{M-x yow}.