emacs-diffs
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Emacs-diffs] Changes to emacs/lispref/processes.texi


From: Eli Zaretskii
Subject: [Emacs-diffs] Changes to emacs/lispref/processes.texi
Date: Sun, 02 Nov 2003 01:48:16 -0500

Index: emacs/lispref/processes.texi
diff -c emacs/lispref/processes.texi:1.39 emacs/lispref/processes.texi:1.40
*** emacs/lispref/processes.texi:1.39   Mon Oct 13 09:49:31 2003
--- emacs/lispref/processes.texi        Sun Nov  2 01:29:59 2003
***************
*** 265,271 ****
  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
! address@hidden 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
--- 265,271 ----
  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
! address@hidden 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
***************
*** 468,484 ****
  
  @defvar process-connection-type
  @cindex pipes
! @cindex @sc{pty}s
  This variable controls the type of device used to communicate with
! asynchronous subprocesses.  If it is address@hidden, then @sc{pty}s are
  used, when available.  Otherwise, pipes are used.
  
! @sc{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
  it is good not to waste them.
  
  The value of @code{process-connection-type} takes effect when
--- 468,484 ----
  
  @defvar process-connection-type
  @cindex pipes
! @cindex @acronym{PTY}s
  This variable controls the type of device used to communicate with
! asynchronous subprocesses.  If it is address@hidden, then @acronym{PTY}s are
  used, when available.  Otherwise, pipes are used.
  
! @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 @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
***************
*** 494,500 ****
  @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
  Information}).
  @end defvar
  
--- 494,500 ----
  @end smallexample
  
  To determine whether a given subprocess actually got a pipe or a
! @acronym{PTY}, use the function @code{process-tty-name} (@pxref{Process
  Information}).
  @end defvar
  
***************
*** 597,606 ****
  @end defun
  
  @defun process-id process
! This function returns the @sc{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
  process is started and remains constant as long as the process exists.
  @end defun
  
--- 597,606 ----
  @end defun
  
  @defun process-id process
! 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
! @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
  
***************
*** 724,732 ****
  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
  the other characters, to force them through.  For most programs,
! these @sc{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
--- 724,732 ----
  data appears on the ``standard input'' of the subprocess.
  
    Some operating systems have limited space for buffered input in a
! @acronym{PTY}.  On these systems, Emacs sends an @acronym{EOF} periodically 
amidst
  the other characters, to force them through.  For most programs,
! 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
***************
*** 782,791 ****
  
  @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.
  
    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
  error is signaled if the current buffer has no process.
  
    The function returns @var{process-name}.
--- 782,791 ----
  
  @defun process-send-eof &optional process-name
    This function makes @var{process-name} see an end-of-file in its
! 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 @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}.
***************
*** 898,904 ****
  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 to send signals to processes that are not children of Emacs.
  @end defun
  
--- 898,904 ----
  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 @acronym{ID}; that allows
  you to send signals to processes that are not children of Emacs.
  @end defun
  
***************
*** 1480,1486 ****
  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
  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.
--- 1480,1486 ----
  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 @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.




reply via email to

[Prev in Thread] Current Thread [Next in Thread]