[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Emacs-diffs] Changes to misc.texi
|
From: |
Glenn Morris |
|
Subject: |
[Emacs-diffs] Changes to misc.texi |
|
Date: |
Thu, 06 Sep 2007 04:47:40 +0000 |
CVSROOT: /sources/emacs
Module name: emacs
Changes by: Glenn Morris <gm> 07/09/06 04:47:40
Index: misc.texi
===================================================================
RCS file: misc.texi
diff -N misc.texi
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ misc.texi 6 Sep 2007 04:47:39 -0000 1.1
@@ -0,0 +1,2559 @@
address@hidden This is part of the Emacs manual.
address@hidden Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1997, 2000,
2001,
address@hidden 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation,
Inc.
address@hidden See file emacs.texi for copying conditions.
address@hidden
address@hidden 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, following hyperlinks,
+browsing images, emulating other editors, and various diversions and
+amusements.
+
address@hidden iftex
+
address@hidden
address@hidden
address@hidden ifnottex
+
address@hidden Gnus, Shell, Calendar/Diary, Top
address@hidden Gnus
address@hidden Gnus
address@hidden 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.
address@hidden
+For full details, see @ref{Top, Gnus,, gnus, The Gnus Manual}.
address@hidden ifnottex
address@hidden
+For full details on Gnus, type @kbd{M-x info} and then select the Gnus
+manual.
address@hidden iftex
+
address@hidden gnus
+To start Gnus, type @kbd{M-x gnus @key{RET}}.
+
address@hidden
+* 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.
address@hidden menu
+
address@hidden Buffers of Gnus
address@hidden Gnus Buffers
+
+Unlike most Emacs packages, Gnus uses several buffers to display
+information and to receive commands. The three Gnus buffers users use
+most are the @dfn{group buffer}, the @dfn{summary buffer} and the
address@hidden buffer}.
+
+The @dfn{group buffer} contains a list of newsgroups. 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 see this buffer but you don't select it---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.
+
address@hidden Gnus Startup
address@hidden 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
address@hidden 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.
+
address@hidden Summary of Gnus
address@hidden Summary of Gnus Commands
+
+Reading news is a two-step process:
+
address@hidden
address@hidden
+Choose a group in the group buffer.
+
address@hidden
+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.
address@hidden enumerate
+
+ Each Gnus buffer has its own special commands; 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:
+
address@hidden @kbd
address@hidden q @r{(Gnus Group mode)}
address@hidden gnus-group-exit
address@hidden 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.
+
address@hidden L @r{(Gnus Group mode)}
address@hidden gnus-group-list-all-groups
address@hidden 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!
+
address@hidden l @r{(Gnus Group mode)}
address@hidden gnus-group-list-groups
address@hidden l
+In the group buffer, list only the groups to which you subscribe and
+which contain unread articles.
+
address@hidden u @r{(Gnus Group mode)}
address@hidden gnus-group-unsubscribe-current-group
address@hidden subscribe groups
address@hidden unsubscribe groups
address@hidden 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.
+
address@hidden C-k @r{(Gnus)}
address@hidden gnus-group-kill-group
address@hidden 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.''
+
address@hidden SPC @r{(Gnus)}
address@hidden gnus-group-read-group
address@hidden @key{SPC}
+In the group buffer, select the group on the line under the cursor
+and display the first unread article in that group.
+
address@hidden 1000
+In the summary buffer,
+
address@hidden @bullet
address@hidden
+Select the article on the line under the cursor if none is selected.
+
address@hidden
+Scroll the text of the selected article (if there is one).
+
address@hidden
+Select the next unread article if at the end of the current article.
address@hidden itemize
+
+Thus, you can move through all the articles by repeatedly typing @key{SPC}.
+
address@hidden DEL @r{(Gnus)}
address@hidden @key{DEL}
+In the group buffer, move point to the previous group containing
+unread articles.
+
address@hidden gnus-summary-prev-page
+In the summary buffer, scroll the text of the article backwards.
+
address@hidden n @r{(Gnus)}
address@hidden gnus-group-next-unread-group
address@hidden gnus-summary-next-unread-article
address@hidden n
+Move point to the next unread group, or select the next unread article.
+
address@hidden p @r{(Gnus)}
address@hidden gnus-group-prev-unread-group
address@hidden gnus-summary-prev-unread-article
address@hidden p
+Move point to the previous unread group, or select the previous
+unread article.
+
address@hidden C-n @r{(Gnus Group mode)}
address@hidden gnus-group-next-group
address@hidden C-p @r{(Gnus Group mode)}
address@hidden gnus-group-prev-group
address@hidden C-n @r{(Gnus Summary mode)}
address@hidden gnus-summary-next-subject
address@hidden C-p @r{(Gnus Summary mode)}
address@hidden gnus-summary-prev-subject
address@hidden C-n
address@hidden 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.
+
address@hidden s @r{(Gnus Summary mode)}
address@hidden gnus-summary-isearch-article
address@hidden 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}.
+
address@hidden M-s @r{(Gnus Summary mode)}
address@hidden gnus-summary-search-article-forward
address@hidden M-s @var{regexp} @key{RET}
+In the summary buffer, search forward for articles containing a match
+for @var{regexp}.
+
address@hidden table
+
address@hidden
address@hidden Where to Look
address@hidden Where to Look Further
+
address@hidden 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
address@hidden
+additional topics:
+
address@hidden ifnottex
address@hidden
+additional topics in @cite{The Gnus Manual}:
+
address@hidden @bullet
address@hidden
+Follow discussions on specific address@hidden
+See section ``Threading.''
+
address@hidden
+Read digests. See section ``Document Groups.''
+
address@hidden
+Refer to and jump to the parent of the current address@hidden
+See section ``Finding the Parent.''
+
address@hidden
+Refer to articles by using Message-IDs included in the address@hidden
+See section ``Article Keymap.''
+
address@hidden
+Save articles. See section ``Saving Articles.''
+
address@hidden
+Have Gnus score articles according to various criteria, like author
+name, subject, or string in the body of the address@hidden
+See section ``Scoring.''
+
address@hidden
+Send an article to a address@hidden
+See section ``Composing Messages.''
address@hidden itemize
address@hidden iftex
address@hidden
address@hidden @bullet
address@hidden
+Follow discussions on specific address@hidden
address@hidden, , Reading Based on Conversation Threads,
+gnus, The Gnus Manual}.
+
address@hidden
+Read digests. @xref{Document Groups, , , gnus, The Gnus Manual}.
+
address@hidden
+Refer to and jump to the parent of the current address@hidden
address@hidden the Parent, , , gnus, The Gnus Manual}.
+
address@hidden
+Refer to articles by using Message-IDs included in the address@hidden
address@hidden Keymap, , , gnus, The Gnus Manual}.
+
address@hidden
+Save articles. @xref{Saving Articles, , , gnus, The Gnus Manual}.
+
address@hidden
+Have Gnus score articles according to various criteria, like author
+name, subject, or string in the body of the address@hidden
address@hidden, , , gnus, The Gnus Manual}.
+
address@hidden
+Send an article to a address@hidden
address@hidden Messages, , , gnus, The Gnus Manual}.
address@hidden itemize
address@hidden ifnottex
address@hidden ignore
+
address@hidden Shell, Emacs Server, Gnus, Top
address@hidden Running Shell Commands from Emacs
address@hidden subshell
address@hidden 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.
+
address@hidden @kbd
address@hidden M-! @var{cmd} @key{RET}
+Run the shell command line @var{cmd} and display the output
+(@code{shell-command}).
address@hidden 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}).
address@hidden M-x shell
+Run a subshell with input and output through an Emacs buffer.
+You can then give commands interactively.
address@hidden 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.
address@hidden table
+
+ @kbd{M-x eshell} invokes a shell implemented entirely in Emacs. It
+is documented in a separate manual. @xref{Top,Eshell,Eshell, eshell,
+Eshell: The Emacs Shell}.
+
address@hidden
+* 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.
+* Shell Prompts:: Two ways to recognize shell prompts.
+* 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.
address@hidden menu
+
address@hidden Single Shell
address@hidden Single Shell Commands
+
address@hidden M-!
address@hidden 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
address@hidden 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 when @code{shell-command} returns.
+
address@hidden M-|
address@hidden 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. With a numeric argument, meaning insert
+the output in the current buffer, it deletes the old region and the
+output replaces it as the contents of the region. It returns the
+command's exit status, like @kbd{M-!}.
+
+ One use for @kbd{M-|} is to run @code{gpg} to see what keys are in
+the buffer. For instance, if the buffer contains a GPG key, type
address@hidden h M-| gpg @key{RET}} to feed the entire buffer contents to
+the @code{gpg} program. That program will ignore everything except
+the encoded keys, and will output a list of the keys the buffer
+contains.
+
address@hidden 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
address@hidden environment variable when Emacs is started. If the file
+name is relative, Emacs searches the directories in the list
address@hidden; 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.
+
+ Both @kbd{M-!} and @kbd{M-|} wait for the shell command to complete,
+unless you end the command with @samp{&} to make it asynchronous. 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 then 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.
+
+ Asynchronous commands ending in @samp{&} feed their output into
+the buffer @samp{*Async Shell Command*}. Output arrives in that
+buffer regardless of whether it is visible in a window.
+
+ To specify a coding system for @kbd{M-!} or @kbd{M-|}, use the command
address@hidden @key{RET} c} immediately beforehand. @xref{Communication
Coding}.
+
address@hidden shell-command-default-error-buffer
+ Error output from these commands is normally intermixed with the
+regular output. But if the variable
address@hidden has a string as value, and
+it's the name of a buffer, @kbd{M-!} and @kbd{M-|} insert error output
+before point in that buffer.
+
address@hidden Interactive Shell
address@hidden Interactive Inferior Shell
+
address@hidden 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
address@hidden 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.
+
address@hidden @code{comint-highlight-input} face
address@hidden @code{comint-highlight-prompt} face
+ Input lines, once you submit them, are displayed using the face
address@hidden, 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}.
+Subshells in different buffers run independently and in parallel.
+
address@hidden explicit-shell-file-name
address@hidden environment variables for subshells
address@hidden @env{ESHELL} environment variable
address@hidden @env{SHELL} environment variable
+ The file name used to load the subshell is the value of the variable
address@hidden, 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
address@hidden 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
address@hidden/address@hidden as input, if it exists, where
address@hidden is the name of the file that the shell was loaded
+from. For example, if you use bash, the file sent to it is
address@hidden/.emacs_bash}. If this file is not found, Emacs tries to fallback
+on @file{~/.emacs.d/address@hidden
+
+ To specify a coding system for the shell, you can use the command
address@hidden @key{RET} c} immediately before @kbd{M-x shell}. You can
+also change the coding system for a running subshell by typing
address@hidden @key{RET} p} in the shell buffer. @xref{Communication
+Coding}.
+
address@hidden @env{INSIDE_EMACS} environment variable
+ Emacs sets the envitonment variable @env{INSIDE_EMACS} to @code{t}
+in the subshell. Programs can check this variable to determine
+whether they are running inside an Emacs subshell.
+
address@hidden @env{EMACS} environment variable
+ Emacs also sets the @env{EMACS} environment variable to @code{t} if
+it is not already defined. @strong{Warning:} This environment
+variable is deprecated. Programs that check this variable should be
+changed to check @env{INSIDE_EMACS} instead.
+
address@hidden Shell Mode
address@hidden Shell Mode
address@hidden Shell mode
address@hidden 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:
+
address@hidden @kbd
address@hidden @key{RET}
address@hidden RET @r{(Shell mode)}
address@hidden 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}). Copying a line
+in this way omits any prompt at the beginning of the line (text output
+by programs preceding your input). @xref{Shell Prompts}, for how
+Shell mode recognizes prompts.
+
address@hidden @key{TAB}
address@hidden TAB @r{(Shell mode)}
address@hidden 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.
+
address@hidden shell-completion-fignore
address@hidden 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.
+
address@hidden M-?
address@hidden M-? @r{(Shell mode)}
address@hidden 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}).
+
address@hidden C-d
address@hidden C-d @r{(Shell mode)}
address@hidden 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.
+
address@hidden C-c C-a
address@hidden C-c C-a @r{(Shell mode)}
address@hidden 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.)
+
address@hidden 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}.
+
address@hidden C-c C-u
address@hidden C-c C-u @r{(Shell mode)}
address@hidden comint-kill-input
+Kill all text pending at end of buffer to be sent as input
+(@code{comint-kill-input}). If point is not at end of buffer,
+this only kills the part of this text that precedes point.
+
address@hidden C-c C-w
address@hidden C-c C-w @r{(Shell mode)}
+Kill a word before point (@code{backward-kill-word}).
+
address@hidden C-c C-c
address@hidden C-c C-c @r{(Shell mode)}
address@hidden 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.
+
address@hidden C-c C-z
address@hidden C-c C-z @r{(Shell mode)}
address@hidden 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.
+
address@hidden C-c C-\
address@hidden comint-quit-subjob
address@hidden 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.
+
address@hidden C-c C-o
address@hidden C-c C-o @r{(Shell mode)}
address@hidden 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}.
+
address@hidden C-c C-s
address@hidden C-c C-s @r{(Shell mode)}
address@hidden 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.
+
address@hidden C-c C-r
address@hidden C-M-l
address@hidden C-c C-r @r{(Shell mode)}
address@hidden C-M-l @r{(Shell mode)}
address@hidden 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}).
+
address@hidden C-c C-e
address@hidden C-c C-e @r{(Shell mode)}
address@hidden comint-show-maximum-output
+Scroll to put the end of the buffer at the bottom of the window
+(@code{comint-show-maximum-output}).
+
address@hidden C-c C-f
address@hidden C-c C-f @r{(Shell mode)}
address@hidden shell-forward-command
address@hidden 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.
+
address@hidden C-c C-b
address@hidden C-c C-b @r{(Shell mode)}
address@hidden shell-backward-command
+Move backward across one shell command, but not beyond the current line
+(@code{shell-backward-command}).
+
address@hidden M-x dirs
+Ask the shell what its current directory is, so that Emacs can agree
+with the shell.
+
address@hidden M-x send-invisible @key{RET} @var{text} @key{RET}
address@hidden 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.
+
+Please note that Emacs will not echo passwords by default. If you
+really want them to be echoed, evaluate the following Lisp
+expression:
+
address@hidden
+(remove-hook 'comint-output-filter-functions
+ 'comint-watch-for-password-prompt)
address@hidden example
+
address@hidden M-x comint-continue-subjob
address@hidden 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.}
+
address@hidden M-x comint-strip-ctrl-m
address@hidden 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:
+
address@hidden
+(add-hook 'comint-output-filter-functions
+ 'comint-strip-ctrl-m)
address@hidden example
+
address@hidden M-x comint-truncate-buffer
address@hidden 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:
+
address@hidden
+(add-hook 'comint-output-filter-functions
+ 'comint-truncate-buffer)
address@hidden example
address@hidden table
+
address@hidden Comint mode
address@hidden 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}).
+
address@hidden 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.
+
address@hidden Shell Prompts
address@hidden Shell Prompts
+
address@hidden shell-prompt-pattern
address@hidden comint-prompt-regexp
address@hidden comint-use-prompt-regexp
address@hidden prompt, shell
+ A prompt is text output by a program to show that it is ready to
+accept new user input. Normally, Comint mode (and thus Shell mode)
+considers the prompt to be any text output by a program at the
+beginning of an input line. However, if the variable
address@hidden is address@hidden, then Comint mode
+uses a regular expression to recognize prompts. In Shell mode,
address@hidden specifies the regular expression.
+
+ The value of @code{comint-use-prompt-regexp} also affects many
+motion and paragraph commands. If the value is address@hidden, the
+general Emacs motion commands behave as they normally do in buffers
+without special text properties. However, if the value is @code{nil},
+the default, then Comint mode divides the buffer into two types of
+``fields'' (ranges of consecutive characters having the same
address@hidden text property): input and output. Prompts are part of
+the output. Most Emacs motion commands do not cross field boundaries,
+unless they move over multiple lines. For instance, when point is in
+input on the same line as a prompt, @kbd{C-a} puts point at the
+beginning of the input if @code{comint-use-prompt-regexp} is
address@hidden and at the beginning of the line otherwise.
+
+ In Shell mode, only shell prompts start new paragraphs. Thus, a
+paragraph consists of a prompt and the input and output that follow
+it. However, if @code{comint-use-prompt-regexp} is @code{nil}, the
+default, most paragraph commands do not cross field boundaries. This
+means that prompts, ranges of input, and ranges of non-prompt output
+behave mostly like separate paragraphs; with this setting, numeric
+arguments to most paragraph commands yield essentially undefined
+behavior. For the purpose of finding paragraph boundaries, Shell mode
+uses @code{shell-prompt-pattern}, regardless of
address@hidden
+
address@hidden Shell History
address@hidden Shell Command History
+
+ Shell buffers support three ways of repeating earlier commands. You
+can use keys like those used for the minibuffer history; 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
address@hidden history reference.
+
address@hidden
+* 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.
address@hidden menu
+
address@hidden Shell Ring
address@hidden Shell History Ring
+
address@hidden @kbd
address@hidden comint-previous-input
address@hidden M-p @r{(Shell mode)}
address@hidden M-p
address@hidden address@hidden
+Fetch the next earlier old shell command.
+
address@hidden M-n @r{(Shell mode)}
address@hidden comint-next-input
address@hidden M-n
address@hidden address@hidden
+Fetch the next later old shell command.
+
address@hidden M-r @r{(Shell mode)}
address@hidden M-s @r{(Shell mode)}
address@hidden comint-previous-matching-input
address@hidden comint-next-matching-input
address@hidden M-r @var{regexp} @key{RET}
address@hidden M-s @var{regexp} @key{RET}
+Search backwards or forwards for old shell commands that match @var{regexp}.
+
address@hidden C-c C-x
address@hidden C-c C-x @r{(Shell mode)}
address@hidden comint-get-next-from-history
+Fetch the next subsequent command from the history.
+
address@hidden C-c .
address@hidden C-c . @r{(Shell mode)}
address@hidden comint-input-previous-argument
+Fetch one argument from an old shell command.
+
address@hidden C-c C-l
address@hidden C-c C-l @r{(Shell mode)}
address@hidden comint-dynamic-list-input-ring
+Display the buffer's history of shell commands in another window
+(@code{comint-dynamic-list-input-ring}).
address@hidden 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},
address@hidden, @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.
address@hidden@key{UP}} works like @kbd{M-p}, and @address@hidden like
address@hidden
+
+ 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. Any partial input you were composing before navigating the
+history list is restored when you go to the beginning or end of the
+history ring.
+
+ 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
address@hidden 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
address@hidden 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.
+
address@hidden shell-input-ring-file-name
+ Some shells store their command histories in files so that you can
+refer to 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,
address@hidden/.sh_history} for ksh, and @file{~/.history} for other shells.
+
address@hidden Shell History Copying
address@hidden Shell History Copying
+
address@hidden @kbd
address@hidden C-c C-p @r{(Shell mode)}
address@hidden comint-previous-prompt
address@hidden C-c C-p
+Move point to the previous prompt (@code{comint-previous-prompt}).
+
address@hidden C-c C-n @r{(Shell mode)}
address@hidden comint-next-prompt
address@hidden C-c C-n
+Move point to the following prompt (@code{comint-next-prompt}).
+
address@hidden C-c RET @r{(Shell mode)}
address@hidden comint-copy-old-input
address@hidden C-c @key{RET}
+Copy the input command which point is in, inserting the copy at the end
+of the buffer (@code{comint-copy-old-input}). This is useful if you
+move point back to a previous command. After you copy the command, you
+can submit the copy as input with @key{RET}. If you wish, you can
+edit the copy before resubmitting it. If you use this command on an
+output line, it copies that line to the end of the buffer.
+
address@hidden Mouse-2
+If @code{comint-use-prompt-regexp} is @code{nil} (the default), copy
+the old input command that you click on, inserting the copy at the end
+of the buffer (@code{comint-insert-input}). If
address@hidden is address@hidden, or if the click is
+not over old input, just yank as usual.
address@hidden table
+
+ Moving to a previous input and then copying it with @kbd{C-c
address@hidden 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
address@hidden 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.
+
address@hidden History References
address@hidden Shell History References
address@hidden 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}.
+
address@hidden comint-input-autoexpand
address@hidden 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
address@hidden to @code{input}. You can make
address@hidden perform history expansion by binding @key{SPC} to the
+command @code{comint-magic-space}.
+
+ Shell mode recognizes history references when they follow a prompt.
address@hidden Prompts}, for how Shell mode recognizes prompts.
+
address@hidden Directory Tracking
address@hidden Directory Tracking
address@hidden directory tracking
+
address@hidden shell-pushd-regexp
address@hidden shell-popd-regexp
address@hidden 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
address@hidden 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
address@hidden 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,
address@hidden 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.
+
address@hidden @c This seems to have been deleted long ago.
address@hidden shell-set-directory-error-hook
+ If Emacs gets an error while trying to handle what it believes is a
address@hidden, @samp{pushd} or @samp{popd} command, it runs the hook
address@hidden (@pxref{Hooks}).
address@hidden ignore
+
address@hidden 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.
+
address@hidden 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.
+
address@hidden Shell Options
address@hidden Shell Mode Options
+
address@hidden 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. The default is @code{nil}.
+
address@hidden 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 scroll the last
+line of text to the bottom line of the window, showing as much useful
+text as possible. (This mimics the scrolling behavior of most
+terminals.) The default is @code{t}.
+
address@hidden 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
address@hidden, point jumps in the selected window. If the value is
address@hidden, 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.
+
address@hidden comint-prompt-read-only
+ If you set @code{comint-prompt-read-only}, the prompts in the Comint
+buffer are read-only.
+
address@hidden 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.
+
address@hidden comint-completion-addsuffix
address@hidden comint-completion-recexact
address@hidden comint-completion-autolist
+ Three variables customize file name completion. The variable
address@hidden 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).
address@hidden, if address@hidden, directs @key{TAB}
+to choose the shortest possible completion if the usual Emacs completion
+algorithm cannot add even a single character.
address@hidden, if address@hidden, says to list all
+the possible completions whenever completion is not exact.
+
address@hidden 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.
+
address@hidden shell-pushd-tohome
address@hidden shell-pushd-dextract
address@hidden 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:
+
address@hidden
+(add-hook 'shell-mode-hook 'ansi-color-for-comint-mode-on)
address@hidden example
+
address@hidden Terminal emulator
address@hidden Emacs Terminal Emulator
address@hidden 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.
+
address@hidden Term Mode
address@hidden Term Mode
address@hidden Term mode
address@hidden 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:
+
address@hidden @kbd
address@hidden C-c C-j @r{(Term mode)}
address@hidden term-char-mode
address@hidden C-c C-j
+Switch to line mode. Do nothing if already in line mode.
+
address@hidden C-c C-k @r{(Term mode)}
address@hidden term-line-mode
address@hidden C-c C-k
+Switch to char mode. Do nothing if already in char mode.
address@hidden table
+
+ The following commands are only available in char mode:
+
address@hidden @kbd
address@hidden C-c C-c
+Send a literal @key{C-c} to the sub-shell.
+
address@hidden C-c @var{char}
+This is equivalent to @kbd{C-x @var{char}} in normal Emacs. For
+example, @kbd{C-c o} invokes the global binding of @kbd{C-x o}, which
+is normally @samp{other-window}.
address@hidden table
+
address@hidden Paging in Term
address@hidden Page-At-A-Time Output
address@hidden 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.
+
address@hidden @kbd
address@hidden C-c C-q @r{(Term mode)}
address@hidden term-pager-toggle
address@hidden 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}.
address@hidden table
+
+ With page-at-a-time enabled, whenever Term receives more than a
+screenful of output since your last input, it pauses, displaying
address@hidden 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.
+
address@hidden Remote Host
address@hidden Remote Host Shell
address@hidden remote host
address@hidden connecting to remote host
address@hidden Telnet
address@hidden Rlogin
+
+ You can login to a remote computer, using whatever commands you
+would from a regular terminal (e.g.@: using the @code{telnet} or
address@hidden 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, by setting the @env{TERM} environment
+variable in the environment for the remote login command. (If you use
+bash, you do that by writing the variable assignment before the remote
+login command, without separating comma.) Terminal types @samp{ansi}
+or @samp{vt100} will work on most systems.
+
address@hidden If you are talking to a Bourne-compatible
address@hidden shell, and your system understands the @env{TERMCAP} variable,
address@hidden you can use the command @kbd{M-x shell-send-termcap}, which
address@hidden sends a string specifying the terminal type and size.
address@hidden (This command is also useful after the window has changed size.)
+
address@hidden You can of course run @samp{gdb} on that remote computer. One
useful
address@hidden trick: If you invoke gdb with the @code{--fullname} option,
address@hidden it will send special commands to Emacs that will cause Emacs to
address@hidden pop up the source files you're debugging. This will work
address@hidden whether or not gdb is running on a different computer than Emacs,
address@hidden as long as Emacs can access the source files specified by gdb.
+
address@hidden
+ You cannot log in to a remote computer using the Shell mode.
address@hidden (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:
+
address@hidden @kbd
address@hidden M-x telnet @key{RET} @var{hostname} @key{RET}
+Set up a Telnet connection to the computer named @var{hostname}.
address@hidden M-x rlogin @key{RET} @var{hostname} @key{RET}
+Set up an Rlogin connection to the computer named @var{hostname}.
address@hidden table
+
address@hidden 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.
+
address@hidden rlogin
address@hidden 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.
+
address@hidden rlogin-directory-tracking-mode
+ There are two ways of doing directory tracking in an Rlogin
+buffer---either with remote directory names
address@hidden/@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.
+
address@hidden ignore
+
address@hidden Emacs Server, Printing, Shell, Top
address@hidden Using Emacs as a Server
address@hidden emacsclient
address@hidden Emacs as a server
address@hidden server, using Emacs as
address@hidden @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
address@hidden 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 with 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 program and the
+server that is part of Emacs. Here is how.
+
address@hidden @env{TEXEDIT} environment variable
address@hidden server-start
+ First, the preparations. Within Emacs, call the function
address@hidden (Your @file{.emacs} init file can do this
+automatically if you add the expression @code{(server-start)} to it,
+see @ref{Init File}.) 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
address@hidden, you should set the @env{TEXEDIT} environment
+variable to @samp{emacsclient +%d %s}.)
+
address@hidden emacs.bash
address@hidden Bash command to use Emacs server
+ As an alternative to using @code{emacsclient}, the file
address@hidden/emacs.bash} defines a Bash command @code{edit} which will
+communicate with a running Emacs session, or start one if none exist.
+
address@hidden C-x #
address@hidden server-edit
+ Now, 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 in the already running Emacs session.
+
+ 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.
+
address@hidden server-kill-new-buffers
address@hidden 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
address@hidden This is set up to distinguish certain
+``temporary'' files.
+
address@hidden server-window
+ If you set the variable @code{server-window} to a window or a frame,
address@hidden #} displays the server buffer in that window or in that frame.
+
address@hidden server-name
+ You can run multiple Emacs servers on the same machine by giving
+each one a unique ``server name'', using the variable
address@hidden For example, @kbd{M-x set-variable @key{RET}
+server-name @key{RET} foo @key{RET}} sets the server name to
address@hidden The @code{emacsclient} program can specify a server by
+name using the @samp{-s} option. @xref{Invoking emacsclient}.
+
+ While @code{mail} or another application is waiting for
address@hidden 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:
+
address@hidden @bullet
address@hidden
+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.
+
address@hidden
+Using virtual terminals, run @code{mail} in one virtual terminal
+and run Emacs in another.
+
address@hidden
+Use Shell mode or Term mode in Emacs to run the other program such as
address@hidden; then, @code{emacsclient} blocks only the subshell under
+Emacs, and you can still use Emacs to edit the file.
address@hidden 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.
+
address@hidden
+* Invoking emacsclient:: Emacs client startup options.
address@hidden menu
+
address@hidden Invoking emacsclient,, Emacs Server, Emacs Server
address@hidden Invoking @code{emacsclient}
address@hidden @code{emacsclient} invocation and options
+
+ To run the @code{emacsclient} program, specify file names as arguments,
+and optionally line numbers as well, like this:
+
address@hidden
+emacsclient @address@hidden@address@hidden@address@hidden@address@hidden
@address@hidden@address@hidden
address@hidden example
+
address@hidden
+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
address@hidden #} command on each of these buffers. When that happens,
+Emacs sends a message to the @code{emacsclient} program telling it to
+return.
+
+ If you invoke @code{emacsclient} for more than one file, the
+additional client buffers are buried at the bottom of the buffer list
+(@pxref{Buffers}). If you call @kbd{C-x #} after you are done editing
+a client buffer, the next client buffer is automatically selected.
+
+ But if you use the option @samp{-n} or @samp{--no-wait} when running
address@hidden, then it returns immediately. (You can take as
+long as you like to edit the files in Emacs.)
+
+ The option @samp{-a @var{command}} or
address@hidden@var{command}} specifies a command to run if
address@hidden fails to contact Emacs. This is useful when
+running @code{emacsclient} in a script. For example, the following
+setting for the @env{EDITOR} environment variable will always give you
+an editor, even if no Emacs server is running:
+
address@hidden
+EDITOR="emacsclient --alternate-editor emacs +%d %s"
address@hidden example
+
address@hidden
address@hidden @env{ALTERNATE_EDITOR} environment variable
+The environment variable @env{ALTERNATE_EDITOR} has the same effect, with
+the value of the @samp{--alternate-editor} option taking precedence.
+
+If you use several displays, you can tell Emacs on which display to
+open the given files with the @samp{-d @var{display}} or
address@hidden@var{display}} option to @code{emacsclient}. This is
+handy when connecting from home to an Emacs session running on your
+machine at your workplace.
+
+If there is more than one Emacs server running, you can specify a
+server name with the @samp{-s @var{name}} or
address@hidden@var{name}} option to @code{emacsclient}. (This
+option is not supported on MS-Windows.)
+
+You can also use @code{emacsclient} to execute any piece of Emacs Lisp
+code, using the @samp{-e} or @samp{--eval} option. When this option
+is given, the rest of the arguments is interpreted as a list of
+expressions to evaluate, not a list of files to visit.
+
address@hidden @env{EMACS_SERVER_FILE} environment variable
+When you start the Emacs server (by calling @code{server-start}),
+Emacs creates a file with information about TCP connection to the
+server: the host where Emacs is running, the port where it is
+listening, and an authentication string. @code{emacsclient} uses this
+information if it needs to connect to the server via TCP. By default,
+the file goes in the @file{~/.emacs.d/server/} address@hidden
+MS-Windows, if @env{HOME} is not set or the TCP configuration file
+cannot be found there, Emacs also looks for the file in the
address@hidden/server/} subdirectory of the directory pointed to by
+the @env{APPDATA} environment variable.}. You can specify the file
+name to use with the @samp{-f @var{file}} or
address@hidden@var{file}} options, or by setting
address@hidden environment variable to the file name.
+
address@hidden Printing, Sorting, Emacs Server, Top
address@hidden Printing Hard Copies
address@hidden hardcopy
address@hidden printing
+
+ Emacs provides commands for printing hard copies of either an entire
+buffer or just part of one, with or without page headers. You can
+invoke the printing commands directly, as detailed in the following
+section, or using the @samp{File} menu on the menu bar. See also the
+hardcopy commands of Dired (@pxref{Misc File Ops}) and the diary
+(@pxref{Displaying the Diary}).
+
address@hidden @kbd
address@hidden M-x print-buffer
+Print hardcopy of current buffer with page headings containing the file
+name and page number.
address@hidden M-x lpr-buffer
+Print hardcopy of current buffer without page headings.
address@hidden M-x print-region
+Like @code{print-buffer} but print only the current region.
address@hidden M-x lpr-region
+Like @code{lpr-buffer} but print only the current region.
address@hidden table
+
address@hidden print-buffer
address@hidden print-region
address@hidden lpr-buffer
address@hidden lpr-region
address@hidden 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
address@hidden 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
address@hidden like this:
+
address@hidden
+(setq lpr-switches '("-w80"))
address@hidden example
+
address@hidden printer-name
+ You can specify the printer to use by setting the variable
address@hidden
+
address@hidden lpr-headers-switches
address@hidden lpr-commands
address@hidden 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
address@hidden 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
address@hidden) to the printer program: @code{nil} means don't add them.
address@hidden should be @code{nil} if your printer program is
+not compatible with @code{lpr}.
+
address@hidden
+* PostScript:: Printing buffers or regions as PostScript.
+* PostScript Variables:: Customizing the PostScript printing commands.
+* Printing Package:: An optional advanced printing interface.
address@hidden menu
+
address@hidden PostScript, PostScript Variables,, Printing
address@hidden PostScript Hardcopy
+
+ These commands convert buffer contents to PostScript,
+either printing it or leaving it in another Emacs buffer.
+
address@hidden @kbd
address@hidden M-x ps-print-buffer
+Print hardcopy of the current buffer in PostScript form.
address@hidden M-x ps-print-region
+Print hardcopy of the current region in PostScript form.
address@hidden 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.
address@hidden M-x ps-print-region-with-faces
+Print hardcopy of the current region in PostScript form, showing the
+faces used in the text.
address@hidden M-x ps-spool-buffer
+Generate PostScript for the current buffer text.
address@hidden M-x ps-spool-region
+Generate PostScript for the current region.
address@hidden M-x ps-spool-buffer-with-faces
+Generate PostScript for the current buffer, showing the faces used.
address@hidden M-x ps-spool-region-with-faces
+Generate PostScript for the current region, showing the faces used.
address@hidden M-x handwrite
+Generates/prints PostScript for the current buffer as if handwritten.
address@hidden table
+
address@hidden ps-print-region
address@hidden ps-print-buffer
address@hidden ps-print-region-with-faces
address@hidden ps-print-buffer-with-faces
+ The PostScript commands, @code{ps-print-buffer} and
address@hidden, print buffer contents in PostScript form. One
+command prints the entire buffer; the other, just the region. The
+corresponding @samp{-with-faces} commands,
address@hidden 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}.
+
address@hidden ps-spool-region
address@hidden ps-spool-buffer
address@hidden ps-spool-region-with-faces
address@hidden 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.
+
address@hidden handwrite
address@hidden handwriting
address@hidden 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.
+
address@hidden
+ The following section describes variables for customizing these commands.
address@hidden ifnottex
+
address@hidden PostScript Variables, Printing Package, PostScript, Printing
address@hidden Variables for PostScript Hardcopy
+
address@hidden ps-lpr-command
address@hidden ps-lpr-switches
address@hidden ps-printer-name
+ All the PostScript hardcopy commands use the variables
address@hidden and @code{ps-lpr-switches} to specify how to print
+the output. @code{ps-lpr-command} specifies the command name to run,
address@hidden specifies command line options to use, and
address@hidden specifies the printer. If you don't set the
+first two variables yourself, they take their initial values from
address@hidden and @code{lpr-switches}. If @code{ps-printer-name}
+is @code{nil}, @code{printer-name} is used.
+
address@hidden 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.
+
address@hidden color emulation on black-and-white printers
address@hidden 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.
+
address@hidden 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.
+
address@hidden ps-paper-type
address@hidden 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},
address@hidden, @code{b4}, @code{b5}, @code{executive}, @code{ledger},
address@hidden, @code{letter}, @code{letter-small}, @code{statement},
address@hidden The default is @code{letter}. You can define
+additional paper sizes by changing the variable
address@hidden
+
address@hidden 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.
+
address@hidden 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.
+
address@hidden ps-font-family
address@hidden ps-font-size
address@hidden 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},
address@hidden, @code{NewCenturySchlbk}, @code{Palatino} and
address@hidden The variable @code{ps-font-size} specifies the size of
+the font for ordinary text. It defaults to 8.5 points.
+
address@hidden ps-multibyte-buffer
address@hidden Intlfonts for PostScript printing
address@hidden 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,
address@hidden, 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.
+
address@hidden 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}.
+
address@hidden Printing Package,, PostScript Variables, Printing
address@hidden Printing Package
address@hidden Printing package
+
+ The basic Emacs facilities for printing hardcopy can be extended
+using the Printing package. This provides an easy-to-use interface
+for choosing what to print, previewing PostScript files before
+printing, and setting various printing options such as print headers,
+landscape or portrait modes, duplex modes, and so forth. On GNU/Linux
+or Unix systems, the Printing package relies on the @file{gs} and
address@hidden utilities, which are distributed as part of the GhostScript
+program. On MS-Windows, the @file{gstools} port of Ghostscript can be
+used.
+
address@hidden pr-interface
+ To use the Printing package, add @code{(require 'printing)} to your
+init file (@pxref{Init File}), followed by @code{(pr-update-menus)}.
+This function replaces the usual printing commands in the menu bar
+with a @samp{Printing} submenu that contains various printing options.
+You can also type @kbd{M-x pr-interface RET}; this creates a
address@hidden Interface*} buffer, similar to a customization buffer,
+where you can set the printing options. After selecting what and how
+to print, you start the print job using the @samp{Print} button (click
address@hidden on it, or move point over it and type @kbd{RET}). For
+further information on the various options, use the @samp{Interface
+Help} button.
+
address@hidden Sorting, Narrowing, Printing, Top
address@hidden Sorting Text
address@hidden sorting
+
+ Emacs provides several commands for sorting text in the buffer. All
+operate on the contents of the region.
+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.
+
address@hidden sort-lines
address@hidden sort-paragraphs
address@hidden sort-pages
address@hidden sort-fields
address@hidden sort-numeric-fields
address@hidden sort-numeric-base
address@hidden @kbd
address@hidden 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.
+
address@hidden 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.
+
address@hidden 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.
+
address@hidden 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.
+
address@hidden 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
address@hidden are interpreted as hexadecimal and octal, respectively.
+
address@hidden 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.
+
address@hidden 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.
address@hidden table
+
+ For example, if the buffer contains this:
+
address@hidden
+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.
address@hidden smallexample
+
address@hidden
+applying @kbd{M-x sort-lines} to the entire buffer produces this:
+
address@hidden
+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
address@hidden smallexample
+
address@hidden
+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:
+
address@hidden
+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
address@hidden smallexample
+
address@hidden
+where the sort keys were @samp{Emacs}, @samp{If}, @samp{buffer},
address@hidden and @samp{the}.
+
address@hidden 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
address@hidden 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.
address@hidden
+
address@hidden sort-fold-case
+ Many of the sort commands ignore case differences when comparing, if
address@hidden is address@hidden
+
address@hidden Narrowing, Two-Column, Sorting, Top
address@hidden Narrowing
address@hidden widening
address@hidden restriction
address@hidden narrowing
address@hidden 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 bounds of narrowing in effect in a buffer
+are 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 limit the
+range of operation of a replace command or repeating keyboard macro.
+
address@hidden @kbd
address@hidden C-x n n
+Narrow down to between point and mark (@code{narrow-to-region}).
address@hidden C-x n w
+Widen to make the entire buffer accessible again (@code{widen}).
address@hidden C-x n p
+Narrow down to the current page (@code{narrow-to-page}).
address@hidden C-x n d
+Narrow down to the current defun (@code{narrow-to-defun}).
address@hidden 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.
+
address@hidden C-x n n
address@hidden 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.
+
address@hidden C-x n p
address@hidden narrow-to-page
address@hidden C-x n d
address@hidden 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.
address@hidden n d} (@code{narrow-to-defun}) narrows down to the defun
+containing point (@pxref{Defuns}).
+
address@hidden C-x n w
address@hidden 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,
address@hidden 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}.
+
address@hidden Two-Column, Editing Binary Files, Narrowing, Top
address@hidden Two-Column Editing
address@hidden two-column editing
address@hidden splitting columns
address@hidden 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:
+
address@hidden @asis
address@hidden @address@hidden 2} or @kbd{C-x 6 2}
address@hidden F2 2
address@hidden C-x 6 2
address@hidden 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.
+
address@hidden @address@hidden s} or @kbd{C-x 6 s}
address@hidden F2 s
address@hidden C-x 6 s
address@hidden 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.
+
address@hidden @address@hidden b @var{buffer} @key{RET}}
address@hidden @kbd{C-x 6 b @var{buffer} @key{RET}}
address@hidden F2 b
address@hidden C-x 6 b
address@hidden 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}).
address@hidden 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@key{F2} s}; that many characters, before point, constitute the
+separator string. By default, the width is 1, so the column separator
+is the character before point.
+
+ When a line has the separator at the proper place, @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.)
+
address@hidden F2 RET
address@hidden C-x 6 RET
address@hidden 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.
+
address@hidden F2 1
address@hidden C-x 6 1
address@hidden 2C-merge
+ When you have edited both buffers as you wish, merge them with
address@hidden@key{F2} 1} or @kbd{C-x 6 1} (@code{2C-merge}). This copies the
+text from the right-hand buffer as a second column in the other buffer.
+To go back to two-column editing, use @address@hidden s}.
+
address@hidden F2 d
address@hidden C-x 6 d
address@hidden 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@key{F2} d} kills it.
+
address@hidden Editing Binary Files, Saving Emacs Sessions, Two-Column, Top
address@hidden Editing Binary Files
+
address@hidden Hexl mode
address@hidden mode, Hexl
address@hidden editing binary files
address@hidden 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:
+
address@hidden I don't think individual index entries for these commands are
useful--RMS.
address@hidden @kbd
address@hidden C-M-d
+Insert a byte with a code typed in decimal.
+
address@hidden C-M-o
+Insert a byte with a code typed in octal.
+
address@hidden C-M-x
+Insert a byte with a code typed in hex.
+
address@hidden C-x [
+Move to the beginning of a 1k-byte ``page.''
+
address@hidden C-x ]
+Move to the end of a 1k-byte ``page.''
+
address@hidden M-g
+Move to an address specified in hex.
+
address@hidden M-j
+Move to an address specified in decimal.
+
address@hidden C-c C-c
+Leave Hexl mode, going back to the major mode this buffer had before you
+invoked @code{hexl-mode}.
address@hidden table
+
address@hidden
+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.
+
+
address@hidden Saving Emacs Sessions, Recursive Edit, Editing Binary Files, Top
address@hidden Saving Emacs Sessions
address@hidden saving sessions
address@hidden restore session
address@hidden remember editing session
address@hidden reload files
address@hidden 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.
+
address@hidden desktop-save
address@hidden desktop-save-mode
+ You can save the desktop manually with the command @kbd{M-x
+desktop-save}. You can also enable automatic saving of the desktop
+when you exit Emacs, and automatic restoration of the last saved
+desktop when Emacs starts: 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:
+
address@hidden
+(desktop-save-mode 1)
address@hidden example
+
address@hidden desktop-change-dir
address@hidden desktop-revert
+ If you turn on @code{desktop-save-mode} in your @file{~/.emacs},
+then 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
address@hidden 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. This turns off
address@hidden for the current session. Starting Emacs with
+the @samp{--no-init-file} option also disables desktop reloading,
+since it bypasses the @file{.emacs} init file, where
address@hidden is usually turned on.
+
address@hidden desktop-restore-eager
+ By default, all the buffers in the desktop are restored at one go.
+However, this may be slow if there are a lot of buffers in the
+desktop. You can specify the maximum number of buffers to restore
+immediately with the variable @code{desktop-restore-eager}; the
+remaining buffers are restored ``lazily,'' when Emacs is idle.
+
address@hidden desktop-clear
address@hidden desktop-globals-to-clear
address@hidden 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
address@hidden, whose value is a regular
+expression matching the names of buffers not to kill.
+
+ If you want to save minibuffer history from one session to
+another, use the @code{savehist} library.
+
address@hidden Recursive Edit, Emulation, Saving Emacs Sessions, Top
address@hidden Recursive Editing Levels
address@hidden recursive editing level
address@hidden 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
address@hidden, 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}.
+
address@hidden C-M-c
address@hidden exit-recursive-edit
address@hidden 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
address@hidden (@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.
+
address@hidden Emulation, Hyperlinking, Recursive Edit, Top
address@hidden Emulation
address@hidden emulating other editors
address@hidden other editors
address@hidden EDT
address@hidden vi
address@hidden PC key bindings
address@hidden scrolling all windows
address@hidden PC selection
address@hidden Motif key bindings
address@hidden Macintosh key bindings
address@hidden WordStar
+
+ GNU Emacs can be programmed to emulate (more or less) most other
+editors. Standard facilities can emulate these:
+
address@hidden @asis
address@hidden CRiSP/Brief (PC editor)
address@hidden crisp-mode
address@hidden crisp-override-meta-x
address@hidden scroll-all-mode
address@hidden CRiSP mode
address@hidden Brief emulation
address@hidden emulation of Brief
address@hidden mode, CRiSP
+You can turn on key bindings to emulate the CRiSP/Brief editor with
address@hidden crisp-mode}. Note that this rebinds @kbd{M-x} to exit Emacs
+unless you set the variable @code{crisp-override-meta-x}. You can
+also use the command @kbd{M-x scroll-all-mode} or set the variable
address@hidden to emulate CRiSP's scroll-all feature
+(scrolling all windows together).
+
address@hidden EDT (DEC VMS editor)
address@hidden edt-emulation-on
address@hidden edt-emulation-off
+Turn on EDT emulation with the command @kbd{M-x edt-emulation-on},
+while @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.
+
address@hidden TPU (DEC VMS editor)
address@hidden tpu-edt-on
address@hidden TPU
address@hidden tpu-edt-on} turns on emulation of the TPU editor emulating EDT.
+
address@hidden vi (Berkeley editor)
address@hidden 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}.
+
address@hidden vi (another emulator)
address@hidden vi-mode
address@hidden 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.
+
address@hidden vi (alternate emulator)
address@hidden vip-mode
address@hidden 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.
+
address@hidden, VIP, vip}, for full information.
+
address@hidden WordStar (old wordprocessor)
address@hidden wordstar-mode
address@hidden wordstar-mode} provides a major mode with WordStar-like
+key bindings.
address@hidden table
+
address@hidden Hyperlinking, Dissociated Press, Emulation, Top
address@hidden Hyperlinking and Navigation Features
+
address@hidden hyperlinking
address@hidden 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. Clicking @kbd{Mouse-1}
+quickly on the link also follows it. (Hold @kbd{Mouse-1} for longer
+if you want to set point instead.)
+
+ Info mode, Help mode and the Dired-like modes are examples of modes
+that have links in the buffer. 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
address@hidden 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
address@hidden
+
+ Other non-mode-specific facilities described in this section enable
+following links from the current buffer in a context-sensitive
+fashion.
+
address@hidden
+* Browse-URL:: Following URLs.
+* Goto-address:: Activating URLs.
+* FFAP:: Finding files etc. at point.
address@hidden menu
+
address@hidden Browse-URL
address@hidden Following URLs
address@hidden World Wide Web
address@hidden Web
address@hidden browse-url
address@hidden browse-url-at-point
address@hidden browse-url-at-mouse
address@hidden Browse-URL
address@hidden URLs
+
address@hidden @kbd
address@hidden M-x browse-url @key{RET} @var{url} @key{RET}
+Load a URL into a Web browser.
address@hidden 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
address@hidden and @code{browse-url-at-mouse}.
+
address@hidden browse-url-browser-function
+ You can customize Browse-URL's behavior via various options in the
address@hidden Customize group, particularly
address@hidden 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.
+
address@hidden Goto-address
address@hidden Activating URLs
address@hidden goto-address
address@hidden Goto-address
address@hidden URLs, activating
+
address@hidden @kbd
address@hidden M-x goto-address
+Activate URLs and e-mail addresses in the current buffer.
address@hidden 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.
address@hidden is the appropriate hook for Rmail, and
address@hidden for MH-E. This is not needed for Gnus,
+which has a similar feature of its own.
+
+
address@hidden FFAP
address@hidden Finding Files and URLs at Point
address@hidden find-file-at-point
address@hidden ffap
address@hidden dired-at-point
address@hidden ffap-next
address@hidden ffap-menu
address@hidden finding file at point
+
+ FFAP mode replaces certain key bindings for finding files, including
address@hidden 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
address@hidden package's commentary available via @kbd{C-h p} under the
address@hidden keyword and the @code{ffap} Custom group provide details.
+
address@hidden FFAP minor mode
address@hidden 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
address@hidden in Rmail, Gnus and VM article buffers.
+
address@hidden @kbd
address@hidden C-x C-f @var{filename} @key{RET}
address@hidden C-x C-f @r{(FFAP)}
+Find @var{filename}, guessing a default from text around point
+(@code{find-file-at-point}).
address@hidden C-x C-r
address@hidden C-x C-r @r{(FFAP)}
address@hidden, analogous to @code{find-file-read-only}.
address@hidden C-x C-v
address@hidden C-x C-v @r{(FFAP)}
address@hidden, analogous to @code{find-alternate-file}.
address@hidden C-x d @var{directory} @key{RET}
address@hidden C-x d @r{(FFAP)}
+Start Dired on @var{directory}, defaulting to the directory name at
+point (@code{dired-at-point}).
address@hidden C-x C-d
address@hidden, analogous to @code{list-directory}.
address@hidden C-x 4 f
address@hidden C-x 4 f @r{(FFAP)}
address@hidden, analogous to @code{find-file-other-window}.
address@hidden C-x 4 r
address@hidden, analogous to
address@hidden
address@hidden C-x 4 d
address@hidden, analogous to @code{dired-other-window}.
address@hidden C-x 5 f
address@hidden C-x 5 f @r{(FFAP)}
address@hidden, analogous to @code{find-file-other-frame}.
address@hidden C-x 5 r
address@hidden, analogous to
address@hidden
address@hidden C-x 5 d
address@hidden, analogous to @code{dired-other-frame}.
address@hidden M-x ffap-next
+Search buffer for next file name or URL, then find that file or URL.
address@hidden S-Mouse-3
address@hidden S-Mouse-3 @r{(FFAP)}
address@hidden finds the file guessed from text around the position
+of a mouse click.
address@hidden C-S-Mouse-3
address@hidden 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}).
address@hidden table
+
address@hidden Dissociated Press, Amusements, Hyperlinking, Top
address@hidden Dissociated Press
+
address@hidden 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
address@hidden buffer for you to copy elsewhere if you wish.
+
address@hidden 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. Bush has made it appropriate again.} Long sample texts
+produce the best results.
+
address@hidden 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.
+
address@hidden Markov chain
address@hidden ignoriginal
address@hidden techniquitous
+ Dissociated Press produces results fairly like those of 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.
+
address@hidden outragedy
address@hidden buggestion
address@hidden properbose
address@hidden mustatement
address@hidden developediment
address@hidden 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.
+
address@hidden Amusements, Customization, Dissociated Press, Top
address@hidden Other Amusements
address@hidden boredom
address@hidden hanoi
address@hidden yow
address@hidden gomoku
address@hidden 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.
+
address@hidden Go Moku
+ If you want a little more personal involvement, try @kbd{M-x gomoku},
+which plays the game Go Moku with you.
+
address@hidden blackbox
address@hidden mpuz
address@hidden 5x5
address@hidden puzzles
+ @kbd{M-x blackbox}, @kbd{M-x mpuz} and @kbd{M-x 5x5} are puzzles.
address@hidden 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.
+
address@hidden decipher
address@hidden ciphers
address@hidden cryptanalysis
address@hidden decipher} helps you to cryptanalyze a buffer which is encrypted
+in a simple monoalphabetic substitution cipher.
+
address@hidden dunnet
+ @kbd{M-x dunnet} runs an adventure-style exploration game, which is
+a bigger sort of puzzle.
+
address@hidden lm
address@hidden landmark game
address@hidden 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.
+
address@hidden life
address@hidden Life
address@hidden life} runs Conway's ``Life'' cellular automaton.
+
address@hidden morse-region
address@hidden unmorse-region
address@hidden Morse code
address@hidden --/---/.-./.../.
address@hidden morse-region} converts text in a region to Morse code and
address@hidden unmorse-region} converts it back. No cause for remorse.
+
address@hidden pong
address@hidden Pong game
address@hidden pong} plays a Pong-like game, bouncing the ball off opposing
+bats.
+
address@hidden solitaire
address@hidden solitaire
address@hidden solitaire} plays a game of solitaire in which you jump pegs
+across other pegs.
+
address@hidden studlify-region
address@hidden StudlyCaps
address@hidden studlify-region} studlify-cases the region, producing
+text like this:
+
address@hidden
+M-x stUdlIfY-RegioN stUdlIfY-CaSeS thE region.
address@hidden example
+
address@hidden tetris
address@hidden Tetris
address@hidden snake
address@hidden Snake
address@hidden 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
address@hidden doctor}. End each input by typing @key{RET} twice.
+
address@hidden Zippy
+ When you are feeling strange, type @kbd{M-x yow}.
+
address@hidden zone
+The command @kbd{M-x zone} plays games with the display when Emacs is
+idle.
+
address@hidden
address@hidden
address@hidden ifnottex
+
address@hidden
+ arch-tag: 8f094220-c0d5-4e9e-af7d-3e0da8187474
address@hidden ignore