changeset 56716:c126b8b6a314

* process.c (wait_reading_process_input): Clean up. Add wait_for_cell, wait_proc, and just_wait_proc args to avoid overloading `read_kbd' and `do_display' args. Change read_kbd arg to int. All callers changed.
author Kim F. Storm <storm@cua.dk>
date Thu, 19 Aug 2004 13:57:17 +0000
parents 3f2803fc673a
children f95a8f5985be
files src/process.c
diffstat 1 files changed, 67 insertions(+), 95 deletions(-) [+]
line wrap: on
line diff
--- a/src/process.c	Thu Aug 19 13:56:39 2004 +0000
+++ b/src/process.c	Thu Aug 19 13:57:17 2004 +0000
@@ -3777,13 +3777,12 @@
   else
     seconds = NILP (process) ? -1 : 0;
 
-  if (NILP (process))
-    XSETFASTINT (process, 0);
-
   return
-    (wait_reading_process_input (seconds, useconds, process,
+    (wait_reading_process_input (seconds, useconds, 0, 0,
+				 Qnil,
+				 !NILP (process) ? XPROCESS (process) : NULL,
 				 NILP (just_this_one) ? 0 :
-				 !INTEGERP (just_this_one) ? -1 : -2)
+				 !INTEGERP (just_this_one) ? 1 : -1)
      ? Qt : Qnil);
 }
 
@@ -4010,28 +4009,32 @@
      1 to return when input is available, or
      -1 meaning caller will actually read the input, so don't throw to
        the quit handler, or
-     a cons cell, meaning wait until its car is non-nil
-       (and gobble terminal input into the buffer if any arrives), 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.
-
-   If READ_KBD is a process object, DO_DISPLAY < 0 means handle only
-     output from that process (suspending output from other processes)
-     and DO_DISPLAY == -2 specifically means don't run any timers either.
-   Otherwise, != 0 means redisplay should be done to show subprocess
+
+   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.
+   If WAIT_FOR_CELL is a cons cell, wait until its car is non-nil
+     (and gobble terminal input into the buffer if any arrives).
+
+   If WAIT_PROC is specified, wait until something arrives from that
+     process.  The return value is true iff we read some input from
+     that process.
+
+   If JUST_WAIT_PROC is non-nil, handle only output from WAIT_PROC
+     (suspending output from other processes).  A negative value
+     means don't run any timers either.
+
+   If WAIT_PROC is specified, then the function returns true iff we
+     received input from that process before the timeout elapsed.
    Otherwise, return true iff we received 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;
