GNU Info
(emacs)Shell Mode
Shell Mode
----------
Shell buffers use Shell mode, which defines several special keys
attached to the `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 `C-c' first. Here is a complete list
of the special key bindings of Shell mode:
`<RET>'
At end of buffer send line as input; otherwise, copy current line
to end of buffer and send it (`comint-send-input'). When a line is
copied, any prompt at the beginning of the line (text output by
programs preceding your input) is omitted. (See also the variable
`comint-use-prompt-regexp-instead-of-fields'.)
`<TAB>'
Complete the command name or file name before point in the shell
buffer (`comint-dynamic-complete'). <TAB> also completes history
references (Note: History References) and environment variable
names.
The variable `shell-completion-fignore' specifies a list of file
name extensions to ignore in Shell mode completion. The default
setting is `nil', but some users prefer `("~" "#" "%")' to ignore
file names ending in `~', `#' or `%'. Other related Comint modes
use the variable `comint-completion-fignore' instead.
`M-?'
Display temporarily a list of the possible completions of the file
name before point in the shell buffer
(`comint-dynamic-list-filename-completions').
`C-d'
Either delete a character or send EOF
(`comint-delchar-or-maybe-eof'). Typed at the end of the shell
buffer, `C-d' sends EOF to the subshell. Typed at any other
position in the buffer, `C-d' deletes a character as usual.
`C-c C-a'
Move to the beginning of the line, but after the prompt if any
(`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 `C-c <SPC>' the process mark may be in a
previous line.)
`C-c <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 <RET>.
`C-c C-u'
Kill all text pending at end of buffer to be sent as input
(`comint-kill-input').
`C-c C-w'
Kill a word before point (`backward-kill-word').
`C-c C-c'
Interrupt the shell or its current subjob if any
(`comint-interrupt-subjob'). This command also kills any shell
input pending in the shell buffer and not yet sent.
`C-c C-z'
Stop the shell or its current subjob if any (`comint-stop-subjob').
This command also kills any shell input pending in the shell
buffer and not yet sent.
`C-c C-\'
Send quit signal to the shell or its current subjob if any
(`comint-quit-subjob'). This command also kills any shell input
pending in the shell buffer and not yet sent.
`C-c C-o'
Delete the last batch of output from a shell command
(`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 `comint-kill-output'.
`C-c C-s'
Write the last batch of output from a shell command to a file
(`comint-write-output'). With a prefix argument, the file is
appended to instead. Any prompt at the end of the output is not
written.
`C-c C-r'
`C-M-l'
Scroll to display the beginning of the last batch of output at the
top of the window; also move the cursor there
(`comint-show-output').
`C-c C-e'
Scroll to put the end of the buffer at the bottom of the window
(`comint-show-maximum-output').
`C-c C-f'
Move forward across one shell command, but not beyond the current
line (`shell-forward-command'). The variable
`shell-command-regexp' specifies how to recognize the end of a
command.
`C-c C-b'
Move backward across one shell command, but not beyond the current
line (`shell-backward-command').
`C-c C-l'
Display the buffer's history of shell commands in another window
(`comint-dynamic-list-input-ring').
`M-x dirs'
Ask the shell what its current directory is, so that Emacs can
agree with the shell.
`M-x send-invisible <RET> TEXT <RET>'
Send 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:
(add-hook 'comint-output-filter-functions
'comint-watch-for-password-prompt)
`M-x comint-continue-subjob'
Continue the shell process. This is useful if you accidentally
suspend the shell process.(1)
`M-x 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:
(add-hook 'comint-output-filter-functions
'comint-strip-ctrl-m)
`M-x comint-truncate-buffer'
This command truncates the shell buffer to a certain maximum
number of lines, specified by the variable
`comint-buffer-maximum-size'. Here's how to do this automatically
each time you get output from the subshell:
(add-hook 'comint-output-filter-functions
'comint-truncate-buffer)
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.
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
(Note: Debuggers) and `M-x run-lisp' (Note: External Lisp).
You can use `M-x comint-run' to execute any program of your choice
in a subprocess using unmodified Comint mode--without the
specializations of Shell mode.
---------- Footnotes ----------
(1) 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.
automatically generated by info2www version 1.2.2.9