misc.texi 96.5 KB
Newer Older
Dave Love's avatar
#  
Dave Love committed
1
@c This is part of the Emacs manual.
2
@c Copyright (C) 1985, 86, 87, 93, 94, 95, 97, 2000, 2001, 2004
Dave Love's avatar
Dave Love committed
3
@c   Free Software Foundation, Inc.
Dave Love's avatar
#  
Dave Love committed
4 5 6 7 8 9 10 11 12 13 14 15 16
@c See file emacs.texi for copying conditions.
@iftex
@chapter Miscellaneous Commands

  This chapter contains several brief topics that do not fit anywhere
else: reading netnews, running shell commands and shell subprocesses,
using a single shared Emacs for utilities that expect to run an editor
as a subprocess, printing hardcopy, sorting text, narrowing display to
part of the buffer, editing double-column files and binary files, saving
an Emacs session for later resumption, emulating other editors, and
various diversions and amusements.

@end iftex
17 18 19 20 21

@ifnottex
@raisesections
@end ifnottex

Dave Love's avatar
#  
Dave Love committed
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54
@node Gnus, Shell, Calendar/Diary, Top
@section Gnus
@cindex Gnus
@cindex reading netnews

Gnus is an Emacs package primarily designed for reading and posting
Usenet news.  It can also be used to read and respond to messages from a
number of other sources---mail, remote directories, digests, and so on.

Here we introduce Gnus and describe several basic features.
@ifinfo
For full details, see @ref{Top, Gnus,, gnus, The Gnus Manual}.
@end ifinfo
@iftex
For full details on Gnus, type @kbd{M-x info} and then select the Gnus
manual.
@end iftex

@findex gnus
To start Gnus, type @kbd{M-x gnus @key{RET}}.

@menu
* Buffers of Gnus::	The group, summary, and article buffers.
* Gnus Startup::	What you should know about starting Gnus.
* Summary of Gnus::	A short description of the basic Gnus commands.
@end menu

@node Buffers of Gnus
@subsection Gnus Buffers

As opposed to most normal Emacs packages, Gnus uses a number of
different buffers to display information and to receive commands.  The
three buffers users spend most of their time in are the @dfn{group
55
buffer}, the @dfn{summary buffer} and the @dfn{article buffer}.
Dave Love's avatar
#  
Dave Love committed
56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101

The @dfn{group buffer} contains a list of groups.  This is the first
buffer Gnus displays when it starts up.  It normally displays only the
groups to which you subscribe and that contain unread articles.  Use
this buffer to select a specific group.

The @dfn{summary buffer} lists one line for each article in a single
group.  By default, the author, the subject and the line number are
displayed for each article, but this is customizable, like most aspects
of Gnus display.  The summary buffer is created when you select a group
in the group buffer, and is killed when you exit the group.  Use this
buffer to select an article.

The @dfn{article buffer} displays the article.  In normal Gnus usage,
you don't select this buffer---all useful article-oriented commands work
in the summary buffer.  But you can select the article buffer, and
execute all Gnus commands from that buffer, if you want to.

@node Gnus Startup
@subsection When Gnus Starts Up

At startup, Gnus reads your @file{.newsrc} news initialization file
and attempts to communicate with the local news server, which is a
repository of news articles.  The news server need not be the same
computer you are logged in on.

If you start Gnus and connect to the server, but do not see any
newsgroups listed in the group buffer, type @kbd{L} or @kbd{A k} to get
a listing of all the groups.  Then type @kbd{u} to toggle
subscription to groups.

The first time you start Gnus, Gnus subscribes you to a few selected
groups.  All other groups start out as @dfn{killed groups} for you; you
can list them with @kbd{A k}.  All new groups that subsequently come to
exist at the news server become @dfn{zombie groups} for you; type @kbd{A
z} to list them.  You can subscribe to a group shown in these lists
using the @kbd{u} command.

When you quit Gnus with @kbd{q}, it automatically records in your
@file{.newsrc} and @file{.newsrc.eld} initialization files the
subscribed or unsubscribed status of all groups.  You should normally
not edit these files manually, but you may if you know how.

@node Summary of Gnus
@subsection Summary of Gnus Commands

102
Reading news is a two-step process:
Dave Love's avatar
#  
Dave Love committed
103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168

@enumerate
@item
Choose a group in the group buffer.

@item
Select articles from the summary buffer.  Each article selected is
displayed in the article buffer in a large window, below the summary
buffer in its small window.
@end enumerate

  Each Gnus buffer has its own special commands; however, the meanings
of any given key in the various Gnus buffers are usually analogous, even
if not identical.  Here are commands for the group and summary buffers:

@table @kbd
@kindex q @r{(Gnus Group mode)}
@findex gnus-group-exit
@item q
In the group buffer, update your @file{.newsrc} initialization file
and quit Gnus.

In the summary buffer, exit the current group and return to the
group buffer.  Thus, typing @kbd{q} twice quits Gnus.

@kindex L @r{(Gnus Group mode)}
@findex gnus-group-list-all-groups
@item L
In the group buffer, list all the groups available on your news
server (except those you have killed).  This may be a long list!

@kindex l @r{(Gnus Group mode)}
@findex gnus-group-list-groups
@item l
In the group buffer, list only the groups to which you subscribe and
which contain unread articles.

@kindex u @r{(Gnus Group mode)}
@findex gnus-group-unsubscribe-current-group
@cindex subscribe groups
@cindex unsubscribe groups
@item u
In the group buffer, unsubscribe from (or subscribe to) the group listed
in the line that point is on.  When you quit Gnus by typing @kbd{q},
Gnus lists in your @file{.newsrc} file which groups you have subscribed
to.  The next time you start Gnus, you won't see this group,
because Gnus normally displays only subscribed-to groups.

@kindex C-k @r{(Gnus)}
@findex gnus-group-kill-group
@item C-k
In the group buffer, ``kill'' the current line's group---don't
even list it in @file{.newsrc} from now on.  This affects future
Gnus sessions as well as the present session.

When you quit Gnus by typing @kbd{q}, Gnus writes information
in the file @file{.newsrc} describing all newsgroups except those you
have ``killed.''

@kindex SPC @r{(Gnus)}
@findex gnus-group-read-group
@item @key{SPC}
In the group buffer, select the group on the line under the cursor
and display the first unread article in that group.

@need 1000
169
In the summary buffer,
Dave Love's avatar
#  
Dave Love committed
170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298

@itemize @bullet
@item
Select the article on the line under the cursor if none is selected.

@item
Scroll the text of the selected article (if there is one).

@item
Select the next unread article if at the end of the current article.
@end itemize

