the buffer as output is inserted. (However, if the coding system chosen
for decoding output is @code{undecided}, meaning deduce the encoding
from the actual data, then redisplay sometimes cannot continue once
-non-@sc{ascii} characters are encountered. There are fundamental
+non-@acronym{ASCII} characters are encountered. There are fundamental
reasons why it is hard to fix this; see @ref{Output from Processes}.)
Otherwise the function @code{call-process} does no redisplay, and the
@defun call-process-shell-command command &optional infile destination display &rest args
This function executes the shell command @var{command} synchronously
-in separate process. The final arguments @var{args} are additional
+in a separate process. The final arguments @var{args} are additional
arguments to add at the end of @var{command}. The other arguments
are handled as in @code{call-process}.
@end defun
@defvar process-connection-type
@cindex pipes
-@cindex @sc{pty}s
+@cindex @acronym{PTY}s
This variable controls the type of device used to communicate with
-asynchronous subprocesses. If it is non-@code{nil}, then @sc{pty}s are
+asynchronous subprocesses. If it is non-@code{nil}, then @acronym{PTY}s are
used, when available. Otherwise, pipes are used.
-@sc{pty}s are usually preferable for processes visible to the user, as
+@acronym{PTY}s are usually preferable for processes visible to the user, as
in Shell mode, because they allow job control (@kbd{C-c}, @kbd{C-z},
etc.) to work between the process and its children, whereas pipes do
not. For subprocesses used for internal purposes by programs, it is
often better to use a pipe, because they are more efficient. In
-addition, the total number of @sc{pty}s is limited on many systems and
+addition, the total number of @acronym{PTY}s is limited on many systems and
it is good not to waste them.
The value of @code{process-connection-type} takes effect when
@end smallexample
To determine whether a given subprocess actually got a pipe or a
-@sc{pty}, use the function @code{process-tty-name} (@pxref{Process
+@acronym{PTY}, use the function @code{process-tty-name} (@pxref{Process
Information}).
@end defvar
@end defun
@defun process-id process
-This function returns the @sc{pid} of @var{process}. This is an
+This function returns the @acronym{PID} of @var{process}. This is an
integer that distinguishes the process @var{process} from all other
processes running on the same computer at the current time. The
-@sc{pid} of a process is chosen by the operating system kernel when the
+@acronym{PID} of a process is chosen by the operating system kernel when the
process is started and remains constant as long as the process exists.
@end defun
@end defun
@defun process-coding-system process
+@anchor{Coding systems for a subprocess}
This function returns a cons cell describing the coding systems in use
for decoding output from @var{process} and for encoding input to
@var{process} (@pxref{Coding Systems}). The value has this form:
data appears on the ``standard input'' of the subprocess.
Some operating systems have limited space for buffered input in a
-@sc{pty}. On these systems, Emacs sends an @sc{eof} periodically amidst
+@acronym{PTY}. On these systems, Emacs sends an @acronym{EOF} periodically amidst
the other characters, to force them through. For most programs,
-these @sc{eof}s do no harm.
+these @acronym{EOF}s do no harm.
Subprocess input is normally encoded using a coding system before the
subprocess receives it, much like text written into a file. You can use
@defun process-send-eof &optional process-name
This function makes @var{process-name} see an end-of-file in its
-input. The @sc{eof} comes after any text already sent to it.
+input. The @acronym{EOF} comes after any text already sent to it.
If @var{process-name} is not supplied, or if it is @code{nil}, then
-this function sends the @sc{eof} to the current buffer's process. An
+this function sends the @acronym{EOF} to the current buffer's process. An
error is signaled if the current buffer has no process.
The function returns @var{process-name}.
This function sends a signal to process @var{process}. The argument
@var{signal} specifies which signal to send; it should be an integer.
-You can specify the target process by its process @sc{id}; that allows
+You can specify the target process by its process @acronym{ID}; that allows
you to send signals to processes that are not children of Emacs.
@end defun
can arrive before you finish, if the code in between does not call any
primitive that waits.
+@defvar process-adaptive-read-buffering
+On some systems, when Emacs reads the output from a subprocess, the
+output data is read in very small blocks, potentially resulting in
+very poor performance. This behaviour can be remedied to some extent
+by setting the variable @var{process-adaptive-read-buffering} to a
+non-nil value (the default), as it will automatically delay reading
+from such processes, thus allowing them to produce more output before
+Emacs tries to read it.
+@end defvar
+
It is impossible to separate the standard output and standard error
streams of the subprocess, because Emacs normally spawns the subprocess
inside a pseudo-TTY, and a pseudo-TTY has only one output channel. If
you want to keep the output to those streams separate, you should
-redirect one of them to a file--for example, by using an appropriate
+redirect one of them to a file---for example, by using an appropriate
shell command.
@menu
explicitly permit output to arrive at a specific point, or even to wait
until output arrives from a process.
-@defun accept-process-output &optional process seconds millisec
+@defun accept-process-output &optional process seconds millisec just-this-one
This function allows Emacs to read pending output from processes. The
output is inserted in the associated buffers or given to their filter
functions. If @var{process} is non-@code{nil} then this function does
of a second; on those that do not, you get an error if you specify
nonzero @var{millisec}.
+@c Emacs 21.4 feature
+If @var{process} is a process, and the argument @var{just-this-one} is
+non-nil, only output from that process is handled, suspending output
+from other processes until some output has been received from that
+process or the timeout expires. If @var{just-this-one} is an integer,
+also inhibit running timers. This feature is generally not
+recommended, but may be necessary for specific applications, such as
+speech synthesis.
+
The function @code{accept-process-output} returns non-@code{nil} if it
did get some output, or @code{nil} if the timeout expired before output
arrived.
@section Network Connections
@cindex network connection
@cindex TCP
+@cindex UDP
- Emacs Lisp programs can open TCP and datagram network connections to
-other processes on the same machine or other machines. A network
-connection is handled by Lisp much like a subprocess, and is
+ Emacs Lisp programs can open stream (TCP) and datagram (UDP) network
+connections to other processes on the same machine or other machines.
+A network connection is handled by Lisp much like a subprocess, and is
represented by a process object. However, the process you are
communicating with is not a child of the Emacs process, so it has no
-process @sc{id}, and you can't kill it or send it signals. All you
+process @acronym{ID}, and you can't kill it or send it signals. All you
can do is send and receive data. @code{delete-process} closes the
connection, but does not kill the program at the other end; that
program must decide what to do about closure of the connection.
the process plist, from the server.) The network server then goes
back to listening for more connection requests.
+ Network connections and servers are created by calling
+@code{make-network-process} with an argument list consisting of
+keyword/argument pairs, for example @code{:server t} to create a
+server process, or @code{:type 'datagram} to create a datagram
+connection. @xref{Low-Level Network}, for details. You can also use
+one of the @code{open-network-...} functions descibed below;
+internally, they just call @code{make-network-process} with suitable
+arguments.
+
You can distinguish process objects representing network connections
and servers from those representing subprocesses with the
@code{process-status} function. The possible status values for
@code{listen}. None of those values is possible for a real
subprocess. @xref{Process Information}.
- You can stop and resume operation of a network processes by calling
+ You can stop and resume operation of a network process by calling
@code{stop-process} and @code{continue-process}. For a server
process, being stopped means not accepting new connections. (Up to 5
-connection requests will be queued for when you resume the server;
-this limit is imposed by the operating system.) For a network
-connection, being stopped means not processing input (any arriving
-input waits until you resume the connection). You can use the
-function @code{process-command} to determine whether a network
-connection or server is stopped; a non-@code{nil} value means yes.
+connection requests will be queued for when you resume the server; you
+can increase this limit, unless it is imposed by the operating
+systems.) For a network stream connection, being stopped means not
+processing input (any arriving input waits until you resume the
+connection). For a datagram connection, some number of packets may be
+queued but input may be lost. You can use the function
+@code{process-command} to determine whether a network connection or
+server is stopped; a non-@code{nil} value means yes.
@defun open-network-stream name buffer-or-name host service
This function opens a TCP connection, and returns a process object
@item :filter
The associated value is the process filter function.
@item :sentinel
-The associated value is the process filter function.
+The associated value is the process sentinel function.
@item :remote
In a connection, this is the address in internal format of the remote peer.
@item :local
server process' @var{name} with a client identification string. The
client identification string for an IPv4 connection looks like
@samp{<@var{a}.@var{b}.@var{c}.@var{d}:@var{p}>}. Otherwise, it is a
-unique number in brackets, as in @samp{<@var{nnn>}}. The number
+unique number in brackets, as in @samp{<@var{nnn}>}. The number
is unique for each connection in the Emacs session.
@item
If the server's filter is non-@code{nil}, the connection process does
-not get a separate process buffer; otherwise, Emacs creates a bew
+not get a separate process buffer; otherwise, Emacs creates a new
buffer for the purpose. The buffer name is the server's buffer name
or process name, concatenated with the client identification string.
@defun open-network-stream-server name buffer-or-name service &optional sentinel filter
Create a network server process for a TCP service.
-It returns nil if server processes are not supported; otherwise,
+It returns @code{nil} if server processes are not supported; otherwise,
it returns a subprocess-object to represent the server.
When a client connects to the specified service, Emacs creates a new
@end defun
@node Datagrams
-@section Datagrams
+@section Datagrams
@cindex datagrams
- A datagram connection communicates with individual packets
-rather than streams of data. Each call to @code{process-send}
-sends one datagram packet, and each datagram received results
-in one call to the filter function.
+ A datagram connection communicates with individual packets rather
+than streams of data. Each call to @code{process-send} sends one
+datagram packet (@pxref{Input to Processes}), and each datagram
+received results in one call to the filter function.
The datagram connection doesn't have to talk with the same remote
peer all the time. It has a @dfn{remote peer address} which specifies
process object that represents it. The arguments @var{args} are a
list of keyword/argument pairs. Omitting a keyword is always
equivalent to specifying it with value @code{nil}, except for
-@code{:coding} and @code{:filter-multibyte}. Here are the meaningful
-keywords:
+@code{:coding}, @code{:filter-multibyte}, and @code{:reuseaddr}. Here
+are the meaningful keywords:
@table @asis
@item :name name
@item :server @var{server-flag}
If @var{server-flag} is non-@code{nil}, create a server. Otherwise,
-create a connection.
+create a connection. For a stream type server, @var{server-flag} may
+be an integer which then specifies the length of the queue of pending
+connections to the server. The default queue length is 5.
@item :host @var{host}
Specify the host to connect to. @var{host} should be a host name or
@item
An ``unsupported family'' address is represented by a cons
@code{(@var{f} . @var{av})}, where @var{f} is the family number and
-@var{av} is a vector specifying the socket address using with one
-element per address data byte. Do not rely on this format in portable
-code, as it may depend on implementation defined constants, data
-sizes, and data structure alignment.
+@var{av} is a vector specifying the socket address using one element
+per address data byte. Do not rely on this format in portable code,
+as it may depend on implementation defined constants, data sizes, and
+data structure alignment.
@end itemize
@item :nowait @var{bool}
@var{encoding})} for @var{coding}.
If you don't specify this keyword at all, the default
-is to determine the coding systemx from the data.
-
-@item :options @var{options}
-Set the specified options for the network process. See
-@code{set-network-process-options} for details.
+is to determine the coding systems from the data.
@item :noquery @var{query-flag}
-Initialize the process query flag to @var{query-flag}.
+Initialize the process query flag to @var{query-flag}. @xref{Query Before Exit}.
@item :filter @var{filter}
Initialize the process filter to @var{filter}.
Initialize the process plist to @var{plist}.
@end table
+The following network options can be specified for the network
+process. Except for @code{:reuseaddr}, you can set or modify these
+options later using @code{set-network-process-option}.
+
+For a server process, the options specified with
+@code{make-network-process} are not inherited by the client
+connections, so you will need to set the necessary options for each
+child connection as they are created.
+
+@table @asis
+@item :bindtodevice @var{device-name}
+If @var{device-name} is a non-empty string identifying a network
+interface name (see @code{network-interface-list}), only handle
+packets received on that interface. If @var{device-name} is @code{nil}
+(the default), handle packets received on any interface.
+
+Using this option may require special privileges on some systems.
+
+@item :broadcast @var{broadcast-flag}
+If @var{broadcast-flag} is non-@code{nil} for a datagram process, the
+process will receive datagram packet sent to a broadcast address, and
+be able to send packets to a broadcast address. Ignored for a stream
+connection.
+
+@item :dontroute @var{dontroute-flag}
+If @var{dontroute-flag} is non-@code{nil}, the process can only send
+to hosts on the same network as the local host.
+
+@item :keepalive @var{keepalive-flag}
+If @var{keepalive-flag} is non-@code{nil} for a stream connection,
+enable exchange of low-level keep-alive messages.
+
+@item :linger @var{linger-arg}
+If @var{linger-arg} is non-@code{nil}, wait for successful
+transmission of all queued packets on the connection before it is
+deleted (see @code{delete-process}). If @var{linger-arg} is an
+integer, it specifies the maximum time in seconds to wait for queued
+packets to be sent before closing the connection. Default is
+@code{nil} which means to discard unsent queued packets when the
+process is deleted.
+
+@item :oobinline @var{oobinline-flag}
+If @var{oobinline-flag} is non-@code{nil} for a stream connection,
+receive out-of-band data in the normal data stream. Otherwise, ignore
+out-of-band data.
+
+@item :priority @var{priority}
+Set the priority for packets sent on this connection to the integer
+@var{priority}. The interpretation of this number is protocol
+specific, such as setting the TOS (type of service) field on IP
+packets sent on this connection. It may also have system dependent
+effects, such as selecting a specific output queue on the network
+interface.
+
+@item :reuseaddr @var{reuseaddr-flag}
+If @var{reuseaddr-flag} is non-@code{nil} (the default) for a stream
+server process, allow this server to reuse a specific port number (see
+@code{:service}) unless another process on this host is already
+listening on that port. If @var{reuseaddr-flag} is @code{nil}, there
+may be a period of time after the last use of that port (by any
+process on the host), where it is not possible to make a new server on
+that port.
+
+@end table
+
The original argument list, modified with the actual connection
-information, is available via the `process-contact' function.
+information, is available via the @code{process-contact} function.
+@end defun
+
+@defun set-network-process-option process option value
+This function sets or modifies a network option for network process
+@var{process}. See @code{make-network-process} for details of options
+@var{option} and their corresponding values @var{value}.
+
+The current setting of an option is available via the
+@code{process-contact} function.
@end defun
@defun network-interface-list
@end defun
@defun format-network-address address &optional omit-port
-This function converts the lisp representation of a network address to
+This function converts the Lisp representation of a network address to
a string. For example, a five-element vector @code{[@var{a} @var{b}
@var{c} @var{d} @var{p}]} represents an IP address
@var{a}.@var{b}.@var{c}.@var{d} and port number @var{p}.
@example
(featurep 'make-network-process '(@var{keyword} @var{value}))
-@end example
+@end example
@noindent
-The result is @code{t} if it works to specify @var{keyword} with value
-@var{value} in @code{make-network-process}. Here are some of the
-@var{keyword}---@var{value} pairs you can test in this way.
+The result of the first form is @code{t} if it works to specify
+@var{keyword} with value @var{value} in @code{make-network-process}.
+The result of the second form is @code{t} if @var{keyword} is
+supported by @code{make-network-process}. Here are some of the
+@var{keyword}---@var{value} pairs you can test in
+this way.
@table @code
@item (:nowait t)
Non-@code{nil} if local (aka ``UNIX domain'') sockets are supported.
@item (:service t)
Non-@code{nil} if the system can select the port for a server.
-@item (:options bindtodevice)
-@itemx (:options broadcast)
-@itemx (:options dontroute)
-@itemx (:options keepalive)
-@itemx (:options linger)
-@itemx (:options oobinline)
-@itemx (:options priority)
-@itemx (:options reuseaddr)
-That particular socket option is supported.
+@end table
+
+ To test for the availability of a given network option, use
+@code{featurep} like this:
+
+@example
+(featurep 'make-network-process '@var{keyword})
+@end example
+
+Here are some of the option @var{keyword}s you can test in
+this way.
+
+@table @code
+@item :bindtodevice
+@itemx :broadcast
+@itemx :dontroute
+@itemx :keepalive
+@itemx :linger
+@itemx :oobinline
+@itemx :priority
+@itemx :reuseaddr
+That particular network option is supported by
+@code{make-network-process} and @code{set-network-process-option}.
@end table
@ignore