+wait_reading_process_input (time_limit, microsecs, read_kbd, do_display,
+			    wait_for_cell, wait_proc, just_wait_proc)
+     int time_limit, microsecs, read_kbd, do_display;
+     Lisp_Object wait_for_cell;
+     struct Lisp_Process *wait_proc;
+     int just_wait_proc;
 {
   register int channel, nfds;
   SELECT_TYPE Available;
@@ -4041,39 +4044,19 @@
   Lisp_Object proc;
   EMACS_TIME timeout, end_time;
   int wait_channel = -1;
-  struct Lisp_Process *wait_proc = 0;
-  int just_wait_proc = 0;
   int got_some_input = 0;
   /* Either nil or a cons cell, the car of which is of interest and
      may be changed outside of this routine.  */
-  Lisp_Object wait_for_cell = Qnil;
   int saved_waiting_for_user_input_p = waiting_for_user_input_p;
 
   FD_ZERO (&Available);
   FD_ZERO (&Connecting);
 
-  /* If read_kbd is a process to watch, set wait_proc and wait_channel
-     accordingly.  */
-  if (PROCESSP (read_kbd))
-    {
-      wait_proc = XPROCESS (read_kbd);
-      wait_channel = XINT (wait_proc->infd);
-      XSETFASTINT (read_kbd, 0);
-      if (do_display < 0)
-	{
-	  just_wait_proc = do_display;
-	  do_display = 0;
-	}
-    }
-
-  /* If waiting for non-nil in a cell, record where.  */
-  if (CONSP (read_kbd))
-    {
-      wait_for_cell = read_kbd;
-      XSETFASTINT (read_kbd, 0);
-    }
-
-  waiting_for_user_input_p = XINT (read_kbd);
+  /* If wait_proc is a process to watch, set wait_channel accordingly.  */
+  if (wait_proc != NULL)
+    wait_channel = XINT (wait_proc->infd);
+
+  waiting_for_user_input_p = read_kbd;
 
   /* Since we may need to wait several times,
      compute the absolute time to return at.  */
@@ -4101,7 +4084,7 @@
       /* 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)
+      if (read_kbd >= 0)
 	QUIT;
 #ifdef SYNC_INPUT
       else if (interrupt_input_pending)
@@ -4139,7 +4122,7 @@
 	 the wait is supposed to be short,
 	 and those callers cannot handle running arbitrary Lisp code here.  */
       if (NILP (wait_for_cell)
-	  && just_wait_proc != -2)
+	  && just_wait_proc >= 0)
 	{
 	  EMACS_TIME timer_delay;
 
@@ -4167,7 +4150,7 @@
 	  while (!detect_input_pending ());
 
 	  /* If there is unread keyboard input, also return.  */
-	  if (XINT (read_kbd) != 0
+	  if (read_kbd != 0
 	      && requeued_events_pending_p ())
 	    break;
 
@@ -4195,7 +4178,7 @@
 	 It is important that we do this before checking for process
 	 activity.  If we get a SIGCHLD after the explicit checks for
 	 process activity, timeout is the only way we will know.  */
-      if (XINT (read_kbd) < 0)
+      if (read_kbd < 0)
 	set_waiting_for_input (&timeout);
 
       /* If status of something has changed, and no input is
@@ -4275,8 +4258,10 @@
 
       /* Wait till there is something to do */
 
-      if (just_wait_proc)
+      if (wait_proc && just_wait_proc)
 	{
+	  if (XINT (wait_proc->infd) < 0)  /* Terminated */
+	    break;
 	  FD_SET (XINT (wait_proc->infd), &Available);
 	  check_connect = check_delay = 0;
 	}
@@ -4287,7 +4272,7 @@
 	}
       else
 	{
-	  if (! XINT (read_kbd))
+	  if (! read_kbd)
 	    Available = non_keyboard_wait_mask;
 	  else
 	    Available = input_wait_mask;
@@ -4304,12 +4289,12 @@
 	{
 	  clear_waiting_for_input ();
 	  redisplay_preserve_echo_area (11);
-	  if (XINT (read_kbd) < 0)
+	  if (read_kbd < 0)
 	    set_waiting_for_input (&timeout);
 	}
 
       no_avail = 0;
-      if (XINT (read_kbd) && detect_input_pending ())
+      if (read_kbd && detect_input_pending ())
 	{
 	  nfds = 0;
 	  no_avail = 1;
@@ -4429,7 +4414,7 @@
 	 And on hpux, since we turn off polling in wait_reading_process_input,
 	 it might never get read at all if we don't spend much time
 	 outside of wait_reading_process_input.  */
-      if (XINT (read_kbd) && interrupt_input
+      if (read_kbd && interrupt_input
 	  && keyboard_bit_set (&Available)
 	  && input_polling_used ())
 	kill (getpid (), SIGALRM);
@@ -4439,7 +4424,7 @@
       /* If there is any, return immediately
 	 to give it higher priority than subprocesses */
 
-      if (XINT (read_kbd) != 0)
+      if (read_kbd != 0)
 	{
 	  int old_timers_run = timers_run;
 	  struct buffer *old_buffer = current_buffer;
@@ -4464,7 +4449,7 @@
 	}
 
       /* If there is unread keyboard input, also return.  */
-      if (XINT (read_kbd) != 0
+      if (read_kbd != 0
 	  && requeued_events_pending_p ())
 	break;
 
@@ -4475,7 +4460,7 @@
 	 That would causes delays in pasting selections, for example.
 
 	 (We used to do this only if wait_for_cell.)  */
-      if (XINT (read_kbd) == 0 && detect_input_pending ())
+      if (read_kbd == 0 && detect_input_pending ())
 	{
 	  swallow_events (do_display);
 #if 0  /* Exiting when read_kbd doesn't request that seems wrong, though.  */
@@ -4494,7 +4479,7 @@
 	 In that case, there really is no input and no SIGIO,
 	 but select says there is input.  */
 
-      if (XINT (read_kbd) && interrupt_input
+      if (read_kbd && interrupt_input
 	  && keyboard_bit_set (&Available) && ! noninteractive)
 	kill (getpid (), SIGIO);
 #endif
@@ -4504,7 +4489,7 @@
 
       /* If checking input just got us a size-change event from X,
 	 obey it now if we should.  */
-      if (XINT (read_kbd) || ! NILP (wait_for_cell))
+      if (read_kbd || ! NILP (wait_for_cell))
 	do_pending_window_change (0);
 
       /* Check for data from a process.  */
@@ -4679,7 +4664,7 @@
   /* 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)
+  if (read_kbd >= 0)
     {
       /* Prevent input_pending from remaining set if we quit.  */
       clear_input_pending ();
@@ -5326,7 +5311,6 @@
 		       that may allow the program
 		       to finish doing output and read more.  */
 		    {
-		      Lisp_Object zero;
 		      int offset = 0;
 
 #ifdef BROKEN_PTY_READ_AFTER_EAGAIN
@@ -5361,11 +5345,10 @@
 		      else if (STRINGP (object))
 			offset = buf - SDATA (object);
 
-		      XSETFASTINT (zero, 0);
 #ifdef EMACS_HAS_USECS
-		      wait_reading_process_input (0, 20000, zero, 0);
+		      wait_reading_process_input (0, 20000, 0, 0, Qnil, NULL, 0);
 #else
-		      wait_reading_process_input (1, 0, zero, 0);
+		      wait_reading_process_input (1, 0, 0, 0, Qnil, NULL, 0);
 #endif
 
 		      if (BUFFERP (object))
@@ -6887,10 +6870,9 @@
      1 to return when input is available, or
      -1 means caller will actually read the input, so don't throw to
        the quit handler.
-     a cons cell, meaning wait until its car is non-nil
-       (and gobble terminal input into the buffer if any arrives), or
-     We know that read_kbd will never be a Lisp_Process, since
-     `subprocesses' isn't defined.
+
+   see full version for other parameters. We know that wait_proc will
+     always be NULL, since `subprocesses' isn't defined.
 
    do_display != 0 means redisplay should be done to show subprocess
    output that arrives.
@@ -6898,27 +6880,17 @@
    Return true iff we received 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;
+wait_reading_process_input (time_limit, microsecs, read_kbd, do_display,
+			    wait_for_cell, wait_proc, just_wait_proc)
+     int time_limit, microsecs, read_kbd, do_display;
+     Lisp_Object wait_for_cell;
+     struct Lisp_Process *wait_proc;
+     int just_wait_proc;
 {
   register int nfds;
   EMACS_TIME end_time, timeout;
   SELECT_TYPE waitchannels;
   int xerrno;
-  /* Either nil or a cons cell, the car of which is of interest and
-     may be changed outside of this routine.  */
-  Lisp_Object wait_for_cell;
-
-  wait_for_cell = Qnil;
-
-  /* If waiting for non-nil in a cell, record where.  */
-  if (CONSP (read_kbd))
-    {
-      wait_for_cell = read_kbd;
-      XSETFASTINT (read_kbd, 0);
-    }
 
   /* What does time_limit really mean?  */
   if (time_limit || microsecs)
@@ -6941,7 +6913,7 @@
       /* 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)
+      if (read_kbd >= 0)
 	QUIT;
 
       /* Exit now if the cell we're waiting for became non-nil.  */
@@ -6992,7 +6964,7 @@
 	  while (!detect_input_pending ());
 
 	  /* If there is unread keyboard input, also return.  */
-	  if (XINT (read_kbd) != 0
+	  if (read_kbd != 0
 	      && requeued_events_pending_p ())
 	    break;
 
@@ -7010,12 +6982,12 @@
 
       /* Cause C-g and alarm signals to take immediate action,
 	 and cause input available signals to zero out timeout.  */
-      if (XINT (read_kbd) < 0)
+      if (read_kbd < 0)
 	set_waiting_for_input (&timeout);
 
       /* Wait till there is something to do.  */
 
-      if (! XINT (read_kbd) && NILP (wait_for_cell))
+      if (! read_kbd && NILP (wait_for_cell))
 	FD_ZERO (&waitchannels);
       else
 	FD_SET (0, &waitchannels);
@@ -7026,11 +6998,11 @@
 	{
 	  clear_waiting_for_input ();
 	  redisplay_preserve_echo_area (15);
-	  if (XINT (read_kbd) < 0)
+	  if (read_kbd < 0)
 	    set_waiting_for_input (&timeout);
 	}
 
-      if (XINT (read_kbd) && detect_input_pending ())
+      if (read_kbd && detect_input_pending ())
 	{
 	  nfds = 0;
 	  FD_ZERO (&waitchannels);
@@ -7066,13 +7038,13 @@
 	kill (getpid (), SIGIO);
 #endif
 #ifdef SIGIO
-      if (XINT (read_kbd) && interrupt_input && (waitchannels & 1))
+      if (read_kbd && interrupt_input && (waitchannels & 1))
 	kill (getpid (), SIGIO);
 #endif
 
       /* Check for keyboard input */
 
-      if ((XINT (read_kbd) != 0)
+      if (read_kbd
 	  && detect_input_pending_run_timers (do_display))
 	{
 	  swallow_events (do_display);
@@ -7081,7 +7053,7 @@
 	}
 
       /* If there is unread keyboard input, also return.  */
-      if (XINT (read_kbd) != 0
+      if (read_kbd
 	  && requeued_events_pending_p ())
 	break;