Thus, you can move through all the articles by repeatedly typing @key{SPC}.

@kindex DEL @r{(Gnus)}
@item @key{DEL}
In the group buffer, move point to the previous group containing
unread articles.

@findex gnus-summary-prev-page
In the summary buffer, scroll the text of the article backwards.

@kindex n @r{(Gnus)}
@findex gnus-group-next-unread-group
@findex gnus-summary-next-unread-article
@item n
Move point to the next unread group, or select the next unread article.

@kindex p @r{(Gnus)}
@findex gnus-group-prev-unread-group
@findex gnus-summary-prev-unread-article
@item p
Move point to the previous unread group, or select the previous
unread article.

@kindex C-n @r{(Gnus Group mode)}
@findex gnus-group-next-group
@kindex C-p @r{(Gnus Group mode)}
@findex gnus-group-prev-group
@kindex C-n @r{(Gnus Summary mode)}
@findex gnus-summary-next-subject
@kindex C-p @r{(Gnus Summary mode)}
@findex gnus-summary-prev-subject
@item C-n
@itemx C-p
Move point to the next or previous item, even if it is marked as read.
This does not select the article or group on that line.

@kindex s @r{(Gnus Summary mode)}
@findex gnus-summary-isearch-article
@item s
In the summary buffer, do an incremental search of the current text in
the article buffer, just as if you switched to the article buffer and
typed @kbd{C-s}.

@kindex M-s @r{(Gnus Summary mode)}
@findex gnus-summary-search-article-forward
@item M-s @var{regexp} @key{RET}
In the summary buffer, search forward for articles containing a match
for @var{regexp}.

@end table

@ignore
@node Where to Look
@subsection Where to Look Further

@c Too many references to the name of the manual if done with xref in TeX!
Gnus is powerful and customizable.  Here are references to a few
@ifinfo
additional topics:

@end ifinfo
@iftex
additional topics in @cite{The Gnus Manual}:

@itemize @bullet
@item
Follow discussions on specific topics.@*
See section ``Threading.''

@item
Read digests.  See section ``Document Groups.''

@item
Refer to and jump to the parent of the current article.@*
See section ``Finding the Parent.''

@item
Refer to articles by using Message-IDs included in the messages.@*
See section ``Article Keymap.''

@item
Save articles.  See section ``Saving Articles.''

@item
Have Gnus score articles according to various criteria, like author
name, subject, or string in the body of the articles.@*
See section ``Scoring.''

@item
Send an article to a newsgroup.@*
See section ``Composing Messages.''
@end itemize
@end iftex
@ifinfo
@itemize @bullet
@item
Follow discussions on specific topics.@*
@xref{Threading, , Reading Based on Conversation Threads,
gnus, The Gnus Manual}.

@item
Read digests. @xref{Document Groups, , , gnus, The Gnus Manual}.

@item
Refer to and jump to the parent of the current article.@*
@xref{Finding the Parent, , , gnus, The Gnus Manual}.

@item
Refer to articles by using Message-IDs included in the messages.@*
@xref{Article Keymap, , , gnus, The Gnus Manual}.

@item
Save articles. @xref{Saving Articles, , , gnus, The Gnus Manual}.

@item
Have Gnus score articles according to various criteria, like author
name, subject, or string in the body of the articles.@*
299
@xref{Scoring, , , gnus, The Gnus Manual}.
Dave Love's avatar
#  
Dave Love committed
300 301 302 303 304 305 306 307 308 309 310 311 312 313

@item
Send an article to a newsgroup.@*
@xref{Composing Messages, , , gnus, The Gnus Manual}.
@end itemize
@end ifinfo
@end ignore

@node Shell, Emacs Server, Gnus, Top
@section Running Shell Commands from Emacs
@cindex subshell
@cindex shell commands

  Emacs has commands for passing single command lines to inferior shell
Dave Love's avatar
Dave Love committed
314
processes; it can also run a shell interactively with input and output
315
to an Emacs buffer named @samp{*shell*} or run a shell inside a terminal
Dave Love's avatar
Dave Love committed
316 317 318
emulator window.

There is a shell implemented entirely in Emacs, documented in a separate
319
manual.  @xref{Top,Eshell,Eshell, eshell, Eshell: The Emacs Shell}.
Dave Love's avatar
#  
Dave Love committed
320 321 322 323 324 325 326 327 328 329 330 331

@table @kbd
@item M-! @var{cmd} @key{RET}
Run the shell command line @var{cmd} and display the output
(@code{shell-command}).
@item M-| @var{cmd} @key{RET}
Run the shell command line @var{cmd} with region contents as input;
optionally replace the region with the output
(@code{shell-command-on-region}).
@item M-x shell
Run a subshell with input and output through an Emacs buffer.
You can then give commands interactively.
Dave Love's avatar
Dave Love committed
332 333 334 335
@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.
Dave Love's avatar
Dave Love committed
336 337 338
@item M-x eshell
@findex eshell
Start the Emacs shell.
Dave Love's avatar
#  
Dave Love committed
339 340 341 342 343 344 345
@end table

@menu
* Single Shell::           How to run one shell command and return.
* Interactive Shell::      Permanent shell taking input via Emacs.
* Shell Mode::             Special Emacs commands used with permanent shell.
* History: Shell History.  Repeating previous commands in a shell buffer.
346
* Directory Tracking::     Keeping track when the subshell changes directory.
Dave Love's avatar
#  
Dave Love committed
347
* Options: Shell Options.  Options for customizing Shell mode.
Dave Love's avatar
Dave Love committed
348 349 350
* 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.
Dave Love's avatar
#  
Dave Love committed
351 352 353 354 355 356 357 358 359 360 361
* Remote Host::            Connecting to another computer.
@end menu

@node Single Shell
@subsection Single Shell Commands

@kindex M-!
@findex shell-command
  @kbd{M-!} (@code{shell-command}) reads a line of text using the
minibuffer and executes it as a shell command in a subshell made just
for that command.  Standard input for the command comes from the null
362 363 364
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
365 366 367 368 369 370 371 372 373
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
Richard M. Stallman's avatar
Richard M. Stallman committed
374
instance, @kbd{M-1 M-! gunzip < foo.gz @key{RET}} would insert the
375
uncompressed equivalent of @file{foo.gz} into the current buffer.
Dave Love's avatar
#  
Dave Love committed
376 377 378 379

  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
380 381
program.  You do not get any status information for an asynchronous
command, since it hasn't finished yet.
Dave Love's avatar
#  
Dave Love committed
382 383 384 385 386 387 388 389 390 391

@kindex M-|
@findex shell-command-on-region
  @kbd{M-|} (@code{shell-command-on-region}) is like @kbd{M-!} but
