comparison src/process.c @ 650:39f0e62a8511

*** empty log message ***

649:61deba7b73b6

	seconds = -1;
      else
	seconds = 0;
    }

  return
    (wait_reading_process_input (seconds, useconds,
				 (NILP (proc)
				  ? XPROCESS (get_process (proc)) : 0), 0)
     ? Qt : Qnil);
}

/* This variable is different from waiting_for_input in keyboard.c.
   It is used to communicate to a lisp process-filter/sentinel (via the

   time_limit is:
     timeout in seconds, or
     zero for no limit, or
     -1 means gobble data immediately available but don't wait for any.

   read_kbd is:
     0 to ignore keyboard input, or
     1 to return when input is available, or
     -1 means caller will actually read the input, so don't throw to
       the quit handler, or
     a pointer to a struct Lisp_Process, meaning wait until something
       arrives from that process.  The return value is true iff we read
       some input from that process.

   do_display != 0 means redisplay should be done to show subprocess
   output that arrives.

   If read_kbd is a pointer to a struct Lisp_Process, then the
     function returns true iff we received input from that process
     before the timeout elapsed.
   Otherwise, return true iff we recieved input from any process.  */

wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
     int time_limit, microsecs, read_kbd, do_display;
{
  register int channel, nfds, m;
  static SELECT_TYPE Available;
  int xerrno;
  Lisp_Object proc;

  struct Lisp_Process *wait_proc = 0;
  int got_some_input = 0;

  FD_ZERO (&Available);

  /* Detect when read_kbd is really the address of a Lisp_Process.  */
  if (read_kbd > 10 || read_kbd < -1)
    {
      wait_proc = (struct Lisp_Process *) read_kbd;
      wait_channel = XFASTINT (wait_proc->infd);
      read_kbd = 0;
    }

  waiting_for_user_input_p = read_kbd;

  /* Since we may need to wait several times,
     compute the absolute time to return at.  */
  if (time_limit || microsecs)
    {

  while (1)
    {
      /* If calling from keyboard input, do not quit
	 since we want to return C-g as an input character.
	 Otherwise, do pending quit if requested.  */
      if (read_kbd >= 0)
	QUIT;

      /* If status of something has changed, and no input is available,
	 notify the user of the change right away */
      if (update_tick != process_tick && do_display)

	  EMACS_SET_SECS_USECS (timeout, 100000, 0);
	}

      /* Cause C-g and alarm signals to take immediate action,
	 and cause input available signals to zero out timeout */
      if (read_kbd < 0)
	set_waiting_for_input (&timeout);

      /* Wait till there is something to do */

      Available = input_wait_mask;
      if (!read_kbd)
	FD_CLR (0, &Available);

      /* If screen size has changed or the window is newly mapped,
	 redisplay now, before we start to wait.  There is a race
	 condition here; if a SIGIO arrives between now and the select
	 and indicates that a screen is trashed, we lose.  */
      if (screen_garbaged)
	redisplay_preserve_echo_area ();

      if (read_kbd && detect_input_pending ())
	nfds = 0;
      else
	nfds = select (MAXDESC, &Available, 0, 0, &timeout);

      xerrno = errno;

      /* Check for keyboard input */
      /* If there is any, return immediately
	 to give it higher priority than subprocesses */

      if (read_kbd && detect_input_pending ())
	break;

#ifdef SIGIO
      /* If we think we have keyboard input waiting, but didn't get SIGIO
	 go read it.  This can happen with X on BSD after logging out.
	 In that case, there really is no input and no SIGIO,
	 but select says there is input.  */

      /*
	if (read_kbd && interrupt_input && (Available & fileno (stdin)))
	*/
      if (read_kbd && interrupt_input && (FD_ISSET (fileno (stdin), &Available)))
	kill (0, SIGIO);
#endif

#ifdef vipc
      /* Check for connection from other process */

      if (! wait_proc)
	got_some_input |= nfds > 0;

      /* If checking input just got us a size-change event from X,
	 obey it now if we should.  */
      if (read_kbd)
	do_pending_window_change ();

      /* Check for data from a process or a command channel */
      for (channel = FIRST_PROC_DESC; channel < MAXDESC; channel++)
	{

    }				/* end while exit conditions not met */

  /* If calling from keyboard input, do not quit
     since we want to return C-g as an input character.
     Otherwise, do pending quit if requested.  */
  if (read_kbd >= 0)
    {
      /* Prevent input_pending from remaining set if we quit.  */
      clear_input_pending ();
      QUIT;
    }

	buf += rv;
	len -= rv;
	/* Allow input from processes between bursts of sending.
	   Otherwise things may get stopped up.  */
	if (len > 0)
	  wait_reading_process_input (-1, 0, 0, 0);
      }
#endif
  else
    {
      XPROCESS (proc)->raw_status_low = Qnil;

   time_limit is:
     timeout in seconds, or
     zero for no limit, or
     -1 means gobble data immediately available but don't wait for any.

   read_kbd is:
     0 to ignore keyboard input, or
     1 to return when input is available, or
     -1 means caller will actually read the input, so don't throw to
       the quit handler.
     We know that read_kbd will never be a Lisp_Process, since
     `subprocesses' isn't defined.

   do_display != 0 means redisplay should be done to show subprocess
   output that arrives.  This version of the function ignores it.

   If read_kbd is a pointer to a struct Lisp_Process, then the
     function returns true iff we received input from that process
     before the timeout elapsed.
   Otherwise, return true iff we recieved input from any process.  */

int
wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
     int time_limit, microsecs, read_kbd, do_display;
{
  EMACS_TIME end_time, timeout, *timeout_p;
  int waitchannels;

  /* What does time_limit really mean?  */

  for (;;)
    {
      int nfds;

      waitchannels = read_kbd ? 1 : 0;

      /* If calling from keyboard input, do not quit
	 since we want to return C-g as an input character.
	 Otherwise, do pending quit if requested.  */
      if (read_kbd >= 0)
	QUIT;

      if (timeout_p)
	{
	  EMACS_GET_TIME (*timeout_p);

	    break;
	}

      /* Cause C-g and alarm signals to take immediate action,
	 and cause input available signals to zero out timeout.  */
      if (read_kbd < 0)
	set_waiting_for_input (&timeout);

      /* If a screen has been newly mapped and needs updating,
	 reprocess its display stuff.  */
      if (screen_garbaged)
	redisplay_preserve_echo_area ();

      if (read_kbd && detect_input_pending ())
	nfds = 0;
      else
	nfds = select (1, &waitchannels, 0, 0, timeout_p);

      /* Make C-g and alarm signals set flags again */

#ifdef sun
      else if (nfds > 0 && (waitchannels & 1)  && interrupt_input)
	/* System sometimes fails to deliver SIGIO.  */
	kill (getpid (), SIGIO);
#endif
      if (read_kbd && interrupt_input && (waitchannels & 1))
	kill (0, SIGIO);

      /* If we have timed out (nfds == 0) or found some input (nfds > 0),
	 we should exit.  */
      if (nfds >= 0)

650:39f0e62a8511

	seconds = -1;
      else
	seconds = 0;
    }

  if (NILP (proc))
    XFASTINT (proc) = 0;

  return
    (wait_reading_process_input (seconds, useconds, proc, 0)
     ? Qt : Qnil);
}

/* This variable is different from waiting_for_input in keyboard.c.
   It is used to communicate to a lisp process-filter/sentinel (via the

   time_limit is:
     timeout in seconds, or
     zero for no limit, or
     -1 means gobble data immediately available but don't wait for any.

   read_kbd is a lisp value:
     0 to ignore keyboard input, or
     1 to return when input is available, or
     -1 means caller will actually read the input, so don't throw to
       the quit handler, or
     a process object, meaning wait until something arrives from that
       process.  The return value is true iff we read some input from
       that process.

   do_display != 0 means redisplay should be done to show subprocess
   output that arrives.

   If read_kbd is a pointer to a struct Lisp_Process, then the
     function returns true iff we received input from that process
     before the timeout elapsed.
   Otherwise, return true iff we recieved input from any process.  */

wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
     int time_limit, microsecs;
     Lisp_Object read_kbd;
     int do_display;
{
  register int channel, nfds, m;
  static SELECT_TYPE Available;
  int xerrno;
  Lisp_Object proc;

  struct Lisp_Process *wait_proc = 0;
  int got_some_input = 0;

  FD_ZERO (&Available);

  /* If read_kbd is a process to watch, set wait_proc and wait_channel
     accordingly.  */
  if (XTYPE (read_kbd) == Lisp_Process)
    {
      wait_proc = XPROCESS (read_kbd);
      wait_channel = XFASTINT (wait_proc->infd);
      XFASTINT (read_kbd) = 0;
    }

  waiting_for_user_input_p = XINT (read_kbd);

  /* Since we may need to wait several times,
     compute the absolute time to return at.  */
  if (time_limit || microsecs)
    {

  while (1)
    {
      /* If calling from keyboard input, do not quit
	 since we want to return C-g as an input character.
	 Otherwise, do pending quit if requested.  */
      if (XINT (read_kbd) >= 0)
	QUIT;

      /* If status of something has changed, and no input is available,
	 notify the user of the change right away */
      if (update_tick != process_tick && do_display)

	  EMACS_SET_SECS_USECS (timeout, 100000, 0);
	}

      /* Cause C-g and alarm signals to take immediate action,
	 and cause input available signals to zero out timeout */
      if (XINT (read_kbd) < 0)
	set_waiting_for_input (&timeout);

      /* Wait till there is something to do */

      Available = input_wait_mask;
      if (! XINT (read_kbd))
	FD_CLR (0, &Available);

      /* If screen size has changed or the window is newly mapped,
	 redisplay now, before we start to wait.  There is a race
	 condition here; if a SIGIO arrives between now and the select
	 and indicates that a screen is trashed, we lose.  */
      if (screen_garbaged)
	redisplay_preserve_echo_area ();

      if (XINT (read_kbd) && detect_input_pending ())
	nfds = 0;
      else
	nfds = select (MAXDESC, &Available, 0, 0, &timeout);

      xerrno = errno;

      /* Check for keyboard input */
      /* If there is any, return immediately
	 to give it higher priority than subprocesses */

      if (XINT (read_kbd) && detect_input_pending ())
	break;

#ifdef SIGIO
      /* If we think we have keyboard input waiting, but didn't get SIGIO
	 go read it.  This can happen with X on BSD after logging out.
	 In that case, there really is no input and no SIGIO,
	 but select says there is input.  */

      /*
	if (XINT (read_kbd) && interrupt_input && (Available & fileno (stdin)))
	*/
      if (XINT (read_kbd) && interrupt_input && (FD_ISSET (fileno (stdin), &Available)))
	kill (0, SIGIO);
#endif

#ifdef vipc
      /* Check for connection from other process */

      if (! wait_proc)
	got_some_input |= nfds > 0;

      /* If checking input just got us a size-change event from X,
	 obey it now if we should.  */
      if (XINT (read_kbd))
	do_pending_window_change ();

      /* Check for data from a process or a command channel */
      for (channel = FIRST_PROC_DESC; channel < MAXDESC; channel++)
	{

    }				/* end while exit conditions not met */

  /* If calling from keyboard input, do not quit
     since we want to return C-g as an input character.
     Otherwise, do pending quit if requested.  */
  if (XINT (read_kbd) >= 0)
    {
      /* Prevent input_pending from remaining set if we quit.  */
      clear_input_pending ();
      QUIT;
    }

	buf += rv;
	len -= rv;
	/* Allow input from processes between bursts of sending.
	   Otherwise things may get stopped up.  */
	if (len > 0)
	  {
	    Lisp_Object zero;

	    XFASTINT (zero) = 0;
	    wait_reading_process_input (-1, 0, zero, 0);
	  }
      }
#endif
  else
    {
      XPROCESS (proc)->raw_status_low = Qnil;

   time_limit is:
     timeout in seconds, or
     zero for no limit, or
     -1 means gobble data immediately available but don't wait for any.

   read_kbd is a Lisp_Object:
     0 to ignore keyboard input, or
     1 to return when input is available, or
     -1 means caller will actually read the input, so don't throw to
       the quit handler.
     We know that read_kbd will never be a Lisp_Process, since
     `subprocesses' isn't defined.

   do_display != 0 means redisplay should be done to show subprocess
   output that arrives.  This version of the function ignores it.

   Return true iff we recieved input from any process.  */

int
wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
     int time_limit, microsecs;
     Lisp_Object read_kbd;
     int do_display;
{
  EMACS_TIME end_time, timeout, *timeout_p;
  int waitchannels;

  /* What does time_limit really mean?  */

  for (;;)
    {
      int nfds;

      waitchannels = XINT (read_kbd) ? 1 : 0;

      /* If calling from keyboard input, do not quit
	 since we want to return C-g as an input character.
	 Otherwise, do pending quit if requested.  */
      if (XINT (read_kbd) >= 0)
	QUIT;

      if (timeout_p)
	{
	  EMACS_GET_TIME (*timeout_p);

	    break;
	}

      /* Cause C-g and alarm signals to take immediate action,
	 and cause input available signals to zero out timeout.  */
      if (XINT (read_kbd) < 0)
	set_waiting_for_input (&timeout);

      /* If a screen has been newly mapped and needs updating,
	 reprocess its display stuff.  */
      if (screen_garbaged)
	redisplay_preserve_echo_area ();

      if (XINT (read_kbd) && detect_input_pending ())
	nfds = 0;
      else
	nfds = select (1, &waitchannels, 0, 0, timeout_p);

      /* Make C-g and alarm signals set flags again */

#ifdef sun
      else if (nfds > 0 && (waitchannels & 1)  && interrupt_input)
	/* System sometimes fails to deliver SIGIO.  */
	kill (getpid (), SIGIO);
#endif
      if (XINT (read_kbd) && interrupt_input && (waitchannels & 1))
	kill (0, SIGIO);

      /* If we have timed out (nfds == 0) or found some input (nfds > 0),
	 we should exit.  */
      if (nfds >= 0)