2855 lines
114 KiB
Text
2855 lines
114 KiB
Text
@c This is part of the Emacs manual.
|
|
@c Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1997, 2000, 2001,
|
|
@c 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
|
|
@c Free Software Foundation, Inc.
|
|
@c See file emacs.texi for copying conditions.
|
|
@iftex
|
|
@chapter Miscellaneous Commands
|
|
|
|
This chapter contains several brief topics that do not fit anywhere
|
|
else: viewing ``document files'', 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.
|
|
|
|
@end iftex
|
|
|
|
@ifnottex
|
|
@raisesections
|
|
@end ifnottex
|
|
|
|
@node Document View, Gnus, Calendar/Diary, Top
|
|
@section Document Viewing
|
|
@cindex DVI file
|
|
@cindex PDF file
|
|
@cindex PS file
|
|
@cindex Postscript file
|
|
@cindex DocView mode
|
|
@cindex mode, DocView
|
|
@cindex document viewer (DocView)
|
|
@findex doc-view-mode
|
|
|
|
DocView mode (@code{doc-view-mode}) is a viewer for DVI, Postscript
|
|
(PS), and PDF documents. It provides features such as slicing,
|
|
zooming, and searching inside documents. It works by converting the
|
|
document to a set of images using the @command{gs} (GhostScript)
|
|
command, and displaying those images.
|
|
|
|
@findex doc-view-toggle-display
|
|
@findex doc-view-toggle-display
|
|
@cindex doc-view-minor-mode
|
|
When you visit a PDF or DVI file, Emacs automatically switches to
|
|
DocView mode. When you visit a Postscript file, Emacs switches to PS
|
|
mode, a major mode for editing Postscript files as text; however, it
|
|
also enables DocView minor mode, so you can type @kbd{C-c C-c} to view
|
|
the document with DocView. (PDF and DVI files, unlike Postscript
|
|
files, are not usually human-editable.) In either case, repeating
|
|
@kbd{C-c C-c} (@code{doc-view-toggle-display}) toggles between DocView
|
|
and the file text.
|
|
|
|
You can explicitly toggle DocView mode with the command @code{M-x
|
|
doc-view-mode}, and DocView minor mode with the command @code{M-x
|
|
doc-view-minor-mode}.
|
|
|
|
When DocView mode starts, it displays a welcome screen and begins
|
|
formatting the file, page by page. It displays the first page once
|
|
that has been formatted.
|
|
|
|
@findex doc-view-enlarge
|
|
@findex doc-view-shrink
|
|
@vindex doc-view-resolution
|
|
When in DocView mode, you can enlarge or shrink the document with
|
|
@kbd{+} (@code{doc-view-enlarge}) and @kbd{-}
|
|
(@code{doc-view-shrink}). To specify the default size for DocView,
|
|
set or customize the variable @code{doc-view-resolution}.
|
|
|
|
To kill the DocView buffer, type @kbd{k}
|
|
(@code{doc-view-kill-proc-and-buffer}). To bury it, type @kbd{q}
|
|
(@code{quit-window}).
|
|
|
|
@menu
|
|
* Navigation:: Navigation inside DocView buffers.
|
|
* Searching:: Searching inside documents.
|
|
* Slicing:: Specifying which part of pages should be displayed.
|
|
* Conversion:: Influencing and triggering conversion.
|
|
@end menu
|
|
|
|
@node Navigation
|
|
@subsection Navigation
|
|
|
|
When in DocView mode, you can scroll the current page using the usual
|
|
Emacs movement keys: @kbd{C-p}, @kbd{C-n}, @kbd{C-b}, @kbd{C-f}, and
|
|
the arrow keys.
|
|
|
|
@findex doc-view-next-page
|
|
@findex doc-view-previous-page
|
|
To display the next page, type @kbd{n}, @key{next} or @kbd{C-x ]}
|
|
(@code{doc-view-next-page}). To display the previous page, type
|
|
@kbd{p}, @key{prior} or @kbd{C-x [} (@code{doc-view-previous-page}).
|
|
|
|
@findex doc-view-scroll-up-or-next-page
|
|
@findex doc-view-scroll-down-or-previous-page
|
|
The @key{SPC} (@code{doc-view-scroll-up-or-next-page}) key is a
|
|
convenient way to advance through the document. It scrolls within the
|
|
current page or advances to the next. @key{DEL} moves backwards in a
|
|
similar way (@code{doc-view-scroll-down-or-previous-page}).
|
|
|
|
@findex doc-view-first-page
|
|
@findex doc-view-last-page
|
|
@findex doc-view-goto-page
|
|
To go to the first page, type @kbd{M-<}
|
|
(@code{doc-view-first-page}); to go to the last one, type @kbd{M->}
|
|
(@code{doc-view-last-page}). To jump to a page by its number, type
|
|
@kbd{M-g M-g} or @kbd{M-g g} (@code{doc-view-goto-page}).
|
|
|
|
@node Searching
|
|
@subsection Searching
|
|
|
|
While in DocView mode, you can search the file's text for a regular
|
|
expression (@pxref{Regexps}). The interface for searching is inspired
|
|
by @code{isearch} (@pxref{Incremental Search}).
|
|
|
|
@findex doc-view-search
|
|
@findex doc-view-search-backward
|
|
@findex doc-view-show-tooltip
|
|
To begin a search, type @kbd{C-s} (@code{doc-view-search}) or
|
|
@kbd{C-r} (@code{doc-view-search-backward}). This reads a regular
|
|
expression using a minibuffer, then echoes the number of matches found
|
|
within the document. You can move forward and back among the matches
|
|
by typing @kbd{C-s} and @kbd{C-r}. DocView mode has no way to show
|
|
the match inside the page image; instead, it displays a tooltip (at
|
|
the mouse position) listing all matching lines in the current page.
|
|
To force display of this tooltip, type @kbd{C-t}
|
|
(@code{doc-view-show-tooltip}).
|
|
|
|
To start a new search, use the search command with a prefix
|
|
argument; i.e., @kbd{C-u C-s} for a forward search or @kbd{C-u C-r}
|
|
for a backward search.
|
|
|
|
@node Slicing
|
|
@subsection Slicing
|
|
|
|
Documents often have wide margins for printing. They are annoying
|
|
when reading the document on the screen, because they use up screen
|
|
space and can cause inconvenient scrolling.
|
|
|
|
@findex doc-view-set-slice
|
|
@findex doc-view-set-slice-using-mouse
|
|
With DocView you can hide these margins by selecting a @dfn{slice}
|
|
of pages to display. A slice is a rectangle within the page area;
|
|
once you specify a slice in DocView, it applies to whichever page you
|
|
look at.
|
|
|
|
To specify the slice numerically, type @kbd{s s}
|
|
(@code{doc-view-set-slice}); then enter the top left pixel position
|
|
and the slice's width and height.
|
|
@c ??? how does this work?
|
|
|
|
A more convenient graphical way to specify the slice is with @kbd{s
|
|
m} (@code{doc-view-set-slice-using-mouse}), where you use the mouse to
|
|
select the slice.
|
|
@c ??? How does this work?
|
|
|
|
@findex doc-view-reset-slice
|
|
To cancel the selected slice, type @kbd{s r}
|
|
(@code{doc-view-reset-slice}). Then DocView shows the entire page
|
|
including its entire margins.
|
|
|
|
@node Conversion
|
|
@subsection Conversion
|
|
|
|
@vindex doc-view-cache-directory
|
|
@findex doc-view-clear-cache
|
|
For efficiency, DocView caches the images produced by @command{gs}.
|
|
The name of this directory is given by the variable
|
|
@code{doc-view-cache-directory}. You can clear the cache directory by
|
|
typing @code{M-x doc-view-clear-cache}.
|
|
|
|
@findex doc-view-kill-proc
|
|
@findex doc-view-kill-proc-and-buffer
|
|
To force a reconversion of the currently viewed document, type
|
|
@kbd{r} or @kbd{g} (@code{revert-buffer}). To kill the converter
|
|
process associated with the current buffer, type @kbd{K}
|
|
(@code{doc-view-kill-proc}). The command @kbd{k}
|
|
(@code{doc-view-kill-proc-and-buffer}) kills the converter process and
|
|
the DocView buffer.
|
|
|
|
The zoom commands @kbd{+} (@code{doc-view-enlarge}) and @kbd{-}
|
|
(@code{doc-view-shrink}) need to reconvert the document at the new
|
|
size. The current page is converted first.
|
|
|
|
@node Gnus, Shell, Document View, Top
|
|
@section Gnus
|
|
@cindex Gnus
|
|
@cindex reading netnews
|
|
|
|
Gnus is an Emacs package primarily designed for reading and posting
|
|
Usenet news. It can also be used to read and respond to messages from a
|
|
number of other sources---mail, remote directories, digests, and so on.
|
|
Here we introduce Gnus and describe several basic features.
|
|
@ifnottex
|
|
For full details, see @ref{Top, Gnus,, gnus, The Gnus Manual}.
|
|
@end ifnottex
|
|
@iftex
|
|
For full details on Gnus, type @kbd{M-x info} and then select the Gnus
|
|
manual.
|
|
@end iftex
|
|
|
|
@findex gnus
|
|
To start Gnus, type @kbd{M-x gnus @key{RET}}.
|
|
|
|
@menu
|
|
* Buffers of Gnus:: The group, summary, and article buffers.
|
|
* Gnus Startup:: What you should know about starting Gnus.
|
|
* Summary of Gnus:: A short description of the basic Gnus commands.
|
|
@end menu
|
|
|
|
@node Buffers of Gnus
|
|
@subsection Gnus Buffers
|
|
|
|
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
|
|
@dfn{article 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.
|
|
|
|
@node Gnus Startup
|
|
@subsection When Gnus Starts Up
|
|
|
|
At startup, Gnus reads your @file{.newsrc} news initialization file
|
|
and attempts to communicate with the local news server, which is a
|
|
repository of news articles. The news server need not be the same
|
|
computer you are logged in on.
|
|
|
|
If you start Gnus and connect to the server, but do not see any
|
|
newsgroups listed in the group buffer, type @kbd{L} or @kbd{A k} to get
|
|
a listing of all the groups. Then type @kbd{u} to toggle
|
|
subscription to groups.
|
|
|
|
The first time you start Gnus, Gnus subscribes you to a few selected
|
|
groups. All other groups start out as @dfn{killed groups} for you; you
|
|
can list them with @kbd{A k}. All new groups that subsequently come to
|
|
exist at the news server become @dfn{zombie groups} for you; type @kbd{A
|
|
z} to list them. You can subscribe to a group shown in these lists
|
|
using the @kbd{u} command.
|
|
|
|
When you quit Gnus with @kbd{q}, it automatically records in your
|
|
@file{.newsrc} and @file{.newsrc.eld} initialization files the
|
|
subscribed or unsubscribed status of all groups. You should normally
|
|
not edit these files manually, but you may if you know how.
|
|
|
|
@node Summary of Gnus
|
|
@subsection Summary of Gnus Commands
|
|
|
|
Reading news is a two-step process:
|
|
|
|
@enumerate
|
|
@item
|
|
Choose a group in the group buffer.
|
|
|
|
@item
|
|
Select articles from the summary buffer. Each article selected is
|
|
displayed in the article buffer in a large window, below the summary
|
|
buffer in its small window.
|
|
@end enumerate
|
|
|
|
Each Gnus buffer has its own special commands; the meanings of any
|
|
given key in the various Gnus buffers are usually analogous, even if
|
|
not identical. Here are commands for the group and summary buffers:
|
|
|
|
@table @kbd
|
|
@kindex q @r{(Gnus Group mode)}
|
|
@findex gnus-group-exit
|
|
@item q
|
|
In the group buffer, update your @file{.newsrc} initialization file
|
|
and quit Gnus.
|
|
|
|
In the summary buffer, exit the current group and return to the
|
|
group buffer. Thus, typing @kbd{q} twice quits Gnus.
|
|
|
|
@kindex L @r{(Gnus Group mode)}
|
|
@findex gnus-group-list-all-groups
|
|
@item L
|
|
In the group buffer, list all the groups available on your news
|
|
server (except those you have killed). This may be a long list!
|
|
|
|
@kindex l @r{(Gnus Group mode)}
|
|
@findex gnus-group-list-groups
|
|
@item l
|
|
In the group buffer, list only the groups to which you subscribe and
|
|
which contain unread articles.
|
|
|
|
@kindex u @r{(Gnus Group mode)}
|
|
@findex gnus-group-unsubscribe-current-group
|
|
@cindex subscribe groups
|
|
@cindex unsubscribe groups
|
|
@item u
|
|
In the group buffer, unsubscribe from (or subscribe to) the group listed
|
|
in the line that point is on. When you quit Gnus by typing @kbd{q},
|
|
Gnus lists in your @file{.newsrc} file which groups you have subscribed
|
|
to. The next time you start Gnus, you won't see this group,
|
|
because Gnus normally displays only subscribed-to groups.
|
|
|
|
@kindex C-k @r{(Gnus)}
|
|
@findex gnus-group-kill-group
|
|
@item C-k
|
|
In the group buffer, ``kill'' the current line's group---don't
|
|
even list it in @file{.newsrc} from now on. This affects future
|
|
Gnus sessions as well as the present session.
|
|
|
|
When you quit Gnus by typing @kbd{q}, Gnus writes information
|
|
in the file @file{.newsrc} describing all newsgroups except those you
|
|
have ``killed.''
|
|
|
|
@kindex SPC @r{(Gnus)}
|
|
@findex gnus-group-read-group
|
|
@item @key{SPC}
|
|
In the group buffer, select the group on the line under the cursor
|
|
and display the first unread article in that group.
|
|
|
|
@need 1000
|
|
In the summary buffer,
|
|
|
|
@itemize @bullet
|
|
@item
|
|
Select the article on the line under the cursor if none is selected.
|
|
|
|
@item
|
|
Scroll the text of the selected article (if there is one).
|
|
|
|
@item
|
|
Select the next unread article if at the end of the current article.
|
|
@end itemize
|
|
|
|
Thus, you can move through all the articles by repeatedly typing @key{SPC}.
|
|
|
|
@kindex DEL @r{(Gnus)}
|
|
@item @key{DEL}
|
|
In the group buffer, move point to the previous group containing
|
|
unread articles.
|
|
|
|
@findex gnus-summary-prev-page
|
|
In the summary buffer, scroll the text of the article backwards.
|
|
|
|
@kindex n @r{(Gnus)}
|
|
@findex gnus-group-next-unread-group
|
|
@findex gnus-summary-next-unread-article
|
|
@item n
|
|
Move point to the next unread group, or select the next unread article.
|
|
|
|
@kindex p @r{(Gnus)}
|
|
@findex gnus-group-prev-unread-group
|
|
@findex gnus-summary-prev-unread-article
|
|
@item p
|
|
Move point to the previous unread group, or select the previous
|
|
unread article.
|
|
|
|
@kindex C-n @r{(Gnus Group mode)}
|
|
@findex gnus-group-next-group
|
|
@kindex C-p @r{(Gnus Group mode)}
|
|
@findex gnus-group-prev-group
|
|
@kindex C-n @r{(Gnus Summary mode)}
|
|
@findex gnus-summary-next-subject
|
|
@kindex C-p @r{(Gnus Summary mode)}
|
|
@findex gnus-summary-prev-subject
|
|
@item C-n
|
|
@itemx C-p
|
|
Move point to the next or previous item, even if it is marked as read.
|
|
This does not select the article or group on that line.
|
|
|
|
@kindex s @r{(Gnus Summary mode)}
|
|
@findex gnus-summary-isearch-article
|
|
@item s
|
|
In the summary buffer, do an incremental search of the current text in
|
|
the article buffer, just as if you switched to the article buffer and
|
|
typed @kbd{C-s}.
|
|
|
|
@kindex M-s @r{(Gnus Summary mode)}
|
|
@findex gnus-summary-search-article-forward
|
|
@item M-s @var{regexp} @key{RET}
|
|
In the summary buffer, search forward for articles containing a match
|
|
for @var{regexp}.
|
|
|
|
@end table
|
|
|
|
@ignore
|
|
@node Where to Look
|
|
@subsection Where to Look Further
|
|
|
|
@c Too many references to the name of the manual if done with xref in TeX!
|
|
Gnus is powerful and customizable. Here are references to a few
|
|
@ifnottex
|
|
additional topics:
|
|
|
|
@end ifnottex
|
|
@iftex
|
|
additional topics in @cite{The Gnus Manual}:
|
|
|
|
@itemize @bullet
|
|
@item
|
|
Follow discussions on specific topics.@*
|
|
See section ``Threading.''
|
|
|
|
@item
|
|
Read digests. See section ``Document Groups.''
|
|
|
|
@item
|
|
Refer to and jump to the parent of the current article.@*
|
|
See section ``Finding the Parent.''
|
|
|
|
@item
|
|
Refer to articles by using Message-IDs included in the messages.@*
|
|
See section ``Article Keymap.''
|
|
|
|
@item
|
|
Save articles. See section ``Saving Articles.''
|
|
|
|
@item
|
|
Have Gnus score articles according to various criteria, like author
|
|
name, subject, or string in the body of the articles.@*
|
|
See section ``Scoring.''
|
|
|
|
@item
|
|
Send an article to a newsgroup.@*
|
|
See section ``Composing Messages.''
|
|
@end itemize
|
|
@end iftex
|
|
@ifnottex
|
|
@itemize @bullet
|
|
@item
|
|
Follow discussions on specific topics.@*
|
|
@xref{Threading, , Reading Based on Conversation Threads,
|
|
gnus, The Gnus Manual}.
|
|
|
|
@item
|
|
Read digests. @xref{Document Groups, , , gnus, The Gnus Manual}.
|
|
|
|
@item
|
|
Refer to and jump to the parent of the current article.@*
|
|
@xref{Finding the Parent, , , gnus, The Gnus Manual}.
|
|
|
|
@item
|
|
Refer to articles by using Message-IDs included in the messages.@*
|
|
@xref{Article Keymap, , , gnus, The Gnus Manual}.
|
|
|
|
@item
|
|
Save articles. @xref{Saving Articles, , , gnus, The Gnus Manual}.
|
|
|
|
@item
|
|
Have Gnus score articles according to various criteria, like author
|
|
name, subject, or string in the body of the articles.@*
|
|
@xref{Scoring, , , gnus, The Gnus Manual}.
|
|
|
|
@item
|
|
Send an article to a newsgroup.@*
|
|
@xref{Composing Messages, , , gnus, The Gnus Manual}.
|
|
@end itemize
|
|
@end ifnottex
|
|
@end ignore
|
|
|
|
@node Shell, Emacs Server, Gnus, Top
|
|
@section Running Shell Commands from Emacs
|
|
@cindex subshell
|
|
@cindex shell commands
|
|
|
|
Emacs has commands for passing single command lines to inferior shell
|
|
processes; it can also run a shell interactively with input and output
|
|
to an Emacs buffer named @samp{*shell*} or run a shell inside a terminal
|
|
emulator window.
|
|
|
|
@table @kbd
|
|
@item M-! @var{cmd} @key{RET}
|
|
Run the shell command line @var{cmd} and display the output
|
|
(@code{shell-command}).
|
|
@item M-| @var{cmd} @key{RET}
|
|
Run the shell command line @var{cmd} with region contents as input;
|
|
optionally replace the region with the output
|
|
(@code{shell-command-on-region}).
|
|
@item M-& @var{cmd} @key{RET}
|
|
Run the shell command line @var{cmd} asynchronously, and display the
|
|
output (@code{async-shell-command}).
|
|
@item M-x shell
|
|
Run a subshell with input and output through an Emacs buffer.
|
|
You can then give commands interactively.
|
|
@item M-x term
|
|
Run a subshell with input and output through an Emacs buffer.
|
|
You can then give commands interactively.
|
|
Full terminal emulation is available.
|
|
@end 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}.
|
|
|
|
@menu
|
|
* Single Shell:: How to run one shell command and return.
|
|
* Interactive Shell:: Permanent shell taking input via Emacs.
|
|
* Shell Mode:: Special Emacs commands used with permanent shell.
|
|
* 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.
|
|
* Serial Terminal:: Connecting to a serial port.
|
|
@end menu
|
|
|
|
@node Single Shell
|
|
@subsection Single Shell Commands
|
|
|
|
@kindex M-!
|
|
@findex shell-command
|
|
@kbd{M-!} (@code{shell-command}) reads a line of text using the
|
|
minibuffer and executes it as a shell command in a subshell made just
|
|
for that command. Standard input for the command comes from the null
|
|
device. If the shell command produces any output, the output appears
|
|
either in the echo area (if it is short), or in an Emacs buffer named
|
|
@samp{*Shell Command Output*}, which is displayed in another window
|
|
but not selected (if the output is long).
|
|
|
|
For instance, one way to decompress a file @file{foo.gz} from Emacs
|
|
is to type @kbd{M-! gunzip foo.gz @key{RET}}. That shell command
|
|
normally creates the file @file{foo} and produces no terminal output.
|
|
|
|
A numeric argument, as in @kbd{M-1 M-!}, says to insert terminal
|
|
output into the current buffer instead of a separate buffer. It puts
|
|
point before the output, and sets the mark after the output. For
|
|
instance, @kbd{M-1 M-! gunzip < foo.gz @key{RET}} would insert the
|
|
uncompressed equivalent of @file{foo.gz} into the current buffer.
|
|
|
|
If the shell command line ends in @samp{&}, it runs asynchronously.
|
|
For a synchronous shell command, @code{shell-command} returns the
|
|
command's exit status (0 means success), when it is called from a Lisp
|
|
program. You do not get any status information for an asynchronous
|
|
command, since it hasn't finished yet when @code{shell-command} returns.
|
|
|
|
You can also type @kbd{M-&} (@code{async-shell-command}) to execute
|
|
a shell command asynchronously. This behaves exactly like calling
|
|
@code{shell-command} with @samp{&}, except that you do not need to add
|
|
the @samp{&} to the shell command line.
|
|
|
|
@kindex M-|
|
|
@findex shell-command-on-region
|
|
@kbd{M-|} (@code{shell-command-on-region}) is like @kbd{M-!} but
|
|
passes the contents of the region as the standard input to the shell
|
|
command, instead of no input. 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
|
|
@kbd{C-x 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.
|
|
|
|
@vindex shell-file-name
|
|
Both @kbd{M-!} and @kbd{M-|} use @code{shell-file-name} to specify
|
|
the shell to use. This variable is initialized based on your
|
|
@env{SHELL} environment variable when Emacs is started. If the file
|
|
name is relative, Emacs searches the directories in the list
|
|
@code{exec-path}; this list is initialized based on the environment
|
|
variable @env{PATH} when Emacs is started. Your init file can
|
|
override either or both of these default initializations (@pxref{Init
|
|
File}).
|
|
|
|
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
|
|
@kbd{C-x @key{RET} c} immediately beforehand. @xref{Communication Coding}.
|
|
|
|
@vindex shell-command-default-error-buffer
|
|
Error output from these commands is normally intermixed with the
|
|
regular output. But if the variable
|
|
@code{shell-command-default-error-buffer} 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.
|
|
|
|
@node Interactive Shell
|
|
@subsection Interactive Inferior Shell
|
|
|
|
@findex shell
|
|
To run a subshell interactively, use @kbd{M-x shell}. This creates
|
|
(or reuses) a buffer named @samp{*shell*} and runs a subshell with
|
|
input coming from and output going to that buffer. That is to say,
|
|
any ``terminal output'' from the subshell goes into the buffer,
|
|
advancing point, and any ``terminal input'' for the subshell comes
|
|
from text in the buffer. To give input to the subshell, go to the end
|
|
of the buffer and type the input, terminated by @key{RET}.
|
|
|
|
Emacs does not wait for the subshell to do anything. You can switch
|
|
windows or buffers and edit them while the shell is waiting, or while it is
|
|
running a command. Output from the subshell waits until Emacs has time to
|
|
process it; this happens whenever Emacs is waiting for keyboard input or
|
|
for time to elapse.
|
|
|
|
@cindex @code{comint-highlight-input} face
|
|
@cindex @code{comint-highlight-prompt} face
|
|
Input lines, once you submit them, are displayed using the face
|
|
@code{comint-highlight-input}, and prompts are displayed using the
|
|
face @code{comint-highlight-prompt}. This makes it easier to see
|
|
previous input lines in the buffer. @xref{Faces}.
|
|
|
|
To make multiple subshells, you can invoke @kbd{M-x shell} with a
|
|
prefix argument (e.g. @kbd{C-u M-x shell}), which will read a buffer
|
|
name and create (or reuse) a subshell in that buffer. You can also
|
|
rename the @samp{*shell*} buffer using @kbd{M-x rename-uniquely}, then
|
|
create a new @samp{*shell*} buffer using plain @kbd{M-x shell}.
|
|
Subshells in different buffers run independently and in parallel.
|
|
|
|
@vindex explicit-shell-file-name
|
|
@cindex environment variables for subshells
|
|
@cindex @env{ESHELL} environment variable
|
|
@cindex @env{SHELL} environment variable
|
|
The file name used to load the subshell is the value of the variable
|
|
@code{explicit-shell-file-name}, if that is non-@code{nil}.
|
|
Otherwise, the environment variable @env{ESHELL} is used, or the
|
|
environment variable @env{SHELL} if there is no @env{ESHELL}. If the
|
|
file name specified is relative, the directories in the list
|
|
@code{exec-path} are searched; this list is initialized based on the
|
|
environment variable @env{PATH} when Emacs is started. Your init file
|
|
can override either or both of these default initializations.
|
|
(@pxref{Init File}).
|
|
|
|
Emacs sends the new shell the contents of the file
|
|
@file{~/.emacs_@var{shellname}} as input, if it exists, where
|
|
@var{shellname} is the name of the file that the shell was loaded
|
|
from. For example, if you use bash, the file sent to it is
|
|
@file{~/.emacs_bash}. If this file is not found, Emacs tries to fallback
|
|
on @file{~/.emacs.d/init_@var{shellname}.sh}.
|
|
|
|
To specify a coding system for the shell, you can use the command
|
|
@kbd{C-x @key{RET} c} immediately before @kbd{M-x shell}. You can
|
|
also change the coding system for a running subshell by typing
|
|
@kbd{C-x @key{RET} p} in the shell buffer. @xref{Communication
|
|
Coding}.
|
|
|
|
@cindex @env{INSIDE_EMACS} environment variable
|
|
Emacs sets the environment variable @env{INSIDE_EMACS} in the
|
|
subshell to a comma-separated list including the Emacs version.
|
|
Programs can check this variable to determine whether they are running
|
|
inside an Emacs subshell.
|
|
|
|
@cindex @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.
|
|
|
|
@node Shell Mode
|
|
@subsection Shell Mode
|
|
@cindex Shell mode
|
|
@cindex mode, Shell
|
|
|
|
Shell buffers use Shell mode, which defines several special keys
|
|
attached to the @kbd{C-c} prefix. They are chosen to resemble the usual
|
|
editing and job control characters present in shells that are not under
|
|
Emacs, except that you must type @kbd{C-c} first. Here is a complete list
|
|
of the special key bindings of Shell mode:
|
|
|
|
@table @kbd
|
|
@item @key{RET}
|
|
@kindex RET @r{(Shell mode)}
|
|
@findex comint-send-input
|
|
At end of buffer send line as input; otherwise, copy current line to
|
|
end of buffer and send it (@code{comint-send-input}). 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.
|
|
|
|
@item @key{TAB}
|
|
@kindex TAB @r{(Shell mode)}
|
|
@findex comint-dynamic-complete
|
|
Complete the command name or file name before point in the shell buffer
|
|
(@code{comint-dynamic-complete}). @key{TAB} also completes history
|
|
references (@pxref{History References}) and environment variable names.
|
|
|
|
@vindex shell-completion-fignore
|
|
@vindex comint-completion-fignore
|
|
The variable @code{shell-completion-fignore} specifies a list of file
|
|
name extensions to ignore in Shell mode completion. The default
|
|
setting is @code{nil}, but some users prefer @code{("~" "#" "%")} to
|
|
ignore file names ending in @samp{~}, @samp{#} or @samp{%}. Other
|
|
related Comint modes use the variable @code{comint-completion-fignore}
|
|
instead.
|
|
|
|
@item M-?
|
|
@kindex M-? @r{(Shell mode)}
|
|
@findex comint-dynamic-list-filename@dots{}
|
|
Display temporarily a list of the possible completions of the file name
|
|
before point in the shell buffer
|
|
(@code{comint-dynamic-list-filename-completions}).
|
|
|
|
@item C-d
|
|
@kindex C-d @r{(Shell mode)}
|
|
@findex comint-delchar-or-maybe-eof
|
|
Either delete a character or send @acronym{EOF}
|
|
(@code{comint-delchar-or-maybe-eof}). Typed at the end of the shell
|
|
buffer, @kbd{C-d} sends @acronym{EOF} to the subshell. Typed at any other
|
|
position in the buffer, @kbd{C-d} deletes a character as usual.
|
|
|
|
@item C-c C-a
|
|
@kindex C-c C-a @r{(Shell mode)}
|
|
@findex comint-bol-or-process-mark
|
|
Move to the beginning of the line, but after the prompt if any
|
|
(@code{comint-bol-or-process-mark}). If you repeat this command twice
|
|
in a row, the second time it moves back to the process mark, which is
|
|
the beginning of the input that you have not yet sent to the subshell.
|
|
(Normally that is the same place---the end of the prompt on this
|
|
line---but after @kbd{C-c @key{SPC}} the process mark may be in a
|
|
previous line.)
|
|
|
|
@item C-c @key{SPC}
|
|
Accumulate multiple lines of input, then send them together. This
|
|
command inserts a newline before point, but does not send the preceding
|
|
text as input to the subshell---at least, not yet. Both lines, the one
|
|
before this newline and the one after, will be sent together (along with
|
|
the newline that separates them), when you type @key{RET}.
|
|
|
|
@item C-c C-u
|
|
@kindex C-c C-u @r{(Shell mode)}
|
|
@findex comint-kill-input
|
|
Kill all text pending at end of buffer to be sent as input
|
|
(@code{comint-kill-input}). If point is not at end of buffer,
|
|
this only kills the part of this text that precedes point.
|
|
|
|
@item C-c C-w
|
|
@kindex C-c C-w @r{(Shell mode)}
|
|
Kill a word before point (@code{backward-kill-word}).
|
|
|
|
@item C-c C-c
|
|
@kindex C-c C-c @r{(Shell mode)}
|
|
@findex comint-interrupt-subjob
|
|
Interrupt the shell or its current subjob if any
|
|
(@code{comint-interrupt-subjob}). This command also kills
|
|
any shell input pending in the shell buffer and not yet sent.
|
|
|
|
@item C-c C-z
|
|
@kindex C-c C-z @r{(Shell mode)}
|
|
@findex comint-stop-subjob
|
|
Stop the shell or its current subjob if any (@code{comint-stop-subjob}).
|
|
This command also kills any shell input pending in the shell buffer and
|
|
not yet sent.
|
|
|
|
@item C-c C-\
|
|
@findex comint-quit-subjob
|
|
@kindex C-c C-\ @r{(Shell mode)}
|
|
Send quit signal to the shell or its current subjob if any
|
|
(@code{comint-quit-subjob}). This command also kills any shell input
|
|
pending in the shell buffer and not yet sent.
|
|
|
|
@item C-c C-o
|
|
@kindex C-c C-o @r{(Shell mode)}
|
|
@findex comint-delete-output
|
|
Delete the last batch of output from a shell command
|
|
(@code{comint-delete-output}). This is useful if a shell command spews
|
|
out lots of output that just gets in the way. This command used to be
|
|
called @code{comint-kill-output}.
|
|
|
|
@item C-c C-s
|
|
@kindex C-c C-s @r{(Shell mode)}
|
|
@findex comint-write-output
|
|
Write the last batch of output from a shell command to a file
|
|
(@code{comint-write-output}). With a prefix argument, the file is
|
|
appended to instead. Any prompt at the end of the output is not
|
|
written.
|
|
|
|
@item C-c C-r
|
|
@itemx C-M-l
|
|
@kindex C-c C-r @r{(Shell mode)}
|
|
@kindex C-M-l @r{(Shell mode)}
|
|
@findex comint-show-output
|
|
Scroll to display the beginning of the last batch of output at the top
|
|
of the window; also move the cursor there (@code{comint-show-output}).
|
|
|
|
@item C-c C-e
|
|
@kindex C-c C-e @r{(Shell mode)}
|
|
@findex comint-show-maximum-output
|
|
Scroll to put the end of the buffer at the bottom of the window
|
|
(@code{comint-show-maximum-output}).
|
|
|
|
@item C-c C-f
|
|
@kindex C-c C-f @r{(Shell mode)}
|
|
@findex shell-forward-command
|
|
@vindex shell-command-regexp
|
|
Move forward across one shell command, but not beyond the current line
|
|
(@code{shell-forward-command}). The variable @code{shell-command-regexp}
|
|
specifies how to recognize the end of a command.
|
|
|
|
@item C-c C-b
|
|
@kindex C-c C-b @r{(Shell mode)}
|
|
@findex shell-backward-command
|
|
Move backward across one shell command, but not beyond the current line
|
|
(@code{shell-backward-command}).
|
|
|
|
@item M-x dirs
|
|
Ask the shell what its current directory is, so that Emacs can agree
|
|
with the shell.
|
|
|
|
@item M-x send-invisible @key{RET} @var{text} @key{RET}
|
|
@findex send-invisible
|
|
Send @var{text} as input to the shell, after reading it without
|
|
echoing. This is useful when a shell command runs a program that asks
|
|
for a password.
|
|
|
|
Please note that Emacs will not echo passwords by default. If you
|
|
really want them to be echoed, evaluate the following Lisp
|
|
expression:
|
|
|
|
@example
|
|
(remove-hook 'comint-output-filter-functions
|
|
'comint-watch-for-password-prompt)
|
|
@end example
|
|
|
|
@item M-x comint-continue-subjob
|
|
@findex comint-continue-subjob
|
|
Continue the shell process. This is useful if you accidentally suspend
|
|
the shell process.@footnote{You should not suspend the shell process.
|
|
Suspending a subjob of the shell is a completely different matter---that
|
|
is normal practice, but you must use the shell to continue the subjob;
|
|
this command won't do it.}
|
|
|
|
@item M-x comint-strip-ctrl-m
|
|
@findex comint-strip-ctrl-m
|
|
Discard all control-M characters from the current group of shell output.
|
|
The most convenient way to use this command is to make it run
|
|
automatically when you get output from the subshell. To do that,
|
|
evaluate this Lisp expression:
|
|
|
|
@example
|
|
(add-hook 'comint-output-filter-functions
|
|
'comint-strip-ctrl-m)
|
|
@end example
|
|
|
|
@item M-x comint-truncate-buffer
|
|
@findex comint-truncate-buffer
|
|
This command truncates the shell buffer to a certain maximum number of
|
|
lines, specified by the variable @code{comint-buffer-maximum-size}.
|
|
Here's how to do this automatically each time you get output from the
|
|
subshell:
|
|
|
|
@example
|
|
(add-hook 'comint-output-filter-functions
|
|
'comint-truncate-buffer)
|
|
@end example
|
|
@end table
|
|
|
|
@cindex Comint mode
|
|
@cindex mode, Comint
|
|
Shell mode is a derivative of Comint mode, a general-purpose mode for
|
|
communicating with interactive subprocesses. Most of the features of
|
|
Shell mode actually come from Comint mode, as you can see from the
|
|
command names listed above. The special features of Shell mode include
|
|
the directory tracking feature, and a few user commands.
|
|
|
|
Other Emacs features that use variants of Comint mode include GUD
|
|
(@pxref{Debuggers}) and @kbd{M-x run-lisp} (@pxref{External Lisp}).
|
|
|
|
@findex comint-run
|
|
You can use @kbd{M-x comint-run} to execute any program of your choice
|
|
in a subprocess using unmodified Comint mode---without the
|
|
specializations of Shell mode.
|
|
|
|
@node Shell Prompts
|
|
@subsection Shell Prompts
|
|
|
|
@vindex shell-prompt-pattern
|
|
@vindex comint-prompt-regexp
|
|
@vindex comint-use-prompt-regexp
|
|
@cindex 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
|
|
@code{comint-use-prompt-regexp} is non-@code{nil}, then Comint mode
|
|
uses a regular expression to recognize prompts. In Shell mode,
|
|
@code{shell-prompt-pattern} specifies the regular expression.
|
|
|
|
The value of @code{comint-use-prompt-regexp} also affects many
|
|
motion and paragraph commands. If the value is non-@code{nil}, 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
|
|
@code{field} 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
|
|
@code{nil} 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
|
|
@code{comint-use-prompt-regexp}.
|
|
|
|
@node Shell History
|
|
@subsection 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
|
|
@samp{!}-style history reference.
|
|
|
|
@menu
|
|
* Ring: Shell Ring. Fetching commands from the history list.
|
|
* Copy: Shell History Copying. Moving to a command and then copying it.
|
|
* History References:: Expanding @samp{!}-style history references.
|
|
@end menu
|
|
|
|
@node Shell Ring
|
|
@subsubsection Shell History Ring
|
|
|
|
@table @kbd
|
|
@findex comint-previous-input
|
|
@kindex M-p @r{(Shell mode)}
|
|
@item M-p
|
|
@itemx C-@key{UP}
|
|
Fetch the next earlier old shell command.
|
|
|
|
@kindex M-n @r{(Shell mode)}
|
|
@findex comint-next-input
|
|
@item M-n
|
|
@itemx C-@key{DOWN}
|
|
Fetch the next later old shell command.
|
|
|
|
@kindex M-r @r{(Shell mode)}
|
|
@kindex M-s @r{(Shell mode)}
|
|
@findex comint-previous-matching-input
|
|
@findex comint-next-matching-input
|
|
@item M-r @var{regexp} @key{RET}
|
|
@itemx M-s @var{regexp} @key{RET}
|
|
Search backwards or forwards for old shell commands that match @var{regexp}.
|
|
|
|
@item C-c C-x
|
|
@kindex C-c C-x @r{(Shell mode)}
|
|
@findex comint-get-next-from-history
|
|
Fetch the next subsequent command from the history.
|
|
|
|
@item C-c .
|
|
@kindex C-c . @r{(Shell mode)}
|
|
@findex comint-input-previous-argument
|
|
Fetch one argument from an old shell command.
|
|
|
|
@item C-c C-l
|
|
@kindex C-c C-l @r{(Shell mode)}
|
|
@findex comint-dynamic-list-input-ring
|
|
Display the buffer's history of shell commands in another window
|
|
(@code{comint-dynamic-list-input-ring}).
|
|
@end table
|
|
|
|
Shell buffers provide a history of previously entered shell commands. To
|
|
reuse shell commands from the history, use the editing commands @kbd{M-p},
|
|
@kbd{M-n}, @kbd{M-r} and @kbd{M-s}. These work just like the minibuffer
|
|
history commands except that they operate on the text at the end of the
|
|
shell buffer, where you would normally insert text to send to the shell.
|
|
|
|
@kbd{M-p} fetches an earlier shell command to the end of the shell
|
|
buffer. Successive use of @kbd{M-p} fetches successively earlier
|
|
shell commands, each replacing any text that was already present as
|
|
potential shell input. @kbd{M-n} does likewise except that it finds
|
|
successively more recent shell commands from the buffer.
|
|
@kbd{C-@key{UP}} works like @kbd{M-p}, and @kbd{C-@key{DOWN}} like
|
|
@kbd{M-n}.
|
|
|
|
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
|
|
@key{RET}} over and over.
|
|
|
|
The command @kbd{C-c .}@: (@code{comint-input-previous-argument})
|
|
copies an individual argument from a previous command, like @kbd{ESC
|
|
.} in Bash. The simplest use copies the last argument from the
|
|
previous shell command. With a prefix argument @var{n}, it copies the
|
|
@var{n}th argument instead. Repeating @kbd{C-c .} copies from an
|
|
earlier shell command instead, always using the same value of @var{n}
|
|
(don't give a prefix argument when you repeat the @kbd{C-c .}
|
|
command).
|
|
|
|
These commands get the text of previous shell commands from a special
|
|
history list, not from the shell buffer itself. Thus, editing the shell
|
|
buffer, or even killing large parts of it, does not affect the history
|
|
that these commands access.
|
|
|
|
@vindex shell-input-ring-file-name
|
|
Some shells store their command histories in files so that you can
|
|
refer to commands from previous shell sessions. Emacs reads
|
|
the command history file for your chosen shell, to initialize its own
|
|
command history. The file name is @file{~/.bash_history} for bash,
|
|
@file{~/.sh_history} for ksh, and @file{~/.history} for other shells.
|
|
|
|
@node Shell History Copying
|
|
@subsubsection Shell History Copying
|
|
|
|
@table @kbd
|
|
@kindex C-c C-p @r{(Shell mode)}
|
|
@findex comint-previous-prompt
|
|
@item C-c C-p
|
|
Move point to the previous prompt (@code{comint-previous-prompt}).
|
|
|
|
@kindex C-c C-n @r{(Shell mode)}
|
|
@findex comint-next-prompt
|
|
@item C-c C-n
|
|
Move point to the following prompt (@code{comint-next-prompt}).
|
|
|
|
@kindex C-c RET @r{(Shell mode)}
|
|
@findex comint-copy-old-input
|
|
@item C-c @key{RET}
|
|
Copy the input command at point, 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.
|
|
|
|
@item 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
|
|
@code{comint-use-prompt-regexp} is non-@code{nil}, or if the click is
|
|
not over old input, just yank as usual.
|
|
@end table
|
|
|
|
Moving to a previous input and then copying it with @kbd{C-c
|
|
@key{RET}} or @kbd{Mouse-2} produces the same results---the same
|
|
buffer contents---that you would get by using @kbd{M-p} enough times
|
|
to fetch that previous input from the history list. However, @kbd{C-c
|
|
@key{RET}} copies the text from the buffer, which can be different
|
|
from what is in the history list if you edit the input text in the
|
|
buffer after it has been sent.
|
|
|
|
@node History References
|
|
@subsubsection Shell History References
|
|
@cindex history reference
|
|
|
|
Various shells including csh and bash support @dfn{history
|
|
references} that begin with @samp{!} and @samp{^}. Shell mode
|
|
recognizes these constructs, and can perform the history substitution
|
|
for you.
|
|
|
|
If you insert a history reference and type @key{TAB}, this searches
|
|
the input history for a matching command, performs substitution if
|
|
necessary, and places the result in the buffer in place of the history
|
|
reference. For example, you can fetch the most recent command
|
|
beginning with @samp{mv} with @kbd{! m v @key{TAB}}. You can edit the
|
|
command if you wish, and then resubmit the command to the shell by
|
|
typing @key{RET}.
|
|
|
|
@vindex comint-input-autoexpand
|
|
@findex comint-magic-space
|
|
Shell mode can optionally expand history references in the buffer
|
|
when you send them to the shell. To request this, set the variable
|
|
@code{comint-input-autoexpand} to @code{input}. You can make
|
|
@key{SPC} perform history expansion by binding @key{SPC} to the
|
|
command @code{comint-magic-space}.
|
|
|
|
Shell mode recognizes history references when they follow a prompt.
|
|
@xref{Shell Prompts}, for how Shell mode recognizes prompts.
|
|
|
|
@node Directory Tracking
|
|
@subsection Directory Tracking
|
|
@cindex directory tracking
|
|
|
|
@vindex shell-pushd-regexp
|
|
@vindex shell-popd-regexp
|
|
@vindex shell-cd-regexp
|
|
Shell mode keeps track of @samp{cd}, @samp{pushd} and @samp{popd}
|
|
commands given to the inferior shell, so it can keep the
|
|
@samp{*shell*} buffer's default directory the same as the shell's
|
|
working directory. It recognizes these commands syntactically, by
|
|
examining lines of input that are sent.
|
|
|
|
If you use aliases for these commands, you can tell Emacs to
|
|
recognize them also. For example, if the value of the variable
|
|
@code{shell-pushd-regexp} matches the beginning of a shell command
|
|
line, that line is regarded as a @code{pushd} command. Change this
|
|
variable when you add aliases for @samp{pushd}. Likewise,
|
|
@code{shell-popd-regexp} and @code{shell-cd-regexp} are used to
|
|
recognize commands with the meaning of @samp{popd} and @samp{cd}.
|
|
These commands are recognized only at the beginning of a shell command
|
|
line.
|
|
|
|
@ignore @c This seems to have been deleted long ago.
|
|
@vindex shell-set-directory-error-hook
|
|
If Emacs gets an error while trying to handle what it believes is a
|
|
@samp{cd}, @samp{pushd} or @samp{popd} command, it runs the hook
|
|
@code{shell-set-directory-error-hook} (@pxref{Hooks}).
|
|
@end ignore
|
|
|
|
@findex dirs
|
|
If Emacs gets confused about changes in the current directory of the
|
|
subshell, use the command @kbd{M-x dirs} to ask the shell what its
|
|
current directory is. This command works for shells that support the
|
|
most common command syntax; it may not work for unusual shells.
|
|
|
|
@findex dirtrack-mode
|
|
You can also use @kbd{M-x dirtrack-mode} to enable (or disable) an
|
|
alternative method of tracking changes in the current directory. This
|
|
method relies on your shell prompt containing the full current working
|
|
directory at all times.
|
|
|
|
@node Shell Options
|
|
@subsection Shell Mode Options
|
|
|
|
@vindex comint-scroll-to-bottom-on-input
|
|
If the variable @code{comint-scroll-to-bottom-on-input} is
|
|
non-@code{nil}, insertion and yank commands scroll the selected window
|
|
to the bottom before inserting. The default is @code{nil}.
|
|
|
|
@vindex comint-scroll-show-maximum-output
|
|
If @code{comint-scroll-show-maximum-output} is non-@code{nil}, 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}.
|
|
|
|
@vindex comint-move-point-for-output
|
|
By setting @code{comint-move-point-for-output}, you can opt for
|
|
having point jump to the end of the buffer whenever output arrives---no
|
|
matter where in the buffer point was before. If the value is
|
|
@code{this}, point jumps in the selected window. If the value is
|
|
@code{all}, point jumps in each window that shows the Comint buffer. If
|
|
the value is @code{other}, point jumps in all nonselected windows that
|
|
show the current buffer. The default value is @code{nil}, which means
|
|
point does not jump to the end.
|
|
|
|
@vindex comint-prompt-read-only
|
|
If you set @code{comint-prompt-read-only}, the prompts in the Comint
|
|
buffer are read-only.
|
|
|
|
@vindex comint-input-ignoredups
|
|
The variable @code{comint-input-ignoredups} controls whether successive
|
|
identical inputs are stored in the input history. A non-@code{nil}
|
|
value means to omit an input that is the same as the previous input.
|
|
The default is @code{nil}, which means to store each input even if it is
|
|
equal to the previous input.
|
|
|
|
@vindex comint-completion-addsuffix
|
|
@vindex comint-completion-recexact
|
|
@vindex comint-completion-autolist
|
|
Three variables customize file name completion. The variable
|
|
@code{comint-completion-addsuffix} controls whether completion inserts a
|
|
space or a slash to indicate a fully completed file or directory name
|
|
(non-@code{nil} means do insert a space or slash).
|
|
@code{comint-completion-recexact}, if non-@code{nil}, directs @key{TAB}
|
|
to choose the shortest possible completion if the usual Emacs completion
|
|
algorithm cannot add even a single character.
|
|
@code{comint-completion-autolist}, if non-@code{nil}, says to list all
|
|
the possible completions whenever completion is not exact.
|
|
|
|
@vindex shell-completion-execonly
|
|
Command completion normally considers only executable files.
|
|
If you set @code{shell-completion-execonly} to @code{nil},
|
|
it considers nonexecutable files as well.
|
|
|
|
@findex shell-pushd-tohome
|
|
@findex shell-pushd-dextract
|
|
@findex shell-pushd-dunique
|
|
You can configure the behavior of @samp{pushd}. Variables control
|
|
whether @samp{pushd} behaves like @samp{cd} if no argument is given
|
|
(@code{shell-pushd-tohome}), pop rather than rotate with a numeric
|
|
argument (@code{shell-pushd-dextract}), and only add directories to the
|
|
directory stack if they are not already on it
|
|
(@code{shell-pushd-dunique}). The values you choose should match the
|
|
underlying shell, of course.
|
|
|
|
@node Terminal emulator
|
|
@subsection Emacs Terminal Emulator
|
|
@findex term
|
|
|
|
To run a subshell in a terminal emulator, 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.
|
|
|
|
You can use Term mode to communicate with a device connected to a
|
|
serial port of your computer. @xref{Serial Terminal}.
|
|
|
|
The file name used to load the subshell is determined the same way
|
|
as for Shell mode. To make multiple terminal emulators, rename the
|
|
buffer @samp{*terminal*} to something different using @kbd{M-x
|
|
rename-uniquely}, just as with Shell mode.
|
|
|
|
Unlike Shell mode, Term mode does not track the current directory by
|
|
examining your input. But some shells can tell Term what the current
|
|
directory is. This is done automatically by @code{bash} version 1.15
|
|
and later.
|
|
|
|
@node Term Mode
|
|
@subsection Term Mode
|
|
@cindex Term mode
|
|
@cindex mode, Term
|
|
|
|
The terminal emulator uses Term mode, which has two input modes. In
|
|
line mode, Term basically acts like Shell mode; see @ref{Shell Mode}.
|
|
In char mode, each character is sent directly to the inferior
|
|
subshell, except for the Term escape character, normally @kbd{C-c}.
|
|
|
|
To switch between line and char mode, use these commands:
|
|
|
|
@table @kbd
|
|
@kindex C-c C-j @r{(Term mode)}
|
|
@findex term-char-mode
|
|
@item C-c C-j
|
|
Switch to line mode. Do nothing if already in line mode.
|
|
|
|
@kindex C-c C-k @r{(Term mode)}
|
|
@findex term-line-mode
|
|
@item C-c C-k
|
|
Switch to char mode. Do nothing if already in char mode.
|
|
@end table
|
|
|
|
The following commands are only available in char mode:
|
|
|
|
@table @kbd
|
|
@item C-c C-c
|
|
Send a literal @key{C-c} to the sub-shell.
|
|
|
|
@item C-c @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}.
|
|
@end table
|
|
|
|
@node Paging in Term
|
|
@subsection Page-At-A-Time Output
|
|
@cindex page-at-a-time
|
|
|
|
Term mode has a page-at-a-time feature. When enabled it makes
|
|
output pause at the end of each screenful.
|
|
|
|
@table @kbd
|
|
@kindex C-c C-q @r{(Term mode)}
|
|
@findex term-pager-toggle
|
|
@item C-c C-q
|
|
Toggle the page-at-a-time feature. This command works in both line
|
|
and char modes. When page-at-a-time is enabled, the mode-line
|
|
displays the word @samp{page}.
|
|
@end table
|
|
|
|
With page-at-a-time enabled, whenever Term receives more than a
|
|
screenful of output since your last input, it pauses, displaying
|
|
@samp{**MORE**} in the mode-line. Type @key{SPC} to display the next
|
|
screenful of output. Type @kbd{?} to see your other options. The
|
|
interface is similar to the @code{more} program.
|
|
|
|
@node Remote Host
|
|
@subsection Remote Host Shell
|
|
@cindex remote host
|
|
@cindex connecting to remote host
|
|
@cindex Telnet
|
|
@cindex Rlogin
|
|
|
|
You can login to a remote computer, using whatever commands you
|
|
would from a regular terminal (e.g.@: using the @code{telnet} or
|
|
@code{rlogin} commands), from a Term window.
|
|
|
|
A program that asks you for a password will normally suppress
|
|
echoing of the password, so the password will not show up in the
|
|
buffer. This will happen just as if you were using a real terminal,
|
|
if the buffer is in char mode. If it is in line mode, the password is
|
|
temporarily visible, but will be erased when you hit return. (This
|
|
happens automatically; there is no special password processing.)
|
|
|
|
When you log in to a different machine, you need to specify the type
|
|
of terminal you're using, 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.
|
|
|
|
@c If you are talking to a Bourne-compatible
|
|
@c shell, and your system understands the @env{TERMCAP} variable,
|
|
@c you can use the command @kbd{M-x shell-send-termcap}, which
|
|
@c sends a string specifying the terminal type and size.
|
|
@c (This command is also useful after the window has changed size.)
|
|
|
|
@c You can of course run @samp{gdb} on that remote computer. One useful
|
|
@c trick: If you invoke gdb with the @code{--fullname} option,
|
|
@c it will send special commands to Emacs that will cause Emacs to
|
|
@c pop up the source files you're debugging. This will work
|
|
@c whether or not gdb is running on a different computer than Emacs,
|
|
@c as long as Emacs can access the source files specified by gdb.
|
|
|
|
@ignore
|
|
You cannot log in to a remote computer using the Shell mode.
|
|
@c (This will change when Shell is re-written to use Term.)
|
|
Instead, Emacs provides two commands for logging in to another computer
|
|
and communicating with it through an Emacs buffer using Comint mode:
|
|
|
|
@table @kbd
|
|
@item M-x telnet @key{RET} @var{hostname} @key{RET}
|
|
Set up a Telnet connection to the computer named @var{hostname}.
|
|
@item M-x rlogin @key{RET} @var{hostname} @key{RET}
|
|
Set up an Rlogin connection to the computer named @var{hostname}.
|
|
@end table
|
|
|
|
@findex telnet
|
|
Use @kbd{M-x telnet} to set up a Telnet connection to another
|
|
computer. (Telnet is the standard Internet protocol for remote login.)
|
|
It reads the host name of the other computer as an argument with the
|
|
minibuffer. Once the connection is established, talking to the other
|
|
computer works like talking to a subshell: you can edit input with the
|
|
usual Emacs commands, and send it a line at a time by typing @key{RET}.
|
|
The output is inserted in the Telnet buffer interspersed with the input.
|
|
|
|
@findex rlogin
|
|
@vindex rlogin-explicit-args
|
|
Use @kbd{M-x rlogin} to set up an Rlogin connection. Rlogin is
|
|
another remote login communication protocol, essentially much like the
|
|
Telnet protocol but incompatible with it, and supported only by certain
|
|
systems. Rlogin's advantages are that you can arrange not to have to
|
|
give your user name and password when communicating between two machines
|
|
you frequently use, and that you can make an 8-bit-clean connection.
|
|
(To do that in Emacs, set @code{rlogin-explicit-args} to @code{("-8")}
|
|
before you run Rlogin.)
|
|
|
|
@kbd{M-x rlogin} sets up the default file directory of the Emacs
|
|
buffer to access the remote host via FTP (@pxref{File Names}), and it
|
|
tracks the shell commands that change the current directory, just like
|
|
Shell mode.
|
|
|
|
@findex rlogin-directory-tracking-mode
|
|
There are two ways of doing directory tracking in an Rlogin
|
|
buffer---either with remote directory names
|
|
@file{/@var{host}:@var{dir}/} or with local names (that works if the
|
|
``remote'' machine shares file systems with your machine of origin).
|
|
You can use the command @code{rlogin-directory-tracking-mode} to switch
|
|
modes. No argument means use remote directory names, a positive
|
|
argument means use local names, and a negative argument means turn
|
|
off directory tracking.
|
|
|
|
@end ignore
|
|
|
|
@node Serial Terminal
|
|
@subsection Serial Terminal
|
|
@cindex terminal, serial
|
|
@findex serial-term
|
|
|
|
If you have a device connected to a serial port of your computer,
|
|
you can use Emacs to communicate with it. @kbd{M-x serial-term} will
|
|
ask you for a serial port name and speed and will then open a new
|
|
window in @ref{Term Mode}.
|
|
|
|
The speed of the serial port is measured in bits per second. The
|
|
most common speed is 9600 bits per second. You can change the speed
|
|
interactively by clicking on the mode line.
|
|
|
|
A serial port can be configured even more by clicking on ``8N1'' in
|
|
the mode line. By default, a serial port is configured as ``8N1'',
|
|
which means that each byte consists of 8 data bits, No parity check
|
|
bit, and 1 stopbit.
|
|
|
|
When you have opened the serial port connection, you will see output
|
|
from the device in the window. Also, what you type in the window is
|
|
sent to the device.
|
|
|
|
If the speed or the configuration is wrong, you cannot communicate
|
|
with your device and will probably only see garbage output in the
|
|
window.
|
|
|
|
@node Emacs Server, Printing, Shell, Top
|
|
@section Using Emacs as a Server
|
|
@pindex emacsclient
|
|
@cindex Emacs as a server
|
|
@cindex server, using Emacs as
|
|
@cindex @env{EDITOR} environment variable
|
|
|
|
Various programs such as @command{mail} can invoke your choice of
|
|
editor to edit a particular piece of text, such as a message that you
|
|
are sending. By convention, most of these programs use the
|
|
environment variable @env{EDITOR} to specify which editor to run. If
|
|
you set @env{EDITOR} to @samp{emacs}, they invoke Emacs---but in an
|
|
inconvenient way, by starting a new Emacs process. This is
|
|
inconvenient because the new Emacs process doesn't share buffers, a
|
|
command history, or other kinds of information with any existing Emacs
|
|
process.
|
|
|
|
You can solve this problem by setting up Emacs as an @dfn{edit
|
|
server}, so that it ``listens'' for external edit requests and acts
|
|
accordingly. There are two ways to start an Emacs server:
|
|
|
|
@findex server-start
|
|
The first is to run the command @code{server-start} in an existing
|
|
Emacs process: either type @kbd{M-x server-start}, or put the
|
|
expression @code{(server-start)} in your initialization file
|
|
(@pxref{Init File}). The existing Emacs process is the server; when
|
|
you exit Emacs, the server dies with the Emacs process.
|
|
|
|
@cindex daemon, Emacs
|
|
The second way to start an Emacs server is to run Emacs as a
|
|
@dfn{daemon}, using the @samp{--daemon} command-line option.
|
|
@xref{Initial Options}. When Emacs is started this way, it calls
|
|
@code{server-start} after initialization, and returns control to the
|
|
calling terminal instead of opening an initial frame; it then waits in
|
|
the background, listening for edit requests.
|
|
|
|
@cindex @env{TEXEDIT} environment variable
|
|
Once an Emacs server is set up, you can use a shell command called
|
|
@command{emacsclient} to connect to the existing Emacs process and
|
|
tell it to visit a file. If you set the @env{EDITOR} environment
|
|
variable to @samp{emacsclient}, programs such as @command{mail} will
|
|
use the existing Emacs process for editing.@footnote{Some programs use
|
|
a different environment variable; for example, to make @TeX{} use
|
|
@samp{emacsclient}, set the @env{TEXEDIT} environment variable to
|
|
@samp{emacsclient +%d %s}.}
|
|
|
|
@vindex server-name
|
|
You can run multiple Emacs servers on the same machine by giving
|
|
each one a unique ``server name'', using the variable
|
|
@code{server-name}. For example, @kbd{M-x set-variable @key{RET}
|
|
server-name @key{RET} foo @key{RET}} sets the server name to
|
|
@samp{foo}. The @code{emacsclient} program can specify a server by
|
|
name, using the @samp{-s} option (@pxref{emacsclient Options}).
|
|
|
|
@menu
|
|
* Invoking emacsclient:: Connecting to the Emacs server.
|
|
* emacsclient Options:: Emacs client startup options.
|
|
@end menu
|
|
|
|
@node Invoking emacsclient
|
|
@subsection Invoking @code{emacsclient}
|
|
@cindex @code{emacsclient} invocation
|
|
|
|
The simplest way to use the @command{emacsclient} program is to run
|
|
the shell command @samp{emacsclient @var{file}}, where @var{file} is a
|
|
file name. This connects to an Emacs server, and tells that Emacs
|
|
process to visit @var{file} in one of its existing frames---either a
|
|
graphical frame, or one in a text-only terminal (@pxref{Frames}). You
|
|
can then select that frame to begin editing.
|
|
|
|
If there is no Emacs server, the @command{emacsclient} program halts
|
|
with an error message. If the Emacs process has no existing
|
|
frame---which can happen if it was started as a daemon (@pxref{Emacs
|
|
Server})---then Emacs opens a frame on the terminal in which you
|
|
called @command{emacsclient}.
|
|
|
|
You can also force @command{emacsclient} to open a new frame on a
|
|
graphical display, or on a text-only terminal, using the @samp{-c} and
|
|
@samp{-t} options. @xref{emacsclient Options}.
|
|
|
|
If you are running on a single text-only terminal, you can switch
|
|
between @command{emacsclient}'s shell and the Emacs server using one
|
|
of two methods: (i) run the Emacs server and @command{emacsclient} on
|
|
different virtual terminals, and switch to the Emacs server's virtual
|
|
terminal after calling @command{emacsclient}; or (ii) call
|
|
@command{emacsclient} from within the Emacs server itself, using Shell
|
|
mode (@pxref{Interactive Shell}) or Term mode (@pxref{Term Mode});
|
|
@code{emacsclient} blocks only the subshell under Emacs, and you can
|
|
still use Emacs to edit the file.
|
|
|
|
@kindex C-x #
|
|
@findex server-edit
|
|
When you finish editing @var{file} in the Emacs server, type
|
|
@kbd{C-x #} (@code{server-edit}) in its buffer. This saves the file
|
|
and sends a message back to the @command{emacsclient} program, telling
|
|
it to exit. Programs that use @env{EDITOR} usually wait for the
|
|
``editor''---in the case @command{emacsclient}---to exit before doing
|
|
something else.
|
|
|
|
You can also call @command{emacsclient} with multiple file name
|
|
arguments: @samp{emacsclient @var{file1} @var{file2} ...} tells the
|
|
Emacs server to visit @var{file1}, @var{file2}, and so forth. Emacs
|
|
selects the buffer visiting @var{file1}, and buries the other buffers
|
|
at the bottom of the buffer list (@pxref{Buffers}). The
|
|
@command{emacsclient} program exits once all the specified files are
|
|
finished (i.e., once you have typed @kbd{C-x #} in each server
|
|
buffer).
|
|
|
|
@vindex server-kill-new-buffers
|
|
@vindex server-temp-file-regexp
|
|
Finishing with a server buffer also kills the buffer, unless it
|
|
already existed in the Emacs session before the server was asked to
|
|
create it. However, if you set @code{server-kill-new-buffers} to
|
|
@code{nil}, then a different criterion is used: finishing with a
|
|
server buffer kills it if the file name matches the regular expression
|
|
@code{server-temp-file-regexp}. This is set up to distinguish certain
|
|
``temporary'' files.
|
|
|
|
Each @kbd{C-x #} 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 tell
|
|
@command{emacsclient} that you are finished.
|
|
|
|
@vindex server-window
|
|
If you set the value of the variable @code{server-window} to a
|
|
window or a frame, @kbd{C-x #} always displays the next server buffer
|
|
in that window or in that frame.
|
|
|
|
@node emacsclient Options
|
|
@subsection @code{emacsclient} Options
|
|
@cindex @code{emacsclient} options
|
|
|
|
You can pass some optional arguments to the @command{emacsclient}
|
|
program, such as:
|
|
|
|
@example
|
|
emacsclient -c +12 @var{file1} +4:3 @var{file2}
|
|
@end example
|
|
|
|
@noindent
|
|
The @samp{+@var{line}} or @samp{+@var{line}:@var{column}} arguments
|
|
specify line numbers, or line and column numbers, for the next file
|
|
argument. These behave like the command line arguments for Emacs
|
|
itself. @xref{Action Arguments}.
|
|
|
|
The other optional arguments recognized by @command{emacsclient} are
|
|
listed below:
|
|
|
|
@table @samp
|
|
@item -a @var{command}
|
|
@itemx --alternate-editor=@var{command}
|
|
Specify a command to run if @code{emacsclient} 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:
|
|
|
|
@example
|
|
EDITOR="emacsclient --alternate-editor emacs +%d %s"
|
|
@end example
|
|
|
|
@noindent
|
|
As a special exception, if @var{command} is the empty string, then
|
|
@code{emacsclient} starts Emacs in daemon mode and then tries
|
|
connecting again.
|
|
|
|
@cindex @env{ALTERNATE_EDITOR} environment variable
|
|
The environment variable @env{ALTERNATE_EDITOR} has the same effect as
|
|
the @samp{-a} option. If both are present, the latter takes
|
|
precedence.
|
|
|
|
@item -c
|
|
Create a new graphical frame, instead of using an existing Emacs
|
|
frame. Emacs 23 can create a graphical frame even if it was started
|
|
in a text-only terminal, provided it is able to connect to a graphical
|
|
display. If no graphical display is available, Emacs creates a new
|
|
text-only terminal frame (@pxref{Frames}). If you omit a filename
|
|
argument while supplying the @samp{-c} option, the new frame displays
|
|
the @samp{*scratch*} buffer (@pxref{Buffers}).
|
|
|
|
@item -d @var{display}
|
|
@itemx --display=@var{display}
|
|
Tell Emacs to open the given files on the X display @var{display}
|
|
(assuming there is more than one X display available).
|
|
|
|
@item -e
|
|
@itemx --eval
|
|
Tell Emacs to evaluate some Emacs Lisp code, instead of visiting some
|
|
files. When this option is given, the arguments to
|
|
@command{emacsclient} are interpreted as a list of expressions to
|
|
evaluate, @emph{not} as a list of files to visit.
|
|
|
|
@item -f @var{server-file}
|
|
@itemx --server-file=@var{server-file}
|
|
@cindex @env{EMACS_SERVER_FILE} environment variable
|
|
@cindex server file
|
|
@vindex server-use-tcp
|
|
@vindex server-host
|
|
Specify a @dfn{server file} for connecting to an Emacs server via TCP.
|
|
|
|
An Emacs server usually uses an operating system feature called a
|
|
``local socket'' to listen for connections. Some operating systems,
|
|
such as Microsoft Windows, do not support local sockets; in that case,
|
|
Emacs uses TCP instead. When you start the Emacs server, Emacs
|
|
creates a server file containing some TCP information that
|
|
@command{emacsclient} needs for making the connection. By default,
|
|
the server file is in @file{~/.emacs.d/server/}. On Microsoft
|
|
Windows, if @command{emacsclient} does not find the server file there,
|
|
it looks in the @file{.emacs.d/server/} subdirectory of the directory
|
|
pointed to by the @env{APPDATA} environment variable. You can tell
|
|
@command{emacsclient} to use a specific server file with the @samp{-f}
|
|
or @samp{--server-file} option, or by setting the
|
|
@env{EMACS_SERVER_FILE} environment variable.
|
|
|
|
Even if local sockets are available, you can tell Emacs to use TCP by
|
|
setting the variable @code{server-use-tcp} to @code{t}. One advantage
|
|
of TCP is that the server can accept connections from remote machines.
|
|
For this to work, you must (i) set the variable @code{server-host} to
|
|
the hostname or IP address of the machine on which the Emacs server
|
|
runs, and (ii) provide @command{emacsclient} with the server file.
|
|
(One convenient way to do the latter is to put the server file on a
|
|
networked file system such as NFS.)
|
|
|
|
@item -n
|
|
@itemx --no-wait
|
|
Let @command{emacsclient} exit immediately, instead of waiting until
|
|
all server buffers are finished. You can take as long as you like to
|
|
edit the server buffers within Emacs, and they are @emph{not} killed
|
|
when you type @kbd{C-x #} in them.
|
|
|
|
@item -s @var{server-name}
|
|
@itemx --socket-name=@var{server-name}
|
|
Connect to the Emacs server named @var{server-name}. The server name
|
|
is given by the variable @code{server-name} on the Emacs server. If
|
|
this option is omitted, @command{emacsclient} connects to the first
|
|
server it finds. (This option is not supported on MS-Windows.)
|
|
|
|
@item -t
|
|
@itemx --tty
|
|
@itemx -nw
|
|
Create a new Emacs frame on the current text-only terminal, instead of
|
|
using an existing Emacs frame. Emacs 23 can open a text-only terminal
|
|
even if it was started in another text-only terminal, or on a
|
|
graphical display. If you omit a filename argument while supplying
|
|
this option, the new frame displays the @samp{*scratch*} buffer.
|
|
@xref{Buffers}.
|
|
@end table
|
|
|
|
If you type @kbd{C-x C-c} (@code{save-buffers-kill-terminal}) in an
|
|
Emacs frame created with @command{emacsclient}, via the @samp{-c} or
|
|
@samp{-t} options, Emacs deletes the frame instead of killing the
|
|
Emacs process itself. On a text-only terminal frame created with the
|
|
@samp{-t} option, this returns control to the terminal. Emacs also
|
|
marks all the server buffers for the client as finished, as though you
|
|
had typed @kbd{C-x #} in all of them.
|
|
|
|
When Emacs is started as a daemon, all frames are considered client
|
|
frames, so @kbd{C-x C-c} will never kill Emacs. To kill the Emacs
|
|
process, type @kbd{M-x kill-emacs}.
|
|
|
|
@node Printing, Sorting, Emacs Server, Top
|
|
@section Printing Hard Copies
|
|
@cindex hardcopy
|
|
@cindex 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}).
|
|
|
|
@table @kbd
|
|
@item M-x print-buffer
|
|
Print hardcopy of current buffer with page headings containing the file
|
|
name and page number.
|
|
@item M-x lpr-buffer
|
|
Print hardcopy of current buffer without page headings.
|
|
@item M-x print-region
|
|
Like @code{print-buffer} but print only the current region.
|
|
@item M-x lpr-region
|
|
Like @code{lpr-buffer} but print only the current region.
|
|
@end table
|
|
|
|
@findex print-buffer
|
|
@findex print-region
|
|
@findex lpr-buffer
|
|
@findex lpr-region
|
|
@vindex lpr-switches
|
|
The hardcopy commands (aside from the PostScript commands) pass extra
|
|
switches to the @code{lpr} program based on the value of the variable
|
|
@code{lpr-switches}. Its value should be a list of strings, each string
|
|
an option starting with @samp{-}. For example, to specify a line width
|
|
of 80 columns for all the printing you do in Emacs, set
|
|
@code{lpr-switches} like this:
|
|
|
|
@example
|
|
(setq lpr-switches '("-w80"))
|
|
@end example
|
|
|
|
@vindex printer-name
|
|
You can specify the printer to use by setting the variable
|
|
@code{printer-name}.
|
|
|
|
@vindex lpr-headers-switches
|
|
@vindex lpr-commands
|
|
@vindex lpr-add-switches
|
|
The variable @code{lpr-command} specifies the name of the printer
|
|
program to run; the default value depends on your operating system type.
|
|
On most systems, the default is @code{"lpr"}. The variable
|
|
@code{lpr-headers-switches} similarly specifies the extra switches to
|
|
use to make page headers. The variable @code{lpr-add-switches} controls
|
|
whether to supply @samp{-T} and @samp{-J} options (suitable for
|
|
@code{lpr}) to the printer program: @code{nil} means don't add them.
|
|
@code{lpr-add-switches} should be @code{nil} if your printer program is
|
|
not compatible with @code{lpr}.
|
|
|
|
@menu
|
|
* PostScript:: Printing buffers or regions as PostScript.
|
|
* PostScript Variables:: Customizing the PostScript printing commands.
|
|
* Printing Package:: An optional advanced printing interface.
|
|
@end menu
|
|
|
|
@node PostScript, PostScript Variables,, Printing
|
|
@section PostScript Hardcopy
|
|
|
|
These commands convert buffer contents to PostScript,
|
|
either printing it or leaving it in another Emacs buffer.
|
|
|
|
@table @kbd
|
|
@item M-x ps-print-buffer
|
|
Print hardcopy of the current buffer in PostScript form.
|
|
@item M-x ps-print-region
|
|
Print hardcopy of the current region in PostScript form.
|
|
@item M-x ps-print-buffer-with-faces
|
|
Print hardcopy of the current buffer in PostScript form, showing the
|
|
faces used in the text by means of PostScript features.
|
|
@item M-x ps-print-region-with-faces
|
|
Print hardcopy of the current region in PostScript form, showing the
|
|
faces used in the text.
|
|
@item M-x ps-spool-buffer
|
|
Generate and spool a PostScript image for the current buffer text.
|
|
@item M-x ps-spool-region
|
|
Generate and spool a PostScript image for the current region.
|
|
@item M-x ps-spool-buffer-with-faces
|
|
Generate and spool a PostScript image for the current buffer, showing the faces used.
|
|
@item M-x ps-spool-region-with-faces
|
|
Generate and spool a PostScript image for the current region, showing the faces used.
|
|
@item M-x ps-despool
|
|
Send the spooled PostScript to the printer.
|
|
@item M-x handwrite
|
|
Generate/print PostScript for the current buffer as if handwritten.
|
|
@end table
|
|
|
|
@findex ps-print-region
|
|
@findex ps-print-buffer
|
|
@findex ps-print-region-with-faces
|
|
@findex ps-print-buffer-with-faces
|
|
The PostScript commands, @code{ps-print-buffer} and
|
|
@code{ps-print-region}, print buffer contents in PostScript form. One
|
|
command prints the entire buffer; the other, just the region. The
|
|
corresponding @samp{-with-faces} commands,
|
|
@code{ps-print-buffer-with-faces} and @code{ps-print-region-with-faces},
|
|
use PostScript features to show the faces (fonts and colors) in the text
|
|
properties of the text being printed. The @samp{-with-faces} commands only
|
|
work if they are used in a window system, so it has a way to determine color
|
|
values.
|
|
|
|
Interactively, when you use a prefix argument (@kbd{C-u}), the command
|
|
prompts the user for a file name, and saves the PostScript image in that file
|
|
instead of sending it to the printer.
|
|
|
|
Noninteractively, the argument @var{filename} is treated as follows: if it is
|
|
@code{nil}, send the image to the printer. If @var{filename} is a string, save
|
|
the PostScript image in a file with that name.
|
|
|
|
If you are using a color display, you can print a buffer of program
|
|
code with color highlighting by turning on Font-Lock mode in that
|
|
buffer, and using @code{ps-print-buffer-with-faces}.
|
|
|
|
@findex ps-spool-region
|
|
@findex ps-spool-buffer
|
|
@findex ps-spool-region-with-faces
|
|
@findex ps-spool-buffer-with-faces
|
|
The commands whose names have @samp{spool} instead of @samp{print},
|
|
generate the PostScript output in an Emacs buffer instead of sending
|
|
it to the printer.
|
|
|
|
Use the command @code{ps-despool} to send the spooled images to the printer.
|
|
|
|
@findex ps-despool
|
|
This command sends the PostScript generated by @samp{-spool-} commands (see
|
|
commands above) to the printer.
|
|
|
|
Interactively, when you use a prefix argument (@kbd{C-u}), the command
|
|
prompts the user for a file name, and saves the spooled PostScript image in
|
|
that file instead of sending it to the printer.
|
|
|
|
Noninteractively, the argument @var{filename} is treated as follows: if it is
|
|
@code{nil}, send the image to the printer. If @var{filename} is a string, save
|
|
the PostScript image in a file with that name.
|
|
|
|
@findex handwrite
|
|
@cindex handwriting
|
|
@kbd{M-x handwrite} is more frivolous. It generates a PostScript
|
|
rendition of the current buffer as a cursive handwritten document. It
|
|
can be customized in group @code{handwrite}. This function only
|
|
supports ISO 8859-1 characters.
|
|
|
|
@ifnottex
|
|
The following section describes variables for customizing these commands.
|
|
@end ifnottex
|
|
|
|
@node PostScript Variables, Printing Package, PostScript, Printing
|
|
@section Variables for PostScript Hardcopy
|
|
|
|
@vindex ps-lpr-command
|
|
@vindex ps-lpr-switches
|
|
@vindex ps-printer-name
|
|
All the PostScript hardcopy commands use the variables
|
|
@code{ps-lpr-command} and @code{ps-lpr-switches} to specify how to print
|
|
the output. @code{ps-lpr-command} specifies the command name to run,
|
|
@code{ps-lpr-switches} specifies command line options to use, and
|
|
@code{ps-printer-name} specifies the printer. If you don't set the
|
|
first two variables yourself, they take their initial values from
|
|
@code{lpr-command} and @code{lpr-switches}. If @code{ps-printer-name}
|
|
is @code{nil}, @code{printer-name} is used.
|
|
|
|
@vindex ps-print-header
|
|
The variable @code{ps-print-header} controls whether these commands
|
|
add header lines to each page---set it to @code{nil} to turn headers
|
|
off.
|
|
|
|
@cindex color emulation on black-and-white printers
|
|
@vindex ps-print-color-p
|
|
If your printer doesn't support colors, you should turn off color
|
|
processing by setting @code{ps-print-color-p} to @code{nil}. By
|
|
default, if the display supports colors, Emacs produces hardcopy output
|
|
with color information; on black-and-white printers, colors are emulated
|
|
with shades of gray. This might produce illegible output, even if your
|
|
screen colors only use shades of gray.
|
|
|
|
Alternatively, you can set @code{ps-print-color-p} to @code{black-white} to
|
|
print colors on black/white printers.
|
|
|
|
@vindex ps-use-face-background
|
|
By default, PostScript printing ignores the background colors of the
|
|
faces, unless the variable @code{ps-use-face-background} is
|
|
non-@code{nil}. This is to avoid unwanted interference with the zebra
|
|
stripes and background image/text.
|
|
|
|
@vindex ps-paper-type
|
|
@vindex ps-page-dimensions-database
|
|
The variable @code{ps-paper-type} specifies which size of paper to
|
|
format for; legitimate values include @code{a4}, @code{a3},
|
|
@code{a4small}, @code{b4}, @code{b5}, @code{executive}, @code{ledger},
|
|
@code{legal}, @code{letter}, @code{letter-small}, @code{statement},
|
|
@code{tabloid}. The default is @code{letter}. You can define
|
|
additional paper sizes by changing the variable
|
|
@code{ps-page-dimensions-database}.
|
|
|
|
@vindex ps-landscape-mode
|
|
The variable @code{ps-landscape-mode} specifies the orientation of
|
|
printing on the page. The default is @code{nil}, which stands for
|
|
``portrait'' mode. Any non-@code{nil} value specifies ``landscape''
|
|
mode.
|
|
|
|
@vindex ps-number-of-columns
|
|
The variable @code{ps-number-of-columns} specifies the number of
|
|
columns; it takes effect in both landscape and portrait mode. The
|
|
default is 1.
|
|
|
|
@vindex ps-font-family
|
|
@vindex ps-font-size
|
|
@vindex ps-font-info-database
|
|
The variable @code{ps-font-family} specifies which font family to use
|
|
for printing ordinary text. Legitimate values include @code{Courier},
|
|
@code{Helvetica}, @code{NewCenturySchlbk}, @code{Palatino} and
|
|
@code{Times}. The variable @code{ps-font-size} specifies the size of
|
|
the font for ordinary text. It defaults to 8.5 points.
|
|
|
|
@vindex ps-multibyte-buffer
|
|
@cindex Intlfonts for PostScript printing
|
|
@cindex fonts for PostScript printing
|
|
Emacs supports more scripts and characters than a typical PostScript
|
|
printer. Thus, some of the characters in your buffer might not be
|
|
printable using the fonts built into your printer. You can augment
|
|
the fonts supplied with the printer with those from the GNU Intlfonts
|
|
package, or you can instruct Emacs to use Intlfonts exclusively. The
|
|
variable @code{ps-multibyte-buffer} controls this: the default value,
|
|
@code{nil}, is appropriate for printing @acronym{ASCII} and Latin-1
|
|
characters; a value of @code{non-latin-printer} is for printers which
|
|
have the fonts for @acronym{ASCII}, Latin-1, Japanese, and Korean
|
|
characters built into them. A value of @code{bdf-font} arranges for
|
|
the BDF fonts from the Intlfonts package to be used for @emph{all}
|
|
characters. Finally, a value of @code{bdf-font-except-latin}
|
|
instructs the printer to use built-in fonts for @acronym{ASCII} and Latin-1
|
|
characters, and Intlfonts BDF fonts for the rest.
|
|
|
|
@vindex bdf-directory-list
|
|
To be able to use the BDF fonts, Emacs needs to know where to find
|
|
them. The variable @code{bdf-directory-list} holds the list of
|
|
directories where Emacs should look for the fonts; the default value
|
|
includes a single directory @file{/usr/local/share/emacs/fonts/bdf}.
|
|
|
|
Many other customization variables for these commands are defined and
|
|
described in the Lisp files @file{ps-print.el} and @file{ps-mule.el}.
|
|
|
|
@node Printing Package,, PostScript Variables, Printing
|
|
@section Printing Package
|
|
@cindex 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
|
|
@file{gv} utilities, which are distributed as part of the GhostScript
|
|
program. On MS-Windows, the @file{gstools} port of Ghostscript can be
|
|
used.
|
|
|
|
@findex 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
|
|
@samp{*Printing 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
|
|
@kbd{mouse-2} on it, or move point over it and type @kbd{RET}). For
|
|
further information on the various options, use the @samp{Interface
|
|
Help} button.
|
|
|
|
@node Sorting, Narrowing, Printing, Top
|
|
@section Sorting Text
|
|
@cindex 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.
|
|
|
|
@findex sort-lines
|
|
@findex sort-paragraphs
|
|
@findex sort-pages
|
|
@findex sort-fields
|
|
@findex sort-numeric-fields
|
|
@vindex sort-numeric-base
|
|
@table @kbd
|
|
@item M-x sort-lines
|
|
Divide the region into lines, and sort by comparing the entire
|
|
text of a line. A numeric argument means sort into descending order.
|
|
|
|
@item M-x sort-paragraphs
|
|
Divide the region into paragraphs, and sort by comparing the entire
|
|
text of a paragraph (except for leading blank lines). A numeric
|
|
argument means sort into descending order.
|
|
|
|
@item M-x sort-pages
|
|
Divide the region into pages, and sort by comparing the entire
|
|
text of a page (except for leading blank lines). A numeric
|
|
argument means sort into descending order.
|
|
|
|
@item M-x sort-fields
|
|
Divide the region into lines, and sort by comparing the contents of
|
|
one field in each line. Fields are defined as separated by
|
|
whitespace, so the first run of consecutive non-whitespace characters
|
|
in a line constitutes field 1, the second such run constitutes field
|
|
2, etc.
|
|
|
|
Specify which field to sort by with a numeric argument: 1 to sort by
|
|
field 1, etc. A negative argument means count fields from the right
|
|
instead of from the left; thus, minus 1 means sort by the last field.
|
|
If several lines have identical contents in the field being sorted, they
|
|
keep the same relative order that they had in the original buffer.
|
|
|
|
@item M-x sort-numeric-fields
|
|
Like @kbd{M-x sort-fields} except the specified field is converted
|
|
to an integer for each line, and the numbers are compared. @samp{10}
|
|
comes before @samp{2} when considered as text, but after it when
|
|
considered as a number. By default, numbers are interpreted according
|
|
to @code{sort-numeric-base}, but numbers beginning with @samp{0x} or
|
|
@samp{0} are interpreted as hexadecimal and octal, respectively.
|
|
|
|
@item M-x sort-columns
|
|
Like @kbd{M-x sort-fields} except that the text within each line
|
|
used for comparison comes from a fixed range of columns. See below
|
|
for an explanation.
|
|
|
|
@item M-x reverse-region
|
|
Reverse the order of the lines in the region. This is useful for
|
|
sorting into descending order by fields or columns, since those sort
|
|
commands do not have a feature for doing that.
|
|
@end table
|
|
|
|
For example, if the buffer contains this:
|
|
|
|
@smallexample
|
|
On systems where clash detection (locking of files being edited) is
|
|
implemented, Emacs also checks the first time you modify a buffer
|
|
whether the file has changed on disk since it was last visited or
|
|
saved. If it has, you are asked to confirm that you want to change
|
|
the buffer.
|
|
@end smallexample
|
|
|
|
@noindent
|
|
applying @kbd{M-x sort-lines} to the entire buffer produces this:
|
|
|
|
@smallexample
|
|
On systems where clash detection (locking of files being edited) is
|
|
implemented, Emacs also checks the first time you modify a buffer
|
|
saved. If it has, you are asked to confirm that you want to change
|
|
the buffer.
|
|
whether the file has changed on disk since it was last visited or
|
|
@end smallexample
|
|
|
|
@noindent
|
|
where the upper-case @samp{O} sorts before all lower-case letters. If
|
|
you use @kbd{C-u 2 M-x sort-fields} instead, you get this:
|
|
|
|
@smallexample
|
|
implemented, Emacs also checks the first time you modify a buffer
|
|
saved. If it has, you are asked to confirm that you want to change
|
|
the buffer.
|
|
On systems where clash detection (locking of files being edited) is
|
|
whether the file has changed on disk since it was last visited or
|
|
@end smallexample
|
|
|
|
@noindent
|
|
where the sort keys were @samp{Emacs}, @samp{If}, @samp{buffer},
|
|
@samp{systems} and @samp{the}.
|
|
|
|
@findex sort-columns
|
|
@kbd{M-x sort-columns} requires more explanation. You specify the
|
|
columns by putting point at one of the columns and the mark at the other
|
|
column. Because this means you cannot put point or the mark at the
|
|
beginning of the first line of the text you want to sort, this command
|
|
uses an unusual definition of ``region'': all of the line point is in is
|
|
considered part of the region, and so is all of the line the mark is in,
|
|
as well as all the lines in between.
|
|
|
|
For example, to sort a table by information found in columns 10 to 15,
|
|
you could put the mark on column 10 in the first line of the table, and
|
|
point on column 15 in the last line of the table, and then run
|
|
@code{sort-columns}. Equivalently, you could run it with the mark on
|
|
column 15 in the first line and point on column 10 in the last line.
|
|
|
|
This can be thought of as sorting the rectangle specified by point and
|
|
the mark, except that the text on each line to the left or right of the
|
|
rectangle moves along with the text inside the rectangle.
|
|
@xref{Rectangles}.
|
|
|
|
@vindex sort-fold-case
|
|
Many of the sort commands ignore case differences when comparing, if
|
|
@code{sort-fold-case} is non-@code{nil}.
|
|
|
|
@node Narrowing, Two-Column, Sorting, Top
|
|
@section Narrowing
|
|
@cindex widening
|
|
@cindex restriction
|
|
@cindex narrowing
|
|
@cindex accessible portion
|
|
|
|
@dfn{Narrowing} means focusing in on some portion of the buffer,
|
|
making the rest temporarily inaccessible. The portion which you can
|
|
still get to is called the @dfn{accessible portion}. Canceling the
|
|
narrowing, which makes the entire buffer once again accessible, is
|
|
called @dfn{widening}. The 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.
|
|
|
|
@table @kbd
|
|
@item C-x n n
|
|
Narrow down to between point and mark (@code{narrow-to-region}).
|
|
@item C-x n w
|
|
Widen to make the entire buffer accessible again (@code{widen}).
|
|
@item C-x n p
|
|
Narrow down to the current page (@code{narrow-to-page}).
|
|
@item C-x n d
|
|
Narrow down to the current defun (@code{narrow-to-defun}).
|
|
@end table
|
|
|
|
When you have narrowed down to a part of the buffer, that part appears
|
|
to be all there is. You can't see the rest, you can't move into it
|
|
(motion commands won't go outside the accessible part), you can't change
|
|
it in any way. However, it is not gone, and if you save the file all
|
|
the inaccessible text will be saved. The word @samp{Narrow} appears in
|
|
the mode line whenever narrowing is in effect.
|
|
|
|
@kindex C-x n n
|
|
@findex narrow-to-region
|
|
The primary narrowing command is @kbd{C-x n n} (@code{narrow-to-region}).
|
|
It sets the current buffer's restrictions so that the text in the current
|
|
region remains accessible, but all text before the region or after the
|
|
region is inaccessible. Point and mark do not change.
|
|
|
|
@kindex C-x n p
|
|
@findex narrow-to-page
|
|
@kindex C-x n d
|
|
@findex narrow-to-defun
|
|
Alternatively, use @kbd{C-x n p} (@code{narrow-to-page}) to narrow
|
|
down to the current page. @xref{Pages}, for the definition of a page.
|
|
@kbd{C-x n d} (@code{narrow-to-defun}) narrows down to the defun
|
|
containing point (@pxref{Defuns}).
|
|
|
|
@kindex C-x n w
|
|
@findex widen
|
|
The way to cancel narrowing is to widen with @kbd{C-x n w}
|
|
(@code{widen}). This makes all text in the buffer accessible again.
|
|
|
|
You can get information on what part of the buffer you are narrowed down
|
|
to using the @kbd{C-x =} command. @xref{Position Info}.
|
|
|
|
Because narrowing can easily confuse users who do not understand it,
|
|
@code{narrow-to-region} is normally a disabled command. Attempting to use
|
|
this command asks for confirmation and gives you the option of enabling it;
|
|
if you enable the command, confirmation will no longer be required for
|
|
it. @xref{Disabling}.
|
|
|
|
@node Two-Column, Editing Binary Files, Narrowing, Top
|
|
@section Two-Column Editing
|
|
@cindex two-column editing
|
|
@cindex splitting columns
|
|
@cindex columns, splitting
|
|
|
|
Two-column mode lets you conveniently edit two side-by-side columns of
|
|
text. It uses two side-by-side windows, each showing its own
|
|
buffer.
|
|
|
|
There are three ways to enter two-column mode:
|
|
|
|
@table @asis
|
|
@item @kbd{@key{F2} 2} or @kbd{C-x 6 2}
|
|
@kindex F2 2
|
|
@kindex C-x 6 2
|
|
@findex 2C-two-columns
|
|
Enter two-column mode with the current buffer on the left, and on the
|
|
right, a buffer whose name is based on the current buffer's name
|
|
(@code{2C-two-columns}). If the right-hand buffer doesn't already
|
|
exist, it starts out empty; the current buffer's contents are not
|
|
changed.
|
|
|
|
This command is appropriate when the current buffer is empty or contains
|
|
just one column and you want to add another column.
|
|
|
|
@item @kbd{@key{F2} s} or @kbd{C-x 6 s}
|
|
@kindex F2 s
|
|
@kindex C-x 6 s
|
|
@findex 2C-split
|
|
Split the current buffer, which contains two-column text, into two
|
|
buffers, and display them side by side (@code{2C-split}). The current
|
|
buffer becomes the left-hand buffer, but the text in the right-hand
|
|
column is moved into the right-hand buffer. The current column
|
|
specifies the split point. Splitting starts with the current line and
|
|
continues to the end of the buffer.
|
|
|
|
This command is appropriate when you have a buffer that already contains
|
|
two-column text, and you wish to separate the columns temporarily.
|
|
|
|
@item @kbd{@key{F2} b @var{buffer} @key{RET}}
|
|
@itemx @kbd{C-x 6 b @var{buffer} @key{RET}}
|
|
@kindex F2 b
|
|
@kindex C-x 6 b
|
|
@findex 2C-associate-buffer
|
|
Enter two-column mode using the current buffer as the left-hand buffer,
|
|
and using buffer @var{buffer} as the right-hand buffer
|
|
(@code{2C-associate-buffer}).
|
|
@end table
|
|
|
|
@kbd{@key{F2} s} or @kbd{C-x 6 s} looks for a column separator, which
|
|
is a string that appears on each line between the two columns. You can
|
|
specify the width of the separator with a numeric argument to
|
|
@kbd{@key{F2} s}; that many characters, before point, constitute the
|
|
separator string. By default, the width is 1, so the column separator
|
|
is the character before point.
|
|
|
|
When a line has the separator at the proper place, @kbd{@key{F2} s}
|
|
puts the text after the separator into the right-hand buffer, and
|
|
deletes the separator. Lines that don't have the column separator at
|
|
the proper place remain unsplit; they stay in the left-hand buffer, and
|
|
the right-hand buffer gets an empty line to correspond. (This is the
|
|
way to write a line that ``spans both columns while in two-column
|
|
mode'': write it in the left-hand buffer, and put an empty line in the
|
|
right-hand buffer.)
|
|
|
|
@kindex F2 RET
|
|
@kindex C-x 6 RET
|
|
@findex 2C-newline
|
|
The command @kbd{C-x 6 @key{RET}} or @kbd{@key{F2} @key{RET}}
|
|
(@code{2C-newline}) inserts a newline in each of the two buffers at
|
|
corresponding positions. This is the easiest way to add a new line to
|
|
the two-column text while editing it in split buffers.
|
|
|
|
@kindex F2 1
|
|
@kindex C-x 6 1
|
|
@findex 2C-merge
|
|
When you have edited both buffers as you wish, merge them with
|
|
@kbd{@key{F2} 1} or @kbd{C-x 6 1} (@code{2C-merge}). This copies the
|
|
text from the right-hand buffer as a second column in the other buffer.
|
|
To go back to two-column editing, use @kbd{@key{F2} s}.
|
|
|
|
@kindex F2 d
|
|
@kindex C-x 6 d
|
|
@findex 2C-dissociate
|
|
Use @kbd{@key{F2} d} or @kbd{C-x 6 d} to dissociate the two buffers,
|
|
leaving each as it stands (@code{2C-dissociate}). If the other buffer,
|
|
the one not current when you type @kbd{@key{F2} d}, is empty,
|
|
@kbd{@key{F2} d} kills it.
|
|
|
|
@node Editing Binary Files, Saving Emacs Sessions, Two-Column, Top
|
|
@section Editing Binary Files
|
|
|
|
@cindex Hexl mode
|
|
@cindex mode, Hexl
|
|
@cindex editing binary files
|
|
@cindex hex editing
|
|
There is a special major mode for editing binary files: Hexl mode. To
|
|
use it, use @kbd{M-x hexl-find-file} instead of @kbd{C-x C-f} to visit
|
|
the file. This command converts the file's contents to hexadecimal and
|
|
lets you edit the translation. When you save the file, it is converted
|
|
automatically back to binary.
|
|
|
|
You can also use @kbd{M-x hexl-mode} to translate an existing buffer
|
|
into hex. This is useful if you visit a file normally and then discover
|
|
it is a binary file.
|
|
|
|
Ordinary text characters overwrite in Hexl mode. This is to reduce
|
|
the risk of accidentally spoiling the alignment of data in the file.
|
|
There are special commands for insertion. Here is a list of the
|
|
commands of Hexl mode:
|
|
|
|
@c I don't think individual index entries for these commands are useful--RMS.
|
|
@table @kbd
|
|
@item C-M-d
|
|
Insert a byte with a code typed in decimal.
|
|
|
|
@item C-M-o
|
|
Insert a byte with a code typed in octal.
|
|
|
|
@item C-M-x
|
|
Insert a byte with a code typed in hex.
|
|
|
|
@item C-x [
|
|
Move to the beginning of a 1k-byte ``page.''
|
|
|
|
@item C-x ]
|
|
Move to the end of a 1k-byte ``page.''
|
|
|
|
@item M-g
|
|
Move to an address specified in hex.
|
|
|
|
@item M-j
|
|
Move to an address specified in decimal.
|
|
|
|
@item C-c C-c
|
|
Leave Hexl mode, going back to the major mode this buffer had before you
|
|
invoked @code{hexl-mode}.
|
|
@end table
|
|
|
|
@noindent
|
|
Other Hexl commands let you insert strings (sequences) of binary
|
|
bytes, move by @code{short}s or @code{int}s, etc.; type @kbd{C-h a
|
|
hexl-@key{RET}} for details.
|
|
|
|
|
|
@node Saving Emacs Sessions, Recursive Edit, Editing Binary Files, Top
|
|
@section Saving Emacs Sessions
|
|
@cindex saving sessions
|
|
@cindex restore session
|
|
@cindex remember editing session
|
|
@cindex reload files
|
|
@cindex desktop
|
|
|
|
Use the desktop library to save the state of Emacs from one session
|
|
to another. Once you save the Emacs @dfn{desktop}---the buffers,
|
|
their file names, major modes, buffer positions, and so on---then
|
|
subsequent Emacs sessions reload the saved desktop.
|
|
|
|
@findex desktop-save
|
|
@vindex desktop-save-mode
|
|
You can save the desktop manually with the command @kbd{M-x
|
|
desktop-save}. You can also enable 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 init file (@pxref{Init File}):
|
|
|
|
@example
|
|
(desktop-save-mode 1)
|
|
@end example
|
|
|
|
@findex desktop-change-dir
|
|
@findex desktop-revert
|
|
If you turn on @code{desktop-save-mode} in your init file, 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 @kbd{M-x
|
|
desktop-revert} reverts to the desktop previously reloaded.
|
|
|
|
Specify the option @samp{--no-desktop} on the command line when you
|
|
don't want it to reload any saved desktop. This turns off
|
|
@code{desktop-save-mode} for the current session. Starting Emacs with
|
|
the @samp{--no-init-file} option also disables desktop reloading,
|
|
since it bypasses the init file, where @code{desktop-save-mode} is
|
|
usually turned on.
|
|
|
|
@vindex 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.
|
|
|
|
@findex desktop-clear
|
|
@vindex desktop-globals-to-clear
|
|
@vindex desktop-clear-preserve-buffers-regexp
|
|
Type @kbd{M-x desktop-clear} to empty the Emacs desktop. This kills
|
|
all buffers except for internal ones, and clears the global variables
|
|
listed in @code{desktop-globals-to-clear}. If you want this to
|
|
preserve certain buffers, customize the variable
|
|
@code{desktop-clear-preserve-buffers-regexp}, whose value is a regular
|
|
expression matching the names of buffers not to kill.
|
|
|
|
If you want to save minibuffer history from one session to
|
|
another, use the @code{savehist} library.
|
|
|
|
@node Recursive Edit, Emulation, Saving Emacs Sessions, Top
|
|
@section Recursive Editing Levels
|
|
@cindex recursive editing level
|
|
@cindex editing level, recursive
|
|
|
|
A @dfn{recursive edit} is a situation in which you are using Emacs
|
|
commands to perform arbitrary editing while in the middle of another
|
|
Emacs command. For example, when you type @kbd{C-r} inside of a
|
|
@code{query-replace}, you enter a recursive edit in which you can change
|
|
the current buffer. On exiting from the recursive edit, you go back to
|
|
the @code{query-replace}.
|
|
|
|
@kindex C-M-c
|
|
@findex exit-recursive-edit
|
|
@cindex exiting recursive edit
|
|
@dfn{Exiting} the recursive edit means returning to the unfinished
|
|
command, which continues execution. The command to exit is @kbd{C-M-c}
|
|
(@code{exit-recursive-edit}).
|
|
|
|
You can also @dfn{abort} the recursive edit. This is like exiting,
|
|
but also quits the unfinished command immediately. Use the command
|
|
@kbd{C-]} (@code{abort-recursive-edit}) to do this. @xref{Quitting}.
|
|
|
|
The mode line shows you when you are in a recursive edit by displaying
|
|
square brackets around the parentheses that always surround the major and
|
|
minor mode names. Every window's mode line shows this in the same way,
|
|
since being in a recursive edit is true of Emacs as a whole rather than
|
|
any particular window or buffer.
|
|
|
|
It is possible to be in recursive edits within recursive edits. For
|
|
example, after typing @kbd{C-r} in a @code{query-replace}, you may type a
|
|
command that enters the debugger. This begins a recursive editing level
|
|
for the debugger, within the recursive editing level for @kbd{C-r}.
|
|
Mode lines display a pair of square brackets for each recursive editing
|
|
level currently in progress.
|
|
|
|
Exiting the inner recursive edit (such as with the debugger @kbd{c}
|
|
command) resumes the command running in the next level up. When that
|
|
command finishes, you can then use @kbd{C-M-c} to exit another recursive
|
|
editing level, and so on. Exiting applies to the innermost level only.
|
|
Aborting also gets out of only one level of recursive edit; it returns
|
|
immediately to the command level of the previous recursive edit. If you
|
|
wish, you can then abort the next recursive editing level.
|
|
|
|
Alternatively, the command @kbd{M-x top-level} aborts all levels of
|
|
recursive edits, returning immediately to the top-level command
|
|
reader. It also exits the minibuffer, if it is active.
|
|
|
|
The text being edited inside the recursive edit need not be the same text
|
|
that you were editing at top level. It depends on what the recursive edit
|
|
is for. If the command that invokes the recursive edit selects a different
|
|
buffer first, that is the buffer you will edit recursively. In any case,
|
|
you can switch buffers within the recursive edit in the normal manner (as
|
|
long as the buffer-switching keys have not been rebound). You could
|
|
probably do all the rest of your editing inside the recursive edit,
|
|
visiting files and all. But this could have surprising effects (such as
|
|
stack overflow) from time to time. So remember to exit or abort the
|
|
recursive edit when you no longer need it.
|
|
|
|
In general, we try to minimize the use of recursive editing levels in
|
|
GNU Emacs. This is because they constrain you to ``go back'' in a
|
|
particular order---from the innermost level toward the top level. When
|
|
possible, we present different activities in separate buffers so that
|
|
you can switch between them as you please. Some commands switch to a
|
|
new major mode which provides a command to switch back. These
|
|
approaches give you more flexibility to go back to unfinished tasks in
|
|
the order you choose.
|
|
|
|
@node Emulation, Hyperlinking, Recursive Edit, Top
|
|
@section Emulation
|
|
@cindex emulating other editors
|
|
@cindex other editors
|
|
@cindex EDT
|
|
@cindex vi
|
|
@cindex PC key bindings
|
|
@cindex scrolling all windows
|
|
@cindex PC selection
|
|
@cindex Motif key bindings
|
|
@cindex Macintosh key bindings
|
|
@cindex WordStar
|
|
|
|
GNU Emacs can be programmed to emulate (more or less) most other
|
|
editors. Standard facilities can emulate these:
|
|
|
|
@table @asis
|
|
@item CRiSP/Brief (PC editor)
|
|
@findex crisp-mode
|
|
@vindex crisp-override-meta-x
|
|
@findex scroll-all-mode
|
|
@cindex CRiSP mode
|
|
@cindex Brief emulation
|
|
@cindex emulation of Brief
|
|
@cindex mode, CRiSP
|
|
You can turn on key bindings to emulate the CRiSP/Brief editor with
|
|
@kbd{M-x crisp-mode}. Note that this rebinds @kbd{M-x} to exit Emacs
|
|
unless you set the variable @code{crisp-override-meta-x}. You can
|
|
also use the command @kbd{M-x scroll-all-mode} or set the variable
|
|
@code{crisp-load-scroll-all} to emulate CRiSP's scroll-all feature
|
|
(scrolling all windows together).
|
|
|
|
@item EDT (DEC VMS editor)
|
|
@findex edt-emulation-on
|
|
@findex edt-emulation-off
|
|
Turn on EDT emulation with 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.
|
|
|
|
@item TPU (DEC VMS editor)
|
|
@findex tpu-edt-on
|
|
@cindex TPU
|
|
@kbd{M-x tpu-edt-on} turns on emulation of the TPU editor emulating EDT.
|
|
|
|
@item vi (Berkeley editor)
|
|
@findex viper-mode
|
|
Viper is the newest emulator for vi. It implements several levels of
|
|
emulation; level 1 is closest to vi itself, while level 5 departs
|
|
somewhat from strict emulation to take advantage of the capabilities of
|
|
Emacs. To invoke Viper, type @kbd{M-x viper-mode}; it will guide you
|
|
the rest of the way and ask for the emulation level. @inforef{Top,
|
|
Viper, viper}.
|
|
|
|
@item vi (another emulator)
|
|
@findex vi-mode
|
|
@kbd{M-x vi-mode} enters a major mode that replaces the previously
|
|
established major mode. All of the vi commands that, in real vi, enter
|
|
``input'' mode are programmed instead to return to the previous major
|
|
mode. Thus, ordinary Emacs serves as vi's ``input'' mode.
|
|
|
|
Because vi emulation works through major modes, it does not work
|
|
to switch buffers during emulation. Return to normal Emacs first.
|
|
|
|
If you plan to use vi emulation much, you probably want to bind a key
|
|
to the @code{vi-mode} command.
|
|
|
|
@item vi (alternate emulator)
|
|
@findex vip-mode
|
|
@kbd{M-x vip-mode} invokes another vi emulator, said to resemble real vi
|
|
more thoroughly than @kbd{M-x vi-mode}. ``Input'' mode in this emulator
|
|
is changed from ordinary Emacs so you can use @key{ESC} to go back to
|
|
emulated vi command mode. To get from emulated vi command mode back to
|
|
ordinary Emacs, type @kbd{C-z}.
|
|
|
|
This emulation does not work through major modes, and it is possible
|
|
to switch buffers in various ways within the emulator. It is not
|
|
so necessary to assign a key to the command @code{vip-mode} as
|
|
it is with @code{vi-mode} because terminating insert mode does
|
|
not use it.
|
|
|
|
@inforef{Top, VIP, vip}, for full information.
|
|
|
|
@item WordStar (old wordprocessor)
|
|
@findex wordstar-mode
|
|
@kbd{M-x wordstar-mode} provides a major mode with WordStar-like
|
|
key bindings.
|
|
@end table
|
|
|
|
@node Hyperlinking, Dissociated Press, Emulation, Top
|
|
@section Hyperlinking and Navigation Features
|
|
|
|
@cindex hyperlinking
|
|
@cindex navigation
|
|
Various modes documented elsewhere have hypertext features so that
|
|
you can follow links, usually by clicking @kbd{Mouse-2} on the link or
|
|
typing @key{RET} while point is on the link. 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
|
|
@ref{Imenu}. Info-lookup provides mode-specific lookup of definitions
|
|
in Info indexes, see @ref{Documentation}. Speedbar maintains a frame
|
|
in which links to files, and locations in files are displayed, see
|
|
@ref{Speedbar}.
|
|
|
|
Other non-mode-specific facilities described in this section enable
|
|
following links from the current buffer in a context-sensitive
|
|
fashion.
|
|
|
|
@menu
|
|
* Browse-URL:: Following URLs.
|
|
* Goto Address mode:: Activating URLs.
|
|
* FFAP:: Finding files etc. at point.
|
|
@end menu
|
|
|
|
@node Browse-URL
|
|
@subsection Following URLs
|
|
@cindex World Wide Web
|
|
@cindex Web
|
|
@findex browse-url
|
|
@findex browse-url-at-point
|
|
@findex browse-url-at-mouse
|
|
@cindex Browse-URL
|
|
@cindex URLs
|
|
|
|
@table @kbd
|
|
@item M-x browse-url @key{RET} @var{url} @key{RET}
|
|
Load a URL into a Web browser.
|
|
@end table
|
|
|
|
The Browse-URL package provides facilities for following URLs specifying
|
|
links on the World Wide Web. Usually this works by invoking a web
|
|
browser, but you can, for instance, arrange to invoke @code{compose-mail}
|
|
from @samp{mailto:} URLs.
|
|
|
|
The general way to use this feature is to type @kbd{M-x browse-url},
|
|
which displays a specified URL. If point is located near a plausible
|
|
URL, that URL is used as the default. Other commands are available
|
|
which you might like to bind to keys, such as
|
|
@code{browse-url-at-point} and @code{browse-url-at-mouse}.
|
|
|
|
@vindex browse-url-browser-function
|
|
You can customize Browse-URL's behavior via various options in the
|
|
@code{browse-url} Customize group, particularly
|
|
@code{browse-url-browser-function}. You can invoke actions dependent
|
|
on the type of URL by defining @code{browse-url-browser-function} as
|
|
an association list. The package's commentary available via @kbd{C-h
|
|
p} under the @samp{hypermedia} keyword provides more information.
|
|
Packages with facilities for following URLs should always go through
|
|
Browse-URL, so that the customization options for Browse-URL will
|
|
affect all browsing in Emacs.
|
|
|
|
@node Goto Address mode
|
|
@subsection Activating URLs
|
|
@findex goto-address-mode
|
|
@cindex Goto Address mode
|
|
@cindex URLs, activating
|
|
|
|
@table @kbd
|
|
@item M-x goto-address-mode
|
|
Activate URLs and e-mail addresses in the current buffer.
|
|
@end table
|
|
|
|
You can make URLs in the current buffer active with @kbd{M-x
|
|
goto-address-mode}. This minor mode finds all the URLs in the buffer,
|
|
highlights them, and turns them into @dfn{buttons}: if you click on a
|
|
URL with @kbd{Mouse-1} or @kbd{Mouse-2} (@pxref{Mouse References}), or
|
|
move to the URL and type @kbd{C-c @key{RET}}, that displays 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-mode} to mode hooks and
|
|
the hooks used to display an incoming message (e.g.,
|
|
@code{rmail-show-message-hook} for Rmail, and @code{mh-show-mode-hook}
|
|
for MH-E). This is not needed for Gnus, which has a similar feature
|
|
of its own.
|
|
|
|
@node FFAP
|
|
@subsection Finding Files and URLs at Point
|
|
@findex find-file-at-point
|
|
@findex ffap
|
|
@findex dired-at-point
|
|
@findex ffap-next
|
|
@findex ffap-menu
|
|
@cindex finding file at point
|
|
|
|
FFAP mode replaces certain key bindings for finding files, including
|
|
@kbd{C-x C-f}, with commands that provide more sensitive defaults.
|
|
These commands behave like the ordinary ones when given a prefix
|
|
argument. Otherwise, they get the default file name or URL from the
|
|
text around point. If what is found in the buffer has the form of a
|
|
URL rather than a file name, the commands use @code{browse-url} to
|
|
view it.
|
|
|
|
This feature is useful for following references in mail or news
|
|
buffers, @file{README} files, @file{MANIFEST} files, and so on. The
|
|
@samp{ffap} package's commentary available via @kbd{C-h p} under the
|
|
@samp{files} keyword and the @code{ffap} Custom group provide details.
|
|
|
|
@cindex FFAP minor mode
|
|
@findex ffap-mode
|
|
You can turn on FFAP minor mode by calling @code{ffap-bindings} to
|
|
make the following key bindings and to install hooks for using
|
|
@code{ffap} in Rmail, Gnus and VM article buffers.
|
|
|
|
@table @kbd
|
|
@item C-x C-f @var{filename} @key{RET}
|
|
@kindex C-x C-f @r{(FFAP)}
|
|
Find @var{filename}, guessing a default from text around point
|
|
(@code{find-file-at-point}).
|
|
@item C-x C-r
|
|
@kindex C-x C-r @r{(FFAP)}
|
|
@code{ffap-read-only}, analogous to @code{find-file-read-only}.
|
|
@item C-x C-v
|
|
@kindex C-x C-v @r{(FFAP)}
|
|
@code{ffap-alternate-file}, analogous to @code{find-alternate-file}.
|
|
@item C-x d @var{directory} @key{RET}
|
|
@kindex C-x d @r{(FFAP)}
|
|
Start Dired on @var{directory}, defaulting to the directory name at
|
|
point (@code{dired-at-point}).
|
|
@item C-x C-d
|
|
@code{ffap-list-directory}, analogous to @code{list-directory}.
|
|
@item C-x 4 f
|
|
@kindex C-x 4 f @r{(FFAP)}
|
|
@code{ffap-other-window}, analogous to @code{find-file-other-window}.
|
|
@item C-x 4 r
|
|
@code{ffap-read-only-other-window}, analogous to
|
|
@code{find-file-read-only-other-window}.
|
|
@item C-x 4 d
|
|
@code{ffap-dired-other-window}, analogous to @code{dired-other-window}.
|
|
@item C-x 5 f
|
|
@kindex C-x 5 f @r{(FFAP)}
|
|
@code{ffap-other-frame}, analogous to @code{find-file-other-frame}.
|
|
@item C-x 5 r
|
|
@code{ffap-read-only-other-frame}, analogous to
|
|
@code{find-file-read-only-other-frame}.
|
|
@item C-x 5 d
|
|
@code{ffap-dired-other-frame}, analogous to @code{dired-other-frame}.
|
|
@item M-x ffap-next
|
|
Search buffer for next file name or URL, then find that file or URL.
|
|
@item S-Mouse-3
|
|
@kindex S-Mouse-3 @r{(FFAP)}
|
|
@code{ffap-at-mouse} finds the file guessed from text around the position
|
|
of a mouse click.
|
|
@item C-S-Mouse-3
|
|
@kindex C-S-Mouse-3 @r{(FFAP)}
|
|
Display a menu of files and URLs mentioned in current buffer, then
|
|
find the one you select (@code{ffap-menu}).
|
|
@end table
|
|
|
|
@node Dissociated Press, Amusements, Hyperlinking, Top
|
|
@section Dissociated Press
|
|
|
|
@findex dissociated-press
|
|
@kbd{M-x dissociated-press} is a command for scrambling a file of text
|
|
either word by word or character by character. Starting from a buffer of
|
|
straight English, it produces extremely amusing output. The input comes
|
|
from the current Emacs buffer. Dissociated Press writes its output in a
|
|
buffer named @samp{*Dissociation*}, and redisplays that buffer after every
|
|
couple of lines (approximately) so you can read the output as it comes out.
|
|
|
|
Dissociated Press asks every so often whether to continue generating
|
|
output. Answer @kbd{n} to stop it. You can also stop at any time by
|
|
typing @kbd{C-g}. The dissociation output remains in the
|
|
@samp{*Dissociation*} buffer for you to copy elsewhere if you wish.
|
|
|
|
@cindex presidentagon
|
|
Dissociated Press operates by jumping at random from one point in
|
|
the buffer to another. In order to produce plausible output rather
|
|
than gibberish, it insists on a certain amount of overlap between the
|
|
end of one run of consecutive words or characters and the start of the
|
|
next. That is, if it has just output `president' and then decides to
|
|
jump to a different point in the buffer, it might spot the `ent' in
|
|
`pentagon' and continue from there, producing `presidentagon'. Long
|
|
sample texts produce the best results.
|
|
|
|
@cindex againformation
|
|
A positive argument to @kbd{M-x dissociated-press} tells it to operate
|
|
character by character, and specifies the number of overlap characters. A
|
|
negative argument tells it to operate word by word, and specifies the number
|
|
of overlap words. In this mode, whole words are treated as the elements to
|
|
be permuted, rather than characters. No argument is equivalent to an
|
|
argument of two. For your againformation, the output goes only into the
|
|
buffer @samp{*Dissociation*}. The buffer you start with is not changed.
|
|
|
|
@cindex Markov chain
|
|
@cindex ignoriginal
|
|
@cindex techniquitous
|
|
Dissociated Press produces 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
|
|
text between random jumps, unlike a Markov chain which would jump
|
|
randomly after each word or character. This makes for more plausible
|
|
sounding results, and runs faster.
|
|
|
|
@cindex outragedy
|
|
@cindex buggestion
|
|
@cindex properbose
|
|
@cindex mustatement
|
|
@cindex developediment
|
|
@cindex userenced
|
|
It is a mustatement that too much use of Dissociated Press can be a
|
|
developediment to your real work, sometimes to the point of outragedy.
|
|
And keep dissociwords out of your documentation, if you want it to be well
|
|
userenced and properbose. Have fun. Your buggestions are welcome.
|
|
|
|
@node Amusements, Customization, Dissociated Press, Top
|
|
@section Other Amusements
|
|
@cindex boredom
|
|
@findex hanoi
|
|
@findex yow
|
|
@findex gomoku
|
|
@cindex tower of Hanoi
|
|
|
|
If you are a little bit bored, you can try @kbd{M-x hanoi}. If you are
|
|
considerably bored, give it a numeric argument. If you are very, very
|
|
bored, try an argument of 9. Sit back and watch.
|
|
|
|
@cindex Go Moku
|
|
If you want a little more personal involvement, try @kbd{M-x gomoku},
|
|
which plays the game Go Moku with you.
|
|
|
|
@findex blackbox
|
|
@findex mpuz
|
|
@findex 5x5
|
|
@cindex puzzles
|
|
@kbd{M-x blackbox}, @kbd{M-x mpuz} and @kbd{M-x 5x5} are puzzles.
|
|
@code{blackbox} challenges you to determine the location of objects
|
|
inside a box by tomography. @code{mpuz} displays a multiplication
|
|
puzzle with letters standing for digits in a code that you must
|
|
guess---to guess a value, type a letter and then the digit you think it
|
|
stands for. The aim of @code{5x5} is to fill in all the squares.
|
|
|
|
@findex decipher
|
|
@cindex ciphers
|
|
@cindex cryptanalysis
|
|
@kbd{M-x decipher} helps you to cryptanalyze a buffer which is encrypted
|
|
in a simple monoalphabetic substitution cipher.
|
|
|
|
@findex dunnet
|
|
@kbd{M-x dunnet} runs an adventure-style exploration game, which is
|
|
a bigger sort of puzzle.
|
|
|
|
@findex lm
|
|
@cindex landmark game
|
|
@kbd{M-x lm} runs a relatively non-participatory game in which a robot
|
|
attempts to maneuver towards a tree at the center of the window based on
|
|
unique olfactory cues from each of the four directions.
|
|
|
|
@findex life
|
|
@cindex Life
|
|
@kbd{M-x life} runs Conway's ``Life'' cellular automaton.
|
|
|
|
@findex morse-region
|
|
@findex unmorse-region
|
|
@cindex Morse code
|
|
@cindex --/---/.-./.../.
|
|
@kbd{M-x morse-region} converts text in a region to Morse code and
|
|
@kbd{M-x unmorse-region} converts it back. No cause for remorse.
|
|
|
|
@findex pong
|
|
@cindex Pong game
|
|
@kbd{M-x pong} plays a Pong-like game, bouncing the ball off opposing
|
|
bats.
|
|
|
|
@findex solitaire
|
|
@cindex solitaire
|
|
@kbd{M-x solitaire} plays a game of solitaire in which you jump pegs
|
|
across other pegs.
|
|
|
|
@findex studlify-region
|
|
@cindex StudlyCaps
|
|
@kbd{M-x studlify-region} studlify-cases the region, producing
|
|
text like this:
|
|
|
|
@example
|
|
M-x stUdlIfY-RegioN stUdlIfY-CaSeS thE region.
|
|
@end example
|
|
|
|
@findex tetris
|
|
@cindex Tetris
|
|
@findex snake
|
|
@cindex Snake
|
|
@kbd{M-x tetris} runs an implementation of the well-known Tetris game.
|
|
Likewise, @kbd{M-x snake} provides an implementation of Snake.
|
|
|
|
When you are frustrated, try the famous Eliza program. Just do
|
|
@kbd{M-x doctor}. End each input by typing @key{RET} twice.
|
|
|
|
@cindex Zippy
|
|
When you are feeling strange, type @kbd{M-x yow}.
|
|
|
|
@findex zone
|
|
The command @kbd{M-x zone} plays games with the display when Emacs is
|
|
idle.
|
|
|
|
@ifnottex
|
|
@lowersections
|
|
@end ifnottex
|
|
|
|
@ignore
|
|
arch-tag: 8f094220-c0d5-4e9e-af7d-3e0da8187474
|
|
@end ignore
|