passes the contents of the region as the standard input to the shell
command, instead of no input.  If a numeric argument is used, meaning
insert the output in the current buffer, then the old region is deleted
first and the output replaces it as the contents of the region.  It
returns the command's exit status when it is called from a Lisp program.

392 393
  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
394
@kbd{C-x h M-| gpg @key{RET}} to feed the entire buffer contents
395 396
to the @code{gpg} program.  That program will ignore everything except
the encoded keys, and will output a list of the keys it contains.
397

Dave Love's avatar
#  
Dave Love committed
398 399
@vindex shell-file-name
  Both @kbd{M-!} and @kbd{M-|} use @code{shell-file-name} to specify the
Gerd Moellmann's avatar
Gerd Moellmann committed
400
shell to use.  This variable is initialized based on your @env{SHELL}
Dave Love's avatar
#  
Dave Love committed
401 402 403
environment variable when Emacs is started.  If the file name does not
specify a directory, the directories in the list @code{exec-path} are
searched; this list is initialized based on the environment variable
Gerd Moellmann's avatar
Gerd Moellmann committed
404
@env{PATH} when Emacs is started.  Your @file{.emacs} file can override
Dave Love's avatar
#  
Dave Love committed
405 406
either or both of these default initializations.@refill

407 408 409
  Both @kbd{M-!} and @kbd{M-|} wait for the shell command to complete,
unless you end the command with @samp{&} to make it asyncronous.  To
stop waiting, type @kbd{C-g} to quit; that terminates the shell
Dave Love's avatar
#  
Dave Love committed
410
command with the signal @code{SIGINT}---the same signal that @kbd{C-c}
411 412 413 414 415 416 417 418
normally generates in the shell.  Emacs waits until the command
actually terminates.  If the shell command doesn't stop (because it
ignores the @code{SIGINT} signal), type @kbd{C-g} again; this sends
the command a @code{SIGKILL} signal which is impossible to ignore.

  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.
Dave Love's avatar
#  
Dave Love committed
419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446

  To specify a coding system for @kbd{M-!} or @kbd{M-|}, use the command
@kbd{C-x @key{RET} c} immediately beforehand.  @xref{Specify Coding}.

@vindex shell-command-default-error-buffer
  Error output from the command is normally intermixed with the regular
output.  If you set the variable
@code{shell-command-default-error-buffer} to a string, which is a buffer
name, error output is inserted before point in the buffer of that name.

@node Interactive Shell
@subsection Interactive Inferior Shell

@findex shell
  To run a subshell interactively, putting its typescript in an Emacs
buffer, use @kbd{M-x shell}.  This creates (or reuses) a buffer named
@samp{*shell*} and runs a subshell with input coming from and output going
to that buffer.  That is to say, any ``terminal output'' from the subshell
goes into the buffer, advancing point, and any ``terminal input'' for
the subshell comes from text in the buffer.  To give input to the subshell,
go to the end of the buffer and type the input, terminated by @key{RET}.

  Emacs does not wait for the subshell to do anything.  You can switch
windows or buffers and edit them while the shell is waiting, or while it is
running a command.  Output from the subshell waits until Emacs has time to
process it; this happens whenever Emacs is waiting for keyboard input or
for time to elapse.

447 448 449 450 451 452 453
@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}.

Richard M. Stallman's avatar
Richard M. Stallman committed
454 455 456 457
  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
458 459
create a new @samp{*shell*} buffer using plain @kbd{M-x shell}.  All the
subshells in different buffers run independently and in parallel.
Dave Love's avatar
#  
Dave Love committed
460 461

@vindex explicit-shell-file-name
462
@cindex environment variables for subshells
Gerd Moellmann's avatar
Gerd Moellmann committed
463 464
@cindex @env{ESHELL} environment variable
@cindex @env{SHELL} environment variable
Dave Love's avatar
#  
Dave Love committed
465 466
  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,
Gerd Moellmann's avatar
Gerd Moellmann committed
467 468
the environment variable @env{ESHELL} is used, or the environment
variable @env{SHELL} if there is no @env{ESHELL}.  If the file name
Dave Love's avatar
#  
Dave Love committed
469 470
specified is relative, the directories in the list @code{exec-path} are
searched; this list is initialized based on the environment variable
Gerd Moellmann's avatar
Gerd Moellmann committed
471
@env{PATH} when Emacs is started.  Your @file{.emacs} file can override
Dave Love's avatar
#  
Dave Love committed
472 473
either or both of these default initializations.

474 475 476 477 478 479
  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}.

Dave Love's avatar
#  
Dave Love committed
480 481 482 483 484
  To specify a coding system for the shell, you can use the command
@kbd{C-x @key{RET} c} immediately before @kbd{M-x shell}.  You can also
specify a coding system after starting the shell by using @kbd{C-x
@key{RET} p} in the shell buffer.  @xref{Specify Coding}.

485 486 487 488 489
@cindex @env{EMACS} environment variable
  Unless the environment variable @env{EMACS} is already defined,
Emacs defines it in the subshell, with value @code{t}.  A shell script
can check this variable to determine whether it has been run from an
Emacs subshell.
Dave Love's avatar
#  
Dave Love committed
490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505

@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
506 507
At end of buffer send line as input; otherwise, copy current line to
end of buffer and send it (@code{comint-send-input}).  When a line is
508 509 510
copied, any prompt at the beginning of the line (text output by
programs preceding your input) is omitted.  (See also the variable
@code{comint-use-prompt-regexp-instead-of-fields}.)
Dave Love's avatar
#  
Dave Love committed
511 512 513 514 515 516 517 518 519 520 521

@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
522 523 524
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
Dave Love's avatar
#  
Dave Love committed
525 526 527 528 529 530 531 532 533 534 535 536 537
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
538
Either delete a character or send @acronym{EOF}
Dave Love's avatar
#  
Dave Love committed
539
(@code{comint-delchar-or-maybe-eof}).  Typed at the end of the shell
540
buffer, @kbd{C-d} sends @acronym{EOF} to the subshell.  Typed at any other
Dave Love's avatar
#  
Dave Love committed
541 542 543 544
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)}
545
@findex comint-bol-or-process-mark
Dave Love's avatar
#  
Dave Love committed
546
Move to the beginning of the line, but after the prompt if any
547 548 549 550 551 552
(@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.)
Dave Love's avatar
#  
Dave Love committed
553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593

@item C-c @key{SPC}
Accumulate multiple lines of input, then send them together.  This
command inserts a newline before point, but does not send the preceding
text as input to the subshell---at least, not yet.  Both lines, the one
before this newline and the one after, will be sent together (along with
the newline that separates them), when you type @key{RET}.

