emacs-diffs
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Emacs-diffs] Changes to emacs/man/misc.texi [gnus-5_10-branch]


From: Miles Bader
Subject: [Emacs-diffs] Changes to emacs/man/misc.texi [gnus-5_10-branch]
Date: Sat, 04 Sep 2004 08:21:41 -0400

Index: emacs/man/misc.texi
diff -c /dev/null emacs/man/misc.texi:1.51.2.1
*** /dev/null   Sat Sep  4 12:03:05 2004
--- emacs/man/misc.texi Sat Sep  4 12:01:15 2004
***************
*** 0 ****
--- 1,2462 ----
+ @c This is part of the Emacs manual.
+ @c Copyright (C) 1985, 86, 87, 93, 94, 95, 97, 2000, 2001, 2004
+ @c   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
+ 
+ @ifnottex
+ @raisesections
+ @end ifnottex
+ 
+ @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 address@hidden
+ See section ``Threading.''
+ 
+ @item
+ Read digests.  See section ``Document Groups.''
+ 
+ @item
+ Refer to and jump to the parent of the current address@hidden
+ See section ``Finding the Parent.''
+ 
+ @item
+ Refer to articles by using Message-IDs included in the address@hidden
+ 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 address@hidden
+ See section ``Scoring.''
+ 
+ @item
+ Send an article to a address@hidden
+ See section ``Composing Messages.''
+ @end itemize
+ @end iftex
+ @ifinfo
+ @itemize @bullet
+ @item
+ Follow discussions on specific address@hidden
+ @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 address@hidden
+ @xref{Finding the Parent, , , gnus, The Gnus Manual}.
+ 
+ @item
+ Refer to articles by using Message-IDs included in the address@hidden
+ @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 address@hidden
+ @xref{Scoring, , , gnus, The Gnus Manual}.
+ 
+ @item
+ Send an article to a address@hidden
+ @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*} or run a shell inside a terminal
+ emulator window.
+ 
+ There is a shell implemented entirely in Emacs, documented in a separate
+ manual.  @xref{Top,Eshell,Eshell, eshell, Eshell: The Emacs 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.
+ @item M-x term
+ Run a subshell with input and output through an Emacs buffer.
+ You can then give commands interactively.
+ Full terminal emulation is available.
+ @item M-x eshell
+ @findex eshell
+ Start the Emacs shell.
+ @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.
+ * Directory Tracking::     Keeping track when the subshell changes directory.
+ * Options: Shell Options.  Options for customizing Shell mode.
+ * Terminal emulator::      An Emacs window as a terminal emulator.
+ * Term Mode::              Special Emacs commands used in Term mode.
+ * Paging in Term::         Paging in the terminal emulator.
+ * 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 appears
+ either in the echo area (if it is short), or in an Emacs buffer named
+ @samp{*Shell Command Output*}, which is displayed in another window
+ but not selected (if the output is long).
+ 
+   For instance, one way to decompress a file @file{foo.gz} from Emacs
+ is to type @kbd{M-! gunzip foo.gz @key{RET}}.  That shell command
+ normally creates the file @file{foo} and produces no terminal output.
+ 
+   A numeric argument, as in @kbd{M-1 M-!}, says to insert terminal
+ output into the current buffer instead of a separate buffer.  It puts
+ point before the output, and sets the mark after the output.  For
+ instance, @kbd{M-1 M-! gunzip < foo.gz @key{RET}} would insert the
+ uncompressed equivalent of @file{foo.gz} into the current buffer.
+ 
+   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.  You do not get any status information for an asynchronous
+ command, since it hasn't finished yet.
+ 
+ @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.
+ 
+   One use for @kbd{M-|} is to run @code{uudecode}.  For instance, if
+ the buffer contains uuencoded text, type @kbd{C-x h M-| uudecode
+ @key{RET}} to feed the entire buffer contents to the @code{uudecode}
+ program.  That program will ignore everything except the encoded text,
+ and will store the decoded output into the file whose name is
+ specified in the encoded text.
+ 
+ @vindex shell-file-name
+   Both @kbd{M-!} and @kbd{M-|} use @code{shell-file-name} to specify the
+ shell to use.  This variable is initialized based on your @env{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
+ @env{PATH} when Emacs is started.  Your @file{.emacs} file can override
+ either or both of these default address@hidden
+ 
+   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.
+ 
+ @cindex @code{comint-highlight-input} face
+ @cindex @code{comint-highlight-prompt} face
+   Input lines, once you submit them, are displayed using the face
+ @code{comint-highlight-input}, and prompts are displayed using the
+ face @code{comint-highlight-prompt}.  This makes it easier to see
+ previous input lines in the buffer.  @xref{Faces}.
+ 
+   To make multiple subshells, you can invoke @kbd{M-x shell} with a
+ prefix argument (e.g. @kbd{C-u M-x shell}), which will read a buffer
+ name and create (or reuse) a subshell in that buffer.  You can also
+ rename the @samp{*shell*} buffer using @kbd{M-x rename-uniquely}, then
+ create a new @samp{*shell*} buffer using plain @kbd{M-x shell}.  All the
+ subshells in different buffers run independently and in parallel.
+ 
+ @vindex explicit-shell-file-name
+ @cindex environment variables for subshells
+ @cindex @env{ESHELL} environment variable
+ @cindex @env{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 address@hidden  Otherwise,
+ the environment variable @env{ESHELL} is used, or the environment
+ variable @env{SHELL} if there is no @env{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
+ @env{PATH} when Emacs is started.  Your @file{.emacs} file can override
+ either or both of these default initializations.
+ 
+   Emacs sends the new shell the contents of the file
+ @file{~/address@hidden as input, if it 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}.
+ 
+   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}.
+ 
+ @cindex @env{EMACS} environment variable
+   Unless the environment variable @env{EMACS} is already defined,
+ Emacs defines it 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 prompt at the beginning of the line (text output by
+ programs preceding your input) is omitted.  (See also the variable
+ @code{comint-use-prompt-regexp-instead-of-fields}.)
+ 
+ @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 is @code{nil}, but some users prefer @code{("~" "#" "%")} to
+ ignore 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 address@hidden
+ 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 @acronym{EOF}
+ (@code{comint-delchar-or-maybe-eof}).  Typed at the end of the shell
+ buffer, @kbd{C-d} sends @acronym{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-or-process-mark
+ Move to the beginning of the line, but after the prompt if any
+ (@code{comint-bol-or-process-mark}).  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-delete-output
+ Delete the last batch of output from a shell command
+ (@code{comint-delete-output}).  This is useful if a shell command spews
+ out lots of output that just gets in the way.  This command used to be
+ called @code{comint-kill-output}.
+ 
+ @item C-c C-s
+ @kindex C-c C-s @r{(Shell mode)}
+ @findex comint-write-output
+ Write the last batch of output from a shell command to a file
+ (@code{comint-write-output}).  With a prefix argument, the file is
+ appended to instead.  Any prompt at the end of the output is not
+ written.
+ 
+ @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 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 address@hidden 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 include
+ 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
+ @kindex C-c C-x @r{(Shell mode)}
+ @findex comint-get-next-from-history
+ Fetch the next subsequent command from the history.
+ 
+ @item C-c .
+ @kindex C-c . @r{(Shell mode)}
+ @findex comint-input-previous-argument
+ Fetch one argument from an old shell 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}).
+ @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-n}.  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.
+ 
+   The command @kbd{C-c .}@: (@code{comint-input-previous-argument})
+ copies an individual argument from a previous command, like @kbd{ESC
+ .} in Bash.  The simplest use copies the last argument from the
+ previous shell command.  With a prefix argument @var{n}, it copies the
+ @var{n}th argument instead.  Repeating @kbd{C-c .} copies from an
+ earlier shell command instead, always using the same value of @var{n}
+ (don't give a prefix argument when you repeat the @kbd{C-c .}
+ command).
+ 
+   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-insert-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-insert-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.
+ 
+ @item Mouse-2
+ Copy the input command that you click on, inserting the copy at the end
+ of the buffer.
+ @end table
+ 
+   Moving to a previous input and then copying it with @kbd{C-c
+ @key{RET}} or @kbd{Mouse-2} 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
+ recognizes these constructs, and can 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 comint-input-autoexpand
+ @findex comint-magic-space
+   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}.  You can make
+ @key{SPC} perform history expansion by binding @key{SPC} to the
+ command @code{comint-magic-space}.
+ 
+ @vindex shell-prompt-pattern
+ @vindex comint-prompt-regexp
+ @vindex comint-use-prompt-regexp-instead-of-fields
+ @cindex prompt, shell
+   Shell mode recognizes history references when they follow a prompt.
+ Normally, any text output by a program at the beginning of an input
+ line is considered a prompt.  However, if the variable
+ @code{comint-use-prompt-regexp-instead-of-fields} is address@hidden,
+ then Comint mode uses a regular expression to recognize prompts.  In
+ general, the variable @code{comint-prompt-regexp} specifies the
+ regular expression; Shell mode uses the variable
+ @code{shell-prompt-pattern} to set up @code{comint-prompt-regexp} in
+ the shell buffer.
+ 
+ @node Directory Tracking
+ @subsection Directory Tracking
+ @cindex directory tracking
+ 
+ @vindex shell-pushd-regexp
+ @vindex shell-popd-regexp
+ @vindex shell-cd-regexp
+   Shell mode keeps track of @samp{cd}, @samp{pushd} and @samp{popd}
+ commands given to the inferior shell, so it can keep the
+ @samp{*shell*} buffer's default directory the same as the shell's
+ working directory.  It recognizes these commands 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.
+ 
+ @ignore  @c This seems to have been deleted long ago.
+ @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}).
+ @end ignore
+ 
+ @findex dirs
+   If Emacs gets confused about 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.
+ 
+ @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
+ address@hidden, 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 address@hidden, then
+ arrival of output when point is at the end 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-move-point-for-output
+   By setting @code{comint-move-point-for-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 address@hidden
+ 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
+ (address@hidden means do insert a space or slash).
+ @code{comint-completion-recexact}, if address@hidden, 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 address@hidden, says to list all
+ the possible completions whenever completion is not exact.
+ 
+ @vindex shell-completion-execonly
+   Command completion normally considers only executable files.
+ If you set @code{shell-completion-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.
+ 
+   If you want Shell mode to handle color output from shell commands,
+ you can enable ANSI Color mode.  Here is how to do this:
+ 
+ @example
+ (add-hook 'shell-mode-hook 'ansi-color-for-comint-mode-on)
+ @end example
+ 
+ @node Terminal emulator
+ @subsection Emacs Terminal Emulator
+ @findex term
+ 
+   To run a subshell in a terminal emulator, putting its typescript in
+ an Emacs buffer, use @kbd{M-x term}.  This creates (or reuses) a
+ buffer named @samp{*terminal*}, and runs a subshell with input coming
+ from your keyboard, and output going to that buffer.
+ 
+   The terminal emulator uses Term mode, which has two input modes.  In
+ line mode, Term basically acts like Shell mode; see @ref{Shell Mode}.
+ 
+   In char mode, each character is sent directly to the inferior
+ subshell, as ``terminal input.''  Any ``echoing'' of your input is the
+ responsibility of the subshell.  The sole exception is the terminal
+ escape character, which by default is @kbd{C-c} (@pxref{Term Mode}).
+ Any ``terminal output'' from the subshell goes into the buffer,
+ advancing point.
+ 
+   Some programs (such as Emacs itself) need to control the appearance
+ on the terminal screen in detail.  They do this by sending special
+ control codes.  The exact control codes needed vary from terminal to
+ terminal, but nowadays most terminals and terminal emulators
+ (including @code{xterm}) understand the ANSI-standard (VT100-style)
+ escape sequences.  Term mode recognizes these escape sequences, and
+ handles each one appropriately, changing the buffer so that the
+ appearance of the window matches what it would be on a real terminal.
+ You can actually run Emacs inside an Emacs Term window.
+ 
+    The file name used to load the subshell is determined the same way
+ as for Shell mode.  To make multiple terminal emulators, rename the
+ buffer @samp{*terminal*} to something different using @kbd{M-x
+ rename-uniquely}, just as with Shell mode.
+ 
+   Unlike Shell mode, Term mode does not track the current directory by
+ examining your input.  But some shells can tell Term what the current
+ directory is.  This is done automatically by @code{bash} version 1.15
+ and later.
+ 
+ @node Term Mode
+ @subsection Term Mode
+ @cindex Term mode
+ @cindex mode, Term
+ 
+   The terminal emulator uses Term mode, which has two input modes.  In
+ line mode, Term basically acts like Shell mode; see @ref{Shell Mode}.
+ In char mode, each character is sent directly to the inferior
+ subshell, except for the Term escape character, normally @kbd{C-c}.
+ 
+   To switch between line and char mode, use these commands:
+ 
+ @table @kbd
+ @kindex C-c C-j @r{(Term mode)}
+ @findex term-char-mode
+ @item C-c C-j
+ Switch to line mode.  Do nothing if already in line mode.
+ 
+ @kindex C-c C-k @r{(Term mode)}
+ @findex term-line-mode
+ @item C-c C-k
+ Switch to char mode.  Do nothing if already in char mode.
+ @end table
+ 
+   The following commands are only available in char mode:
+ 
+ @table @kbd
+ @item C-c C-c
+ Send a literal @key{C-c} to the sub-shell.
+ 
+ @item C-c C-x
+ A prefix command to access the global @key{C-x} commands conveniently.
+ For example, @kbd{C-c C-x o} invokes the global binding of
+ @kbd{C-x o}, which is normally @samp{other-window}.
+ @end table
+ 
+ @node Paging in Term
+ @subsection Page-At-A-Time Output
+ @cindex page-at-a-time
+ 
+   Term mode has a page-at-a-time feature.  When enabled it makes
+ output pause at the end of each screenful.
+ 
+ @table @kbd
+ @kindex C-c C-q @r{(Term mode)}
+ @findex term-pager-toggle
+ @item C-c C-q
+ Toggle the page-at-a-time feature.  This command works in both line
+ and char modes.  When page-at-a-time is enabled, the mode-line
+ displays the word @samp{page}.
+ @end table
+ 
+   With page-at-a-time enabled, whenever Term receives more than a
+ screenful of output since your last input, it pauses, displaying
+ @samp{**MORE**} in the mode-line.  Type @key{SPC} to display the next
+ screenful of output.  Type @kbd{?} to see your other options.  The
+ interface is similar to the @code{more} program.
+ 
+ @node Remote Host
+ @subsection Remote Host Shell
+ @cindex remote host
+ @cindex connecting to remote host
+ @cindex Telnet
+ @cindex Rlogin
+ 
+   You can login to a remote computer, using whatever commands you
+ would from a regular terminal (e.g.@: using the @code{telnet} or
+ @code{rlogin} commands), from a Term window.
+ 
+   A program that asks you for a password will normally suppress
+ echoing of the password, so the password will not show up in the
+ buffer.  This will happen just as if you were using a real terminal,
+ if the buffer is in char mode.  If it is in line mode, the password is
+ temporarily visible, but will be erased when you hit return.  (This
+ happens automatically; there is no special password processing.)
+ 
+   When you log in to a different machine, you need to specify the type
+ of terminal you're using.  Terminal types @samp{ansi} or @samp{vt100}
+ will work on most systems.
+ 
+ @c   If you are talking to a Bourne-compatible
+ @c shell, and your system understands the @env{TERMCAP} variable,
+ @c you can use the command @kbd{M-x shell-send-termcap}, which
+ @c sends a string specifying the terminal type and size.
+ @c (This command is also useful after the window has changed size.)
+ 
+ @c You can of course run @samp{gdb} on that remote computer.  One useful
+ @c trick:  If you invoke gdb with the @code{--fullname} option,
+ @c it will send special commands to Emacs that will cause Emacs to
+ @c pop up the source files you're debugging.  This will work
+ @c whether or not gdb is running on a different computer than Emacs,
+ @c as long as Emacs can access the source files specified by gdb.
+ 
+ @ignore
+   You cannot log in to a remote computer using the Shell mode.
+ @c (This will change when Shell is re-written to use Term.)
+ Instead, Emacs provides two commands for logging in to another computer
+ and communicating with it through an Emacs buffer using Comint mode:
+ 
+ @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.
+ 
+ @end ignore
+ 
+ @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 @env{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 @env{EDITOR} to specify which editor to run.  If you set
+ @env{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 any 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 @env{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 @env{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
+ @env{TEXEDIT} environment variable to @samp{emacsclient +%d %s}.)
+ 
+ @kindex C-x #
+ @findex server-edit
+   Then, whenever any program invokes your specified @env{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 @env{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 way to
+ say that you are finished with one.
+ 
+ @vindex server-kill-new-buffers
+ @vindex server-temp-file-regexp
+   Finishing with a server buffer also kills the buffer, unless it
+ already existed in the Emacs session before the server asked to create
+ it.  However, if you set @code{server-kill-new-buffers} to @code{nil},
+ then a different criterion is used: finishing with a server buffer
+ kills it if the file name matches the regular expression
+ @code{server-temp-file-regexp}.  This is set up to distinguish certain
+ ``temporary'' files.
+ 
+ @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
+ three 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
+ Using virtual terminals, run @code{mail} in one virtual terminal
+ and run Emacs in another.
+ 
+ @item
+ Use Shell mode or Term 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
+ 
+   If you run @code{emacsclient} with the option @samp{--no-wait}, it
+ returns immediately without waiting for you to ``finish'' the buffer
+ in Emacs.  Note that server buffers created in this way are not killed
+ automatically when you finish with them.
+ 
+ @menu
+ * Invoking emacsclient::
+ @end menu
+ 
+ @node Invoking emacsclient,, Emacs Server, Emacs Server
+ @subsection 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 @address@hidden@address@hidden@address@hidden@address@hidden 
@address@hidden@address@hidden
+ @end example
+ 
+ @noindent
+ 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.
+ If you specify a column number as well, Emacs puts point on that column
+ in the line.
+ 
+   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.)
+ 
+   The option @address@hidden is useful when
+ running @code{emacsclient} in a script.  It specifies a command to run
+ if @code{emacsclient} fails to contact Emacs.  For example, the
+ following setting for the @var{EDITOR} environment variable will
+ always give an editor, even if Emacs is not running:
+ 
+ @example
+ EDITOR="emacsclient --alternate-editor vi +%d %s"
+ @end example
+ 
+ @noindent
+ The environment variable @var{ALTERNATE_EDITOR} has the same effect, but
+ the value of the @samp{--alternate-editor} takes precedence.
+ 
+ @pindex emacs.bash
+   Alternatively, the file @file{etc/emacs.bash} defines a bash
+ function which will communicate with a running Emacs server, or start
+ one if none exists.
+ 
+ If you use several displays, you can tell Emacs on which display to
+ open the given files with the option @address@hidden
+ This can be used typically when connecting from home to an Emacs
+ server running on your machine at your workplace.
+ 
+ You can also use @code{emacsclient} to execute any piece of Emacs Lisp
+ code, using the option @samp{--eval}.  When this option is given, the
+ rest of the arguments is not taken as a list of files to visit but as
+ a list of expressions to evaluate.
+ 
+ @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.
+ @item M-x handwrite
+ Generates/prints PostScript for the current buffer as if handwritten.
+ @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.
+ 
+ @findex handwrite
+ @cindex handwriting
+ @kbd{M-x handwrite} is more frivolous.  It generates a PostScript
+ rendition of the current buffer as a cursive handwritten document.  It
+ can be customized in group @code{handwrite}.  This function only
+ supports ISO 8859-1 characters.
+ 
+ @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
+   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.
+ 
+ @cindex color emulation on black-and-white printers
+ @vindex ps-print-color-p
+   If your printer doesn't support colors, you should turn off color
+ processing by setting @code{ps-print-color-p} to @code{nil}.  By
+ default, if the display supports colors, Emacs produces hardcopy output
+ with color information; on black-and-white printers, colors are emulated
+ with shades of gray.  This might produce illegible output, even if your
+ screen colors only use shades of gray.
+ 
+ @vindex ps-use-face-background
+   By default, PostScript printing ignores the background colors of the
+ faces, unless the variable @code{ps-use-face-background} is
+ address@hidden  This is to avoid unwanted interference with the zebra
+ stripes and background image/text.
+ 
+ @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 address@hidden 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.
+ 
+ @vindex ps-multibyte-buffer
+ @cindex Intlfonts for PostScript printing
+ @cindex fonts for PostScript printing
+   Emacs supports more scripts and characters than a typical PostScript
+ printer.  Thus, some of the characters in your buffer might not be
+ printable using the fonts built into your printer.  You can augment
+ the fonts supplied with the printer with those from the GNU Intlfonts
+ package, or you can instruct Emacs to use Intlfonts exclusively.  The
+ variable @code{ps-multibyte-buffer} controls this: the default value,
+ @code{nil}, is appropriate for printing @acronym{ASCII} and Latin-1
+ characters; a value of @code{non-latin-printer} is for printers which
+ have the fonts for @acronym{ASCII}, Latin-1, Japanese, and Korean
+ characters built into them.  A value of @code{bdf-font} arranges for
+ the BDF fonts from the Intlfonts package to be used for @emph{all}
+ characters.  Finally, a value of @code{bdf-font-except-latin}
+ instructs the printer to use built-in fonts for @acronym{ASCII} and Latin-1
+ characters, and Intlfonts BDF fonts for the rest.
+ 
+ @vindex bdf-directory-list
+   To be able to use the BDF fonts, Emacs needs to know where to find
+ them.  The variable @code{bdf-directory-list} holds the list of
+ directories where Emacs should look for the fonts; the default value
+ includes a single directory @file{/usr/local/share/emacs/fonts/bdf}.
+ 
+   Many other customization variables for these commands are defined and
+ described in the Lisp files @file{ps-print.el} and @file{ps-mule.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 @acronym{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
+ @vindex sort-numeric-base
+ @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 the 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.  By default, numbers are interpreted according
+ to @code{sort-numeric-base}, but numbers beginning with @samp{0x} or
+ @samp{0} are interpreted as hexadecimal and octal, respectively.
+ 
+ @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 address@hidden
+ 
+ @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.
+ 
+ @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 @address@hidden 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 @address@hidden 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 @address@hidden 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
+ 
+   @address@hidden 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
+ @address@hidden 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, @address@hidden 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 @address@hidden @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
+ @address@hidden 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 @address@hidden s}.
+ 
+ @kindex F2 d
+ @kindex C-x 6 d
+ @findex 2C-dissociate
+   Use @address@hidden 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 @address@hidden d}, is empty,
+ @address@hidden 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
+ @cindex hex editing
+   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
+ 
+ @noindent
+ Other Hexl commands let you insert strings (sequences) of binary
+ bytes, move by @code{short}s or @code{int}s, etc.; type @kbd{C-h a
+ address@hidden for details.
+ 
+ 
+ @node Saving Emacs Sessions, Recursive Edit, Editing Binary Files, Top
+ @section Saving Emacs Sessions
+ @cindex saving sessions
+ @cindex restore session
+ @cindex remember editing session
+ @cindex reload files
+ @cindex desktop
+ 
+    Use the desktop library to save the state of Emacs from one session
+ to another.  Once you save the Emacs @dfn{desktop}---the buffers,
+ their file names, major modes, buffer positions, and so on---then
+ subsequent Emacs sessions reload the saved desktop.
+ 
+ @findex desktop-save
+ @vindex desktop-save-mode
+   You can save the desktop manually with the command @kbd{M-x
+ desktop-save}.  You can also enable automatical desktop saving when
+ you exit Emacs: use the Customization buffer (@pxref{Easy
+ Customization}) to set @code{desktop-save-mode} to @code{t} for future
+ sessions, or add this line in your @file{~/.emacs} file:
+ 
+ @example
+ (desktop-save-mode 1)
+ @end example
+ 
+ @findex desktop-change-dir
+ @findex desktop-revert
+   When Emacs starts, it looks for a saved desktop in the current
+ directory.  Thus, you can have separate saved desktops in different
+ directories, and the starting directory determines which one Emacs
+ reloads.  You can save the current desktop and reload one saved in
+ another directory by typing @kbd{M-x desktop-change-dir}.  Typing
+ @kbd{M-x desktop-revert} reverts to the desktop previously reloaded.
+ 
+   Specify the option @samp{--no-desktop} on the command line when you
+ don't want it to reload any saved desktop.
+ 
+ @findex desktop-clear
+ @vindex desktop-globals-to-clear
+ @vindex desktop-clear-preserve-buffers-regexp
+   Type @kbd{M-x desktop-clear} to empty the Emacs desktop.  This kills
+ all buffers except for internal ones, and clears the global variables
+ listed in @code{desktop-globals-to-clear}.  If you want this to
+ preserve certain buffers, customize the variable
+ @code{desktop-clear-preserve-buffers-regexp}, whose value is a regular
+ expression matching the names of buffers not to kill.
+ 
+ @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, Hyperlinking, Recursive Edit, Top
+ @section Emulation
+ @cindex emulating other editors
+ @cindex other editors
+ @cindex EDT
+ @cindex vi
+ @cindex PC key bindings
+ @cindex scrolling all windows
+ @cindex PC selection
+ @cindex Motif key bindings
+ @cindex Macintosh key bindings
+ @cindex WordStar
+ 
+   GNU Emacs can be programmed to emulate (more or less) most other
+ editors.  Standard facilities can emulate these:
+ 
+ @table @asis
+ @item CRiSP/Brief (PC editor)
+ @findex crisp-mode
+ @vindex crisp-override-meta-x
+ @findex scroll-all-mode
+ @cindex CRiSP mode
+ @cindex Brief emulation
+ @cindex emulation of Brief
+ @cindex mode, CRiSP
+ You can turn on key bindings to emulate the CRiSP/Brief editor with
+ @kbd{M-x crisp-mode}.  Note that this rebinds @kbd{M-x} to exit Emacs
+ unless you change the user option @code{crisp-override-meta-x}.  You can
+ also use the command @kbd{M-x scroll-all-mode} or set the user option
+ @code{crisp-load-scroll-all} to emulate CRiSP's scroll-all feature
+ (scrolling all windows together).
+ 
+ @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 ``PC'' bindings
+ @findex pc-bindings-mode
+ @cindex ``PC'' key bindings
+ The command @kbd{M-x pc-bindings-mode} sets up certain key bindings
+ for ``PC compatibility''---what people are often used to on PCs---as
+ follows: @kbd{Delete} and its variants delete forward instead of
+ backward, @kbd{C-Backspace} kills backward a word (as @kbd{C-Delete}
+ normally would), @kbd{M-Backspace} does undo, @kbd{Home} and @kbd{End}
+ move to beginning and end of line, @kbd{C-Home} and @kbd{C-End} move
+ to beginning and end of buffer and @kbd{C-Escape} does
+ @code{list-buffers}.
+ 
+ @item PC Selection mode
+ @findex pc-selection-mode
+ @cindex PC Selection minor mode
+ @cindex mode, PC selection
+ @cindex selection, PC
+ The command @kbd{M-x pc-selection-mode} toggles a global minor mode
+ that emulates the mark, copy, cut and paste commands of various other
+ systems---an interface known as CUA.  It establishes the key bindings
+ of PC mode, and also modifies the bindings of the cursor keys and the
+ @kbd{next}, @kbd{prior}, @kbd{home} and @kbd{end} keys.  It does not
+ provide the full set of CUA key bindings---the fundamental Emacs keys
+ @kbd{C-c}, @kbd{C-v} and @kbd{C-x} are not changed.
+ 
+ The standard keys for moving around (@kbd{right}, @kbd{left},
+ @kbd{up}, @kbd{down}, @kbd{home}, @kbd{end}, @kbd{prior}, @kbd{next},
+ called ``move-keys'') deactivate the mark in PC selection mode.
+ However, using @kbd{Shift} together with the ``move keys'' activates
+ the region over which they move.  The copy, cut and paste functions
+ are available on @kbd{C-insert}, @kbd{S-delete} and @kbd{S-insert}
+ respectively.
+ 
+ Turning @code{pc-selection-mode} off restores the old key bindings of
+ these keys.
+ 
+ @cindex s-region package
+ The @code{s-region} package provides similar, but less complete,
+ facilities.
+ 
+ @item TPU (DEC VMS editor)
+ @findex tpu-edt-on
+ @cindex TPU
+ @kbd{M-x tpu-edt-on} turns on emulation of the TPU editor emulating EDT.
+ 
+ @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.
+ 
+ @item WordStar (old wordprocessor)
+ @findex wordstar-mode
+ @kbd{M-x wordstar-mode} provides a major mode with WordStar-like
+ key bindings.
+ @end table
+ 
+ @node Hyperlinking, Dissociated Press, Emulation, Top
+ @section Hyperlinking and Navigation Features
+ 
+ @cindex hyperlinking
+ @cindex navigation
+   Various modes documented elsewhere have hypertext features so that
+ you can follow links, usually by clicking @kbd{Mouse-2} on the link or
+ typing @key{RET} while point is on the link.  Info mode, Help mode and
+ the Dired-like modes are examples.  The Tags facility links between
+ uses and definitions in source files, see @ref{Tags}.  Imenu provides
+ navigation amongst items indexed in the current buffer, see
+ @ref{Imenu}.  Info-lookup provides mode-specific lookup of definitions
+ in Info indexes, see @ref{Documentation}.  Speedbar maintains a frame
+ in which links to files, and locations in files are displayed, see
+ @ref{Speedbar}.
+ 
+   Other non-mode-specific facilities described in this section enable
+ following links from the current buffer in a context-sensitive
+ fashion.
+ 
+ @menu
+ * Browse-URL::                  Following URLs.
+ * Goto-address::                Activating URLs.
+ * FFAP::                        Finding files etc. at point.
+ * Find-func::                   Finding function and variable definitions.
+ @end menu
+ 
+ @node Browse-URL
+ @subsection  Following URLs
+ @cindex World Wide Web
+ @cindex Web
+ @findex browse-url
+ @findex browse-url-at-point
+ @findex browse-url-at-mouse
+ @cindex Browse-URL
+ @cindex URLs
+ 
+ @table @kbd
+ @item M-x browse-url @key{RET} @var{url} @key{RET}
+ Load a URL into a Web browser.
+ @end table
+ 
+ The Browse-URL package provides facilities for following URLs specifying
+ links on the World Wide Web.  Usually this works by invoking a web
+ browser, but you can, for instance, arrange to invoke @code{compose-mail}
+ from @samp{mailto:} URLs.
+ 
+   The general way to use this feature is to type @kbd{M-x browse-url},
+ which displays a specified URL.  If point is located near a plausible
+ URL, that URL is used as the default.  Other commands are available
+ which you might like to bind to keys, such as
+ @code{browse-url-at-point} and @code{browse-url-at-mouse}.
+ 
+ @vindex browse-url-browser-function
+   You can customize Browse-URL's behavior via various options in the
+ @code{browse-url} Customize group, particularly
+ @code{browse-url-browser-function}.  You can invoke actions dependent
+ on the type of URL by defining @code{browse-url-browser-function} as
+ an association list.  The package's commentary available via @kbd{C-h
+ p} under the @samp{hypermedia} keyword provides more information.
+ Packages with facilities for following URLs should always go through
+ Browse-URL, so that the customization options for Browse-URL will
+ affect all browsing in Emacs.
+ 
+ @node Goto-address
+ @subsection Activating URLs
+ @findex goto-address
+ @cindex Goto-address
+ @cindex URLs, activating
+ 
+ @table @kbd
+ @item M-x goto-address
+ Activate URLs and e-mail addresses in the current buffer.
+ @end table
+ 
+   You can make URLs in the current buffer active with @kbd{M-x
+ goto-address}.  This finds all the URLs in the buffer, and establishes
+ bindings for @kbd{Mouse-2} and @kbd{C-c @key{RET}} on them.  After
+ activation, if you click on a URL with @kbd{Mouse-2}, or move to a URL
+ and type @kbd{C-c @key{RET}}, that will display the web page that the URL
+ specifies.  For a @samp{mailto} URL, it sends mail instead, using your
+ selected mail-composition method (@pxref{Mail Methods}).
+ 
+   It can be useful to add @code{goto-address} to mode hooks and the
+ hooks used to display an incoming message.
+ @code{rmail-show-message-hook} is the appropriate hook for Rmail, and
+ @code{mh-show-mode-hook} for MH-E.  This is not needed for Gnus,
+ which has a similar feature of its own.
+ 
+ 
+ @node FFAP
+ @subsection Finding Files and URLs at Point
+ @findex find-file-at-point
+ @findex ffap
+ @findex ffap-dired-at-point
+ @findex ffap-next
+ @findex ffap-menu
+ @cindex finding file at point
+ 
+   FFAP mode replaces certain key bindings for finding files, including
+ @kbd{C-x C-f}, with commands that provide more sensitive defaults.
+ These commands behave like the ordinary ones when given a prefix
+ argument.  Otherwise, they get the default file name or URL from the
+ text around point.  If what is found in the buffer has the form of a
+ URL rather than a file name, the commands use @code{browse-url} to
+ view it.
+ 
+   This feature is useful for following references in mail or news
+ buffers, @file{README} files, @file{MANIFEST} files, and so on.  The
+ @samp{ffap} package's commentary available via @kbd{C-h p} under the
+ @samp{files} keyword and the @code{ffap} Custom group provide details.
+ 
+ @cindex FFAP minor mode
+ @findex ffap-mode
+   You can turn on FFAP minor mode by calling @code{ffap-bindings} to
+ make the following key bindings and to install hooks for using
+ @code{ffap} in Rmail, Gnus and VM article buffers.
+ 
+ @table @kbd
+ @item C-x C-f @var{filename} @key{RET}
+ @kindex C-x C-f @r{(FFAP)}
+ Find @var{filename}, guessing a default from text around point
+ (@code{find-file-at-point}).
+ @item C-x 4 f
+ @kindex C-x 4 f @r{(FFAP)}
+ @code{ffap-other-window}, analogous to @code{find-file-other-window}.
+ @item C-x 5 f
+ @kindex C-x 5 f @r{(FFAP)}
+ @code{ffap-other-frame}, analogous to @code{find-file-other-frame}.
+ @item M-x ffap-next
+ Search buffer for next file name or URL, then find that file or URL.
+ @item C-x d @var{directory} @key{RET}
+ @kindex C-x d @r{(FFAP)}
+ Start Dired on @var{directory}, defaulting to the directory name at
+ point (@code{ffap-dired-at-point}).
+ @item S-Mouse-3
+ @kindex S-Mouse-3 @r{(FFAP)}
+ @code{ffap-at-mouse} finds the file guessed from text around the position
+ of a mouse click.
+ @item C-S-Mouse-3
+ @kindex C-S-Mouse-3 @r{(FFAP)}
+ Display a menu of files and URLs mentioned in current buffer, then
+ find the one you select (@code{ffap-menu}).
+ @end table
+ 
+ @node Find-func
+ @subsection Finding Function and Variable Definitions
+ @cindex definitions, finding in Lisp sources
+ @cindex Lisp definitions, finding in sources
+ 
+ @table @kbd
+ @item M-x find-function @key{RET} @var{function} @key{RET}
+ Find the definition of @var{function} in its source file.
+ @item M-x find-variable @key{RET} @var{variable} @key{RET}
+ Find the definition of @var{variable} in its source file.
+ @item M-x find-function-on-key @key{RET} @var{key}
+ Find the definition of the function that @var{key} invokes.
+ @end table
+ 
+   These commands provide an easy way to find the definitions of Emacs
+ Lisp functions and variables.  They are similar in purpose to the Tags
+ facility (@pxref{Tags}), but don't require a tags table; on the other
+ hand, they only work for function and variable definitions that are
+ already loaded in the Emacs session.
+ 
+ @findex find-function
+ @findex find-function-on-key
+ @findex find-variable
+   To find the definition of a function, use @kbd{M-x find-function}.
+ @kbd{M-x find-variable} finds the definition of a specified variable.
+ @kbd{M-x find-function-on-key} finds the definition of the function
+ bound to a specified key.
+ 
+   To use these commands, you must have the Lisp source (@samp{.el})
+ files available along with the compiled (@samp{.elc}) files, in
+ directories in @code{load-path}.  You can use compressed source files
+ if you enable Auto Compression mode.  These commands only handle
+ definitions written in Lisp, not primitive functions or variables
+ defined in the C code of Emacs.
+ 
+ @node Dissociated Press, Amusements, Hyperlinking, 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 output `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'address@hidden
+ 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
+ @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
+ @findex 5x5
+ @cindex puzzles
+   @kbd{M-x blackbox}, @kbd{M-x mpuz} and @kbd{M-x 5x5} are 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.  The aim of @code{5x5} is to fill in all the squares.
+ 
+ @findex decipher
+ @cindex ciphers
+ @cindex cryptanalysis
+ @kbd{M-x decipher} helps you to cryptanalyze a buffer which is encrypted
+ in a simple monoalphabetic substitution cipher.
+ 
+ @findex dunnet
+   @kbd{M-x dunnet} runs an adventure-style exploration game, which is
+ a bigger sort of puzzle.
+ 
+ @findex lm
+ @cindex landmark game
+ @kbd{M-x lm} runs a relatively non-participatory game in which a robot
+ attempts to maneuver towards a tree at the center of the window based on
+ unique olfactory cues from each of the four directions.
+ 
+ @findex life
+ @cindex Life
+ @kbd{M-x life} runs Conway's ``Life'' cellular automaton.
+ 
+ @findex morse-region
+ @findex unmorse-region
+ @cindex Morse code
+ @cindex --/---/.-./.../.
+ @kbd{M-x morse-region} converts text in a region to Morse code and
+ @kbd{M-x unmorse-region} converts it back.  No cause for remorse.
+ 
+ @findex pong
+ @cindex Pong game
+ @kbd{M-x pong} plays a Pong-like game, bouncing the ball off opposing
+ bats.
+ 
+ @findex solitaire
+ @cindex solitaire
+ @kbd{M-x solitaire} plays a game of solitaire in which you jump pegs
+ across other pegs.
+ 
+ @findex studlify-region
+ @cindex StudlyCaps
+ @kbd{M-x studlify-region} studlify-cases the region, producing
+ text like this:
+ 
+ @example
+ M-x stUdlIfY-RegioN stUdlIfY-CaSeS thE region.
+ @end example
+ 
+ @findex tetris
+ @cindex Tetris
+ @findex snake
+ @cindex Snake
+ @kbd{M-x tetris} runs an implementation of the well-known Tetris game.
+ Likewise, @kbd{M-x snake} provides an implementation of Snake.
+ 
+   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}.
+ 
+ @findex zone
+ The command @kbd{M-x zone} plays games with the display when Emacs is
+ idle.
+ 
+ @ifnottex
+ @lowersections
+ @end ifnottex
+ 
+ @ignore
+    arch-tag: 8f094220-c0d5-4e9e-af7d-3e0da8187474
+ @end ignore




reply via email to

[Prev in Thread] Current Thread [Next in Thread]