Go to the previous, next section.
Sending a signal to a subprocess is a way of interrupting its
activities. There are several different signals, each with its own
meaning. For example, the signal SIGINT means that the user
has typed C-c, or that some analogous thing has happened.
Each signal has a standard effect on the subprocess. Most signals kill the subprocess, but some stop or resume execution instead. Most signals can optionally be handled by programs; if the program handles the signal, then we can say nothing in general about its effects.
The set of signals and their names is defined by the operating system; Emacs has facilities for sending only a few of the signals that are defined. Emacs can send signals only to its own subprocesses.
You can send signals explicitly by calling the functions in this
section. Emacs also sends signals automatically at certain times:
killing a buffer sends a SIGHUP signal to all its associated
processes; killing Emacs sends a SIGHUP signal to all remaining
processes. (SIGHUP is a signal that usually indicates that the
user hung up the phone.)
Each of the signal-sending functions takes two optional arguments: process-name and current-group.
The argument process-name must be either a process, the name of
one, or nil. If it is nil, the process defaults to the
process associated with the current buffer. An error is signaled if
process-name does not identify a process.
The argument current-group is a flag that makes a difference
when you are running a job-control shell as an Emacs subprocess. If it
is non-nil, then the signal is sent to the current process-group
of the terminal which Emacs uses to communicate with the subprocess. If
the process is a job-control shell, this means the shell's current
subjob. If it is nil, the signal is sent to the process group of
the immediate subprocess of Emacs. If the subprocess is a job-control
shell, this is the shell itself.
The flag current-group has no effect when a pipe is used to
communicate with the subprocess, because the operating system does not
support the distinction in the case of pipes. For the same reason,
job-control shells won't work when a pipe is used. See
process-connection-type in section Creating an Asynchronous Process.
Function: interrupt-process &optional process-name current-group
This function interrupts the process process-name by sending the
signal SIGINT. Outside of Emacs, typing the "interrupt
character" (normally C-c on some systems, and DEL on
others) sends this signal. When the argument current-group is
non-nil, you can think of this function as "typing C-c"
on the terminal by which Emacs talks to the subprocess.
Function: kill-process &optional process-name current-group
This function kills the process process-name by sending the
signal SIGKILL. This signal kills the subprocess immediately,
and cannot be handled by the subprocess.
Function: quit-process &optional process-name current-group
This function sends the signal SIGQUIT to the process
process-name. This signal is the one sent by the "quit
character" (usually C-b or C-\) when you are not inside
Emacs.
Function: stop-process &optional process-name current-group
This function stops the process process-name by sending the
signal SIGTSTP. Use continue-process to resume its
execution.
On systems with job control, the "stop character" (usually C-z)
sends this signal (outside of Emacs). When current-group is
non-nil, you can think of this function as "typing C-z"
on the terminal Emacs uses to communicate with the subprocess.
Function: continue-process &optional process-name current-group
This function resumes execution of the process process by sending
it the signal SIGCONT. This presumes that process-name was
stopped previously.
Function: signal-process pid signal
This function sends a signal to process pid, which need not be a child of Emacs. The argument signal specifies which signal to send; it should be an integer.
Go to the previous, next section.