@item C-c C-u
@kindex C-c C-u @r{(Shell mode)}
@findex comint-kill-input
Kill all text pending at end of buffer to be sent as input
(@code{comint-kill-input}).

@item C-c C-w
@kindex C-c C-w @r{(Shell mode)}
Kill a word before point (@code{backward-kill-word}).

@item C-c C-c
@kindex C-c C-c @r{(Shell mode)}
@findex comint-interrupt-subjob
Interrupt the shell or its current subjob if any
(@code{comint-interrupt-subjob}).  This command also kills
any shell input pending in the shell buffer and not yet sent.

@item C-c C-z
@kindex C-c C-z @r{(Shell mode)}
@findex comint-stop-subjob
Stop the shell or its current subjob if any (@code{comint-stop-subjob}).
This command also kills any shell input pending in the shell buffer and
not yet sent.

@item C-c C-\
@findex comint-quit-subjob
@kindex C-c C-\ @r{(Shell mode)}
Send quit signal to the shell or its current subjob if any
(@code{comint-quit-subjob}).  This command also kills any shell input
pending in the shell buffer and not yet sent.

@item C-c C-o
@kindex C-c C-o @r{(Shell mode)}
Miles Bader's avatar
Miles Bader committed
594 595 596 597 598 599 600 601 602 603 604 605 606
@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.
Dave Love's avatar
#  
Dave Love committed
607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695

@item C-c C-r
@itemx C-M-l
@kindex C-c C-r @r{(Shell mode)}
@kindex C-M-l @r{(Shell mode)}
@findex comint-show-output
Scroll to display the beginning of the last batch of output at the top
of the window; also move the cursor there (@code{comint-show-output}).

@item C-c C-e
@kindex C-c C-e @r{(Shell mode)}
@findex comint-show-maximum-output
Scroll to put the end of the buffer at the bottom of the window
(@code{comint-show-maximum-output}).

@item C-c C-f
@kindex C-c C-f @r{(Shell mode)}
@findex shell-forward-command
@vindex shell-command-regexp
Move forward across one shell command, but not beyond the current line
(@code{shell-forward-command}).  The variable @code{shell-command-regexp}
specifies how to recognize the end of a command.

@item C-c C-b
@kindex C-c C-b @r{(Shell mode)}
@findex shell-backward-command
Move backward across one shell command, but not beyond the current line
(@code{shell-backward-command}).

@item M-x dirs
Ask the shell what its current directory is, so that Emacs can agree
with the shell.

@item M-x send-invisible @key{RET} @var{text} @key{RET}
@findex send-invisible
Send @var{text} as input to the shell, after reading it without
echoing.  This is useful when a shell command runs a program that asks
for a password.

Alternatively, you can arrange for Emacs to notice password prompts
and turn off echoing for them, as follows:

@example
(add-hook 'comint-output-filter-functions
          'comint-watch-for-password-prompt)
@end example

@item M-x comint-continue-subjob
@findex comint-continue-subjob
Continue the shell process.  This is useful if you accidentally suspend
the shell process.@footnote{You should not suspend the shell process.
Suspending a subjob of the shell is a completely different matter---that
is normal practice, but you must use the shell to continue the subjob;
this command won't do it.}

@item M-x comint-strip-ctrl-m
@findex comint-strip-ctrl-m
Discard all control-M characters from the current group of shell output.
The most convenient way to use this command is to make it run
automatically when you get output from the subshell.  To do that,
evaluate this Lisp expression:

@example
(add-hook 'comint-output-filter-functions
          'comint-strip-ctrl-m)
@end example

@item M-x comint-truncate-buffer
@findex comint-truncate-buffer
This command truncates the shell buffer to a certain maximum number of
lines, specified by the variable @code{comint-buffer-maximum-size}.
Here's how to do this automatically each time you get output from the
subshell:

@example
(add-hook 'comint-output-filter-functions
          'comint-truncate-buffer)
@end example
@end table

  Shell mode also customizes the paragraph commands so that only shell
prompts start new paragraphs.  Thus, a paragraph consists of an input
command plus the output that follows it in the buffer.

@cindex Comint mode
@cindex mode, Comint
  Shell mode is a derivative of Comint mode, a general-purpose mode for
communicating with interactive subprocesses.  Most of the features of
Shell mode actually come from Comint mode, as you can see from the
696 697
command names listed above.  The special features of Shell mode include
the directory tracking feature, and a few user commands.
Dave Love's avatar
#  
Dave Love committed
698 699 700 701 702 703 704 705 706 707 708 709 710

  Other Emacs features that use variants of Comint mode include GUD
(@pxref{Debuggers}) and @kbd{M-x run-lisp} (@pxref{External Lisp}).

@findex comint-run
  You can use @kbd{M-x comint-run} to execute any program of your choice
in a subprocess using unmodified Comint mode---without the
specializations of Shell mode.

@node Shell History
@subsection Shell Command History

  Shell buffers support three ways of repeating earlier commands.  You
711 712 713 714 715 716
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.
Dave Love's avatar
#  
Dave Love committed
717 718 719 720 721 722 723 724 725 726 727 728 729 730

@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
731
@itemx C-@key{UP}
Dave Love's avatar
#  
Dave Love committed
732 733 734 735 736
Fetch the next earlier old shell command.

@kindex M-n @r{(Shell mode)}
@findex comint-next-input
@item M-n
737
@itemx C-@key{DOWN}
Dave Love's avatar
#  
Dave Love committed
738 739 740 741 742 743 744 745 746 747
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}.

748 749
@item C-c C-x
@kindex C-c C-x @r{(Shell mode)}
Dave Love's avatar
#  
Dave Love committed
750 751
@findex comint-get-next-from-history
Fetch the next subsequent command from the history.
752

753 754
@item C-c .
@kindex C-c . @r{(Shell mode)}
755 756
@findex comint-input-previous-argument
Fetch one argument from an old shell command.
757 758 759 760 761 762

@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}).
Dave Love's avatar
#  
Dave Love committed
763 764 765 766 767 768 769 770
@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.

771 772 773 774 775 776 777
  @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}.
Dave Love's avatar
#  
Dave Love committed
778 779 780 781

  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}
Richard M. Stallman's avatar
Richard M. Stallman committed
782
and @kbd{M-n}.  If you enter an empty regexp, these commands reuse the
Dave Love's avatar
#  
Dave Love committed
783 784 785 786 787 788 789 790 791 792 793 794 795 796
same regexp used last time.

  When you find the previous input you want, you can resubmit it by
typing @key{RET}, or you can edit it first and then resubmit it if you
wish.

  Often it is useful to reexecute several successive shell commands that
were previously executed in sequence.  To do this, first find and
reexecute the first command of the sequence.  Then type @kbd{C-c C-x};
that will fetch the following command---the one that follows the command
you just repeated.  Then type @key{RET} to reexecute this command.  You
can reexecute several successive commands by typing @kbd{C-c C-x
@key{RET}} over and over.

797 798 799 800 801 802 803 804 805
  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).

Dave Love's avatar
#  
Dave Love committed
806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832
  These commands get the text of previous shell commands from a special
history list, not from the shell buffer itself.  Thus, editing the shell
buffer, or even killing large parts of it, does not affect the history
that these commands access.

@vindex shell-input-ring-file-name
  Some shells store their command histories in files so that you can
refer to previous commands from previous shell sessions.  Emacs reads
the command history file for your chosen shell, to initialize its own
command history.  The file name is @file{~/.bash_history} for bash,
@file{~/.sh_history} for ksh, and @file{~/.history} for other shells.

@node Shell History Copying
@subsubsection Shell History Copying

@table @kbd
@kindex C-c C-p @r{(Shell mode)}
@findex comint-previous-prompt
@item C-c C-p
Move point to the previous prompt (@code{comint-previous-prompt}).

@kindex C-c C-n @r{(Shell mode)}
@findex comint-next-prompt
@item C-c C-n
Move point to the following prompt (@code{comint-next-prompt}).

@kindex C-c RET @r{(Shell mode)}
833
@findex comint-insert-input
Dave Love's avatar
#  
Dave Love committed
834 835
@item C-c @key{RET}
Copy the input command which point is in, inserting the copy at the end
836
of the buffer (@code{comint-insert-input}).  This is useful if you
Dave Love's avatar
#  
Dave Love committed
837 838 839
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.
840 841 842 843

@item Mouse-2
Copy the input command that you click on, inserting the copy at the end
of the buffer.
Dave Love's avatar
#  
Dave Love committed
844 845 846
@end table

  Moving to a previous input and then copying it with @kbd{C-c
847 848 849 850 851 852
@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.
Dave Love's avatar
#  
Dave Love committed
853 854 855 856 857

@node History References
@subsubsection Shell History References
@cindex history reference

858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877
  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}.
Dave Love's avatar
#  
Dave Love committed
878 879 880

@vindex shell-prompt-pattern
@vindex comint-prompt-regexp
881 882
@vindex comint-use-prompt-regexp-instead-of-fields
@cindex prompt, shell
883 884 885 886 887 888 889 890 891 892 893 894 895
  Shell mode recognizes history references when they follow a prompt.
Normally, any text output by a program at the beginning of an input
line is considered a prompt.  However, if the variable
@code{comint-use-prompt-regexp-instead-of-fields} is non-@code{nil},
then Comint mode uses a regular expression to recognize prompts.  In
general, the variable @code{comint-prompt-regexp} specifies the
regular expression; Shell mode uses the variable
@code{shell-prompt-pattern} to set up @code{comint-prompt-regexp} in
the shell buffer.

@node Directory Tracking
@subsection Directory Tracking
@cindex directory tracking
Dave Love's avatar
#  
Dave Love committed
896

897 898 899 900 901 902 903 904
@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.
Dave Love's avatar
#  
Dave Love committed
905

906 907 908 909 910 911 912 913 914 915
  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.

916
@ignore  @c This seems to have been deleted long ago.
917 918 919 920
@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}).
921
@end ignore
922 923 924 925 926 927 928 929 930 931 932

@findex dirs
  If Emacs gets confused about changes in the current directory of the
subshell, use the command @kbd{M-x dirs} to ask the shell what its
current directory is.  This command works for shells that support the
most common command syntax; it may not work for unusual shells.

@findex dirtrack-mode
  You can also use @kbd{M-x dirtrack-mode} to enable (or disable) an
alternative and more aggressive method of tracking changes in the
current directory.
Dave Love's avatar
#  
Dave Love committed
933 934 935 936 937 938 939 940 941 942 943

@node Shell Options
@subsection Shell Mode Options

@vindex comint-scroll-to-bottom-on-input
  If the variable @code{comint-scroll-to-bottom-on-input} is
non-@code{nil}, insertion and yank commands scroll the selected window
to the bottom before inserting.

@vindex comint-scroll-show-maximum-output
  If @code{comint-scroll-show-maximum-output} is non-@code{nil}, then
944
arrival of output when point is at the end tries to place the last line of
945 946 947
text at the bottom line of the window, so as to show as much useful
text as possible.  (This mimics the scrolling behavior of many
terminals.)  The default is @code{nil}.
Dave Love's avatar
#  
Dave Love committed
948

949 950
@vindex comint-move-point-for-output
  By setting @code{comint-move-point-for-output}, you can opt for
Dave Love's avatar
#  
Dave Love committed
951 952 953
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
954
@code{all}, point jumps in each window that shows the Comint buffer.  If
Dave Love's avatar
#  
Dave Love committed
955 956 957 958
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.

959 960
@vindex comint-prompt-read-only
  If you set @code{comint-prompt-read-only}, the prompts in the Comint
961
buffer are read-only.
962

Dave Love's avatar
#  
Dave Love committed
963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982
@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.

983
@vindex shell-completion-execonly
Dave Love's avatar
#  
Dave Love committed
984
  Command completion normally considers only executable files.
985
If you set @code{shell-completion-execonly} to @code{nil},
Dave Love's avatar
#  
Dave Love committed
986 987 988 989 990 991 992 993 994 995 996 997 998
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.

999 1000 1001 1002 1003 1004 1005
  If you want Shell mode to handle color output from shell commands,
you can enable ANSI Color mode.  Here is how to do this:

@example
(add-hook 'shell-mode-hook 'ansi-color-for-comint-mode-on)
@end example

Dave Love's avatar
Dave Love committed
1006
@node Terminal emulator
1007
@subsection Emacs Terminal Emulator
Dave Love's avatar
Dave Love committed
1008 1009
@findex term

1010 1011
  To run a subshell in a terminal emulator, putting its typescript in
an Emacs buffer, use @kbd{M-x term}.  This creates (or reuses) a
1012 1013
buffer named @samp{*terminal*}, and runs a subshell with input coming
from your keyboard, and output going to that buffer.
1014 1015 1016

  The terminal emulator uses Term mode, which has two input modes.  In
line mode, Term basically acts like Shell mode; see @ref{Shell Mode}.
Dave Love's avatar
Dave Love committed
1017

1018 1019 1020 1021
  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}).
Dave Love's avatar
Dave Love committed
1022 1023 1024
Any ``terminal output'' from the subshell goes into the buffer,
advancing point.

1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036
  Some programs (such as Emacs itself) need to control the appearance
on the terminal screen in detail.  They do this by sending special
control codes.  The exact control codes needed vary from terminal to
terminal, but nowadays most terminals and terminal emulators
(including @code{xterm}) understand the ANSI-standard (VT100-style)
escape sequences.  Term mode recognizes these escape sequences, and
handles each one appropriately, changing the buffer so that the
appearance of the window matches what it would be on a real terminal.
You can actually run Emacs inside an Emacs Term window.

   The file name used to load the subshell is determined the same way
as for Shell mode.  To make multiple terminal emulators, rename the
1037
buffer @samp{*terminal*} to something different using @kbd{M-x
1038 1039 1040 1041 1042 1043
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.
Dave Love's avatar
Dave Love committed
1044 1045 1046 1047 1048 1049

@node Term Mode
@subsection Term Mode
@cindex Term mode
@cindex mode, Term

1050 1051 1052 1053 1054 1055
  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:
Dave Love's avatar
Dave Love committed
1056 1057

@table @kbd
1058
@kindex C-c C-j @r{(Term mode)}
Dave Love's avatar
Dave Love committed
1059
@findex term-char-mode
1060
@item C-c C-j
Dave Love's avatar
Dave Love committed
1061 1062
Switch to line mode.  Do nothing if already in line mode.

1063
@kindex C-c C-k @r{(Term mode)}
Dave Love's avatar
Dave Love committed
1064
@findex term-line-mode
1065
@item C-c C-k
Dave Love's avatar
Dave Love committed
1066 1067 1068
Switch to char mode.  Do nothing if already in char mode.
@end table

1069 1070
  The following commands are only available in char mode:

Dave Love's avatar
Dave Love committed
1071 1072 1073 1074
@table @kbd
@item C-c C-c
Send a literal @key{C-c} to the sub-shell.

1075 1076 1077 1078
@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}.
Dave Love's avatar
Dave Love committed
1079 1080 1081
@end table

@node Paging in Term
1082 1083
@subsection Page-At-A-Time Output
@cindex page-at-a-time
Dave Love's avatar
Dave Love committed
1084

1085 1086
  Term mode has a page-at-a-time feature.  When enabled it makes
output pause at the end of each screenful.
Dave Love's avatar
Dave Love committed
1087 1088 1089 1090 1091

@table @kbd
@kindex C-c C-q @r{(Term mode)}
@findex term-pager-toggle
@item C-c C-q
1092 1093 1094
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}.
Dave Love's avatar
Dave Love committed
1095 1096
@end table

1097 1098 1099 1100
  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
1101
interface is similar to the @code{more} program.
Dave Love's avatar
Dave Love committed
1102

Dave Love's avatar
#  
Dave Love committed
1103 1104 1105 1106 1107 1108 1109
@node Remote Host
@subsection Remote Host Shell
@cindex remote host
@cindex connecting to remote host
@cindex Telnet
@cindex Rlogin

Dave Love's avatar
Dave Love committed
1110 1111 1112 1113
  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.

1114 1115 1116 1117 1118 1119
  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.)
Dave Love's avatar
Dave Love committed
1120

1121
  When you log in to a different machine, you need to specify the type
1122
of terminal you're using.  Terminal types @samp{ansi} or @samp{vt100}
1123
will work on most systems.
Dave Love's avatar
Dave Love committed
1124 1125

@c   If you are talking to a Bourne-compatible
Gerd Moellmann's avatar
Gerd Moellmann committed
1126
@c shell, and your system understands the @env{TERMCAP} variable,
Dave Love's avatar
Dave Love committed
1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137
@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.

1138
@ignore
1139
  You cannot log in to a remote computer using the Shell mode.
Dave Love's avatar
Dave Love committed
1140 1141
@c (This will change when Shell is re-written to use Term.)
Instead, Emacs provides two commands for logging in to another computer
1142
and communicating with it through an Emacs buffer using Comint mode:
Dave Love's avatar
#  
Dave Love committed
1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185

@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.

1186 1187
@end ignore

Dave Love's avatar
#  
Dave Love committed
1188 1189 1190 1191 1192
@node Emacs Server, Hardcopy, Shell, Top
@section Using Emacs as a Server
@pindex emacsclient
@cindex Emacs as a server
@cindex server, using Emacs as
Gerd Moellmann's avatar
Gerd Moellmann committed
1193
@cindex @env{EDITOR} environment variable
Dave Love's avatar
#  
Dave Love committed
1194 1195 1196 1197

  Various programs such as @code{mail} can invoke your choice of editor
to edit a particular piece of text, such as a message that you are
sending.  By convention, most of these programs use the environment
Gerd Moellmann's avatar
Gerd Moellmann committed
1198 1199
variable @env{EDITOR} to specify which editor to run.  If you set
@env{EDITOR} to @samp{emacs}, they invoke Emacs---but in an
Dave Love's avatar
#  
Dave Love committed
1200 1201
inconvenient fashion, by starting a new, separate Emacs process.  This
is inconvenient because it takes time and because the new Emacs process
1202
doesn't share the buffers in any existing Emacs process.
Dave Love's avatar
#  
Dave Love committed
1203 1204 1205 1206 1207

  You can arrange to use your existing Emacs process as the editor for
programs like @code{mail} by using the Emacs client and Emacs server
programs.  Here is how.

Gerd Moellmann's avatar
Gerd Moellmann committed
1208
@cindex @env{TEXEDIT} environment variable
Dave Love's avatar
#  
Dave Love committed
1209 1210 1211
  First, the preparation.  Within Emacs, call the function
@code{server-start}.  (Your @file{.emacs} file can do this automatically
if you add the expression @code{(server-start)} to it.)  Then, outside
Gerd Moellmann's avatar
Gerd Moellmann committed
1212
Emacs, set the @env{EDITOR} environment variable to @samp{emacsclient}.
Dave Love's avatar
#  
Dave Love committed
1213 1214
(Note that some programs use a different environment variable; for
example, to make @TeX{} use @samp{emacsclient}, you should set the
Gerd Moellmann's avatar
Gerd Moellmann committed
1215
@env{TEXEDIT} environment variable to @samp{emacsclient +%d %s}.)
Dave Love's avatar
#  
Dave Love committed
1216 1217 1218

@kindex C-x #
@findex server-edit
Gerd Moellmann's avatar
Gerd Moellmann committed
1219
  Then, whenever any program invokes your specified @env{EDITOR}
Dave Love's avatar
#  
Dave Love committed
1220 1221 1222 1223 1224 1225 1226 1227
program, the effect is to send a message to your principal Emacs telling
it to visit a file.  (That's what the program @code{emacsclient} does.)
Emacs displays the buffer immediately and you can immediately begin
editing it.

  When you've finished editing that buffer, type @kbd{C-x #}
(@code{server-edit}).  This saves the file and sends a message back to
the @code{emacsclient} program telling it to exit.  The programs that
Gerd Moellmann's avatar
Gerd Moellmann committed
1228
use @env{EDITOR} wait for the ``editor'' (actually, @code{emacsclient})
Dave Love's avatar
#  
Dave Love committed
1229 1230 1231
to exit.  @kbd{C-x #} also checks for other pending external requests
to edit various files, and selects the next such file.

1232 1233
  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
1234
say that you are finished with one.
Dave Love's avatar
#  
Dave Love committed
1235

1236 1237 1238 1239 1240 1241 1242 1243 1244 1245
@vindex server-kill-new-buffers
@vindex server-temp-file-regexp
  Finishing with a server buffer also kills the buffer, unless it
already existed in the Emacs session before the server asked to create
it.  However, if you set @code{server-kill-new-buffers} to @code{nil},
then a different criterion is used: finishing with a server buffer
kills it if the file name matches the regular expression
@code{server-temp-file-regexp}.  This is set up to distinguish certain
``temporary'' files.

Dave Love's avatar
#  
Dave Love committed
1246 1247 1248 1249
@vindex server-window
  If you set the variable @code{server-window} to a window or a frame,
@kbd{C-x #} displays the server buffer in that window or in that frame.

1250 1251 1252 1253 1254 1255 1256 1257
@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 RET
server-name RET foo} sets the server name to @samp{foo}.  The
@code{emacsclient} program can visit a server by name using the
@samp{-s} option.

Dave Love's avatar
#  
Dave Love committed
1258 1259 1260 1261 1262
  While @code{mail} or another application is waiting for
@code{emacsclient} to finish, @code{emacsclient} does not read terminal
input.  So the terminal that @code{mail} was using is effectively
blocked for the duration.  In order to edit with your principal Emacs,
you need to be able to use it without using that terminal.  There are
1263
three ways to do this:
Dave Love's avatar
#  
Dave Love committed
1264 1265 1266 1267 1268 1269 1270 1271 1272

@itemize @bullet
@item
Using a window system, run @code{mail} and the principal Emacs in two
separate windows.  While @code{mail} is waiting for @code{emacsclient},
the window where it was running is blocked, but you can use Emacs by
switching windows.

@item
1273 1274
Using virtual terminals, run @code{mail} in one virtual terminal
and run Emacs in another.
Dave Love's avatar
#  
Dave Love committed
1275

1276 1277 1278 1279 1280
@item
Use Shell mode or Term mode in Emacs to run the other program such as
@code{mail}; then, @code{emacsclient} blocks only the subshell under
Emacs, and you can still use Emacs to edit the file.
@end itemize
1281

Dave Love's avatar
#  
Dave Love committed
1282
  If you run @code{emacsclient} with the option @samp{--no-wait}, it
1283 1284 1285
returns immediately without waiting for you to ``finish'' the buffer
in Emacs.  Note that server buffers created in this way are not killed
automatically when you finish with them.
Dave Love's avatar
Dave Love committed
1286

Dave Love's avatar
#  
Dave Love committed
1287 1288 1289 1290 1291
@menu
* Invoking emacsclient::
@end menu

@node Invoking emacsclient,, Emacs Server, Emacs Server
1292
@subsection Invoking @code{emacsclient}
Dave Love's avatar
#  
Dave Love committed
1293 1294 1295 1296 1297

  To run the @code{emacsclient} program, specify file names as arguments,
and optionally line numbers as well.  Do it like this:

@example
1298
emacsclient @r{@{}@r{[}+@var{line}@r{[}@var{column}@r{]}@r{]} @var{filename}@r{@}}@dots{}
Dave Love's avatar
#  
Dave Love committed
1299 1300
@end example

1301
@noindent
Dave Love's avatar
#  
Dave Love committed
1302 1303
This tells Emacs to visit each of the specified files; if you specify a
line number for a certain file, Emacs moves to that line in the file.
Richard M. Stallman's avatar
Richard M. Stallman committed
1304 1305
If you specify a column number as well, Emacs puts point on that column
in the line.
Dave Love's avatar
#  
Dave Love committed
1306

1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319
  Ordinarily, @code{emacsclient} does not return until you use the
@kbd{C-x #} command on each of these buffers.  When that happens,
Emacs sends a message to the @code{emacsclient} program telling it to
return.

  But if you use the option @samp{-n} or @samp{--no-wait} when running
@code{emacsclient}, then it returns immediately.  (You can take as
long as you like to edit the files in Emacs.)

  The option @samp{--alternate-editor=@var{command}} is useful when
running @code{emacsclient} in a script.  It specifies a command to run
if @code{emacsclient} fails to contact Emacs.  For example, the
following setting for the @var{EDITOR} environment variable will
1320
always give you an editor, even if no Emacs server is running:
Dave Love's avatar
#  
Dave Love committed
1321

1322
@example
1323
EDITOR="emacsclient --alternate-editor emacs +%d %s"
1324
@end example
Dave Love's avatar
#  
Dave Love committed
1325

1326 1327 1328 1329 1330 1331 1332 1333
@noindent
The environment variable @var{ALTERNATE_EDITOR} has the same effect, but
the value of the @samp{--alternate-editor} takes precedence.

@pindex emacs.bash
  Alternatively, the file @file{etc/emacs.bash} defines a bash
function which will communicate with a running Emacs server, or start
one if none exists.
Dave Love's avatar
#  
Dave Love committed
1334

1335 1336 1337 1338 1339
If you use several displays, you can tell Emacs on which display to
open the given files with the option @samp{--display=@var{DISPLAY}}.
This can be used typically when connecting from home to an Emacs
server running on your machine at your workplace.

1340 1341 1342
If there is more than one Emacs server running, you can specify a
server name with the option @samp{-s @var{name}}.

1343 1344 1345 1346 1347
You can also use @code{emacsclient} to execute any piece of Emacs Lisp
code, using the option @samp{--eval}.  When this option is given, the
rest of the arguments is not taken as a list of files to visit but as
a list of expressions to evaluate.

Dave Love's avatar
Dave Love committed
1348
@node Hardcopy, PostScript, Emacs Server, Top
Dave Love's avatar
#  
Dave Love committed
1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401
@section Hardcopy Output
@cindex hardcopy

  The Emacs commands for making hardcopy let you print either an entire
buffer or just part of one, either with or without page headers.
See also the hardcopy commands of Dired (@pxref{Misc File Ops})
and the diary (@pxref{Diary Commands}).

@table @kbd
@item M-x print-buffer
Print hardcopy of current buffer with page headings containing the file
name and page number.
@item M-x lpr-buffer
Print hardcopy of current buffer without page headings.
@item M-x print-region
Like @code{print-buffer} but print only the current region.
@item M-x lpr-region
Like @code{lpr-buffer} but print only the current region.
@end table

@findex print-buffer
@findex print-region
@findex lpr-buffer
@findex lpr-region
@vindex lpr-switches
  The hardcopy commands (aside from the Postscript commands) pass extra
switches to the @code{lpr} program based on the value of the variable
@code{lpr-switches}.  Its value should be a list of strings, each string
an option starting with @samp{-}.  For example, to specify a line width
of 80 columns for all the printing you do in Emacs, set
@code{lpr-switches} like this:

@example
(setq lpr-switches '("-w80"))
@end example

@vindex printer-name
  You can specify the printer to use by setting the variable
@code{printer-name}.

@vindex lpr-headers-switches
@vindex lpr-commands
@vindex lpr-add-switches
  The variable @code{lpr-command} specifies the name of the printer
program to run; the default value depends on your operating system type.
On most systems, the default is @code{"lpr"}.  The variable
@code{lpr-headers-switches} similarly specifies the extra switches to
use to make page headers.  The variable @code{lpr-add-switches} controls
whether to supply @samp{-T} and @samp{-J} options (suitable for
@code{lpr}) to the printer program: @code{nil} means don't add them.
@code{lpr-add-switches} should be @code{nil} if your printer program is
not compatible with @code{lpr}.

Dave Love's avatar
Dave Love committed
1402 1403
@node PostScript, PostScript Variables, Hardcopy, Top
@section PostScript Hardcopy
Dave Love's avatar
#  
Dave Love committed
1404

Dave Love's avatar
Dave Love committed
1405
  These commands convert buffer contents to PostScript,
Dave Love's avatar
#  
Dave Love committed
1406 1407 1408 1409
either printing it or leaving it in another Emacs buffer.

@table @kbd
@item M-x ps-print-buffer
Dave Love's avatar
Dave Love committed
1410
Print hardcopy of the current buffer in PostScript form.
Dave Love's avatar
#  
Dave Love committed
1411
@item M-x ps-print-region
Dave Love's avatar
Dave Love committed
1412
Print hardcopy of the current region in PostScript form.
Dave Love's avatar
#  
Dave Love committed
1413
@item M-x ps-print-buffer-with-faces
Dave Love's avatar
Dave Love committed
1414 1415
Print hardcopy of the current buffer in PostScript form, showing the
faces used in the text by means of PostScript features.
Dave Love's avatar
#  
Dave Love committed
1416
@item M-x ps-print-region-with-faces
Dave Love's avatar
Dave Love committed
1417
Print hardcopy of the current region in PostScript form, showing the
Dave Love's avatar
#  
Dave Love committed
1418 1419
faces used in the text.
@item M-x ps-spool-buffer
Dave Love's avatar
Dave Love committed
1420
Generate PostScript for the current buffer text.
Dave Love's avatar
#  
Dave Love committed
1421
@item M-x ps-spool-region
Dave Love's avatar
Dave Love committed
1422
Generate PostScript for the current region.
Dave Love's avatar
#  
Dave Love committed
1423
@item M-x ps-spool-buffer-with-faces
Dave Love's avatar
Dave Love committed
1424
Generate PostScript for the current buffer, showing the faces used.
Dave Love's avatar
#  
Dave Love committed
1425
@item M-x ps-spool-region-with-faces
Dave Love's avatar
Dave Love committed
1426 1427 1428
Generate PostScript for the current region, showing the faces used.
@item M-x handwrite
Generates/prints PostScript for the current buffer as if handwritten.
Dave Love's avatar
#  
Dave Love committed
1429 1430 1431 1432 1433 1434
@end table

@findex ps-print-region
@findex ps-print-buffer
@findex ps-print-region-with-faces
@findex ps-print-buffer-with-faces
Dave Love's avatar
Dave Love committed
1435 1436
  The PostScript commands, @code{ps-print-buffer} and
@code{ps-print-region}, print buffer contents in PostScript form.  One
Dave Love's avatar
#  
Dave Love committed
1437 1438 1439
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},
Dave Love's avatar
Dave Love committed
1440
use PostScript features to show the faces (fonts and colors) in the text
Dave Love's avatar
#  
Dave Love committed
1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451
properties of the text being printed.

  If you are using a color display, you can print a buffer of program
code with color highlighting by turning on Font-Lock mode in that
buffer, and using @code{ps-print-buffer-with-faces}.

@findex ps-spool-region
@findex ps-spool-buffer
@findex ps-spool-region-with-faces
@findex ps-spool-buffer-with-faces
  The commands whose names have @samp{spool} instead of @samp{print}
Dave Love's avatar
Dave Love committed
1452
generate the PostScript output in an Emacs buffer instead of sending
Dave Love's avatar
#  
Dave Love committed
1453 1454
it to the printer.

Dave Love's avatar
Dave Love committed
1455 1456 1457 1458
@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
1459 1460
can be customized in group @code{handwrite}.  This function only
supports ISO 8859-1 characters.
Dave Love's avatar
Dave Love committed
1461

Dave Love's avatar
#  
Dave Love committed
1462 1463 1464 1465
@ifinfo
  The following section describes variables for customizing these commands.
@end ifinfo

Dave Love's avatar
Dave Love committed
1466 1467
@node PostScript Variables, Sorting, PostScript, Top
@section Variables for PostScript Hardcopy
Dave Love's avatar
#  
Dave Love committed
1468 1469 1470 1471

@vindex ps-lpr-command
@vindex ps-lpr-switches
@vindex ps-printer-name
Dave Love's avatar
Dave Love committed
1472
  All the PostScript hardcopy commands use the variables
Dave Love's avatar
#  
Dave Love committed
1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483
@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
1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495
off.

@cindex color emulation on black-and-white printers
@vindex ps-print-color-p
  If your printer doesn't support colors, you should turn off color
processing by setting @code{ps-print-color-p} to @code{nil}.  By
default, if the display supports colors, Emacs produces hardcopy output
with color information; on black-and-white printers, colors are emulated
with shades of gray.  This might produce illegible output, even if your
screen colors only use shades of gray.

@vindex ps-use-face-background
1496 1497 1498 1499
  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.
Dave Love's avatar
#  
Dave Love committed
1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530

@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.

1531 1532 1533 1534 1535 1536 1537 1538 1539