(wait_reading_process_input) [!subprocesses]: Handle

the case of READ_KBD being a cons cell.  Retry the timer check
after a timer fired.  (All of these make this definition
consistent with the one that supports async subprocesses.)

(wait_reading_process_input, both definitions):
Use plain detect_input_pending just before the select call.

1 files changed, 57 insertions, 25 deletions

diff --git a/src/process.c b/src/process.c
index 09d262f0c6f..6db62dc6f35 100644
--- a/src/process.c
+++ b/src/process.c
@@ -2174,19 +2174,14 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
 	    set_waiting_for_input (&timeout);
 	}
 
-      {
-	int old_timers_run = timers_run;
-	if (XINT (read_kbd) && detect_input_pending_run_timers (do_display))
-	  {
-	    nfds = 0;
-	    FD_ZERO (&Available);
-	  }
-	else if (timers_run != old_timers_run)
-	  ;
-	else
-	  nfds = select (MAXDESC, &Available, (SELECT_TYPE *)0, (SELECT_TYPE *)0,
-			 &timeout);
-      }
+      if (XINT (read_kbd) && detect_input_pending ())
+	{
+	  nfds = 0;
+	  FD_ZERO (&Available);
+	}
+      else
+	nfds = select (MAXDESC, &Available, (SELECT_TYPE *)0, (SELECT_TYPE *)0,
+		       &timeout);
 
       xerrno = errno;
 
@@ -3830,6 +3825,8 @@ extern int timers_run;
      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.
 
@@ -3847,6 +3844,14 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
   EMACS_TIME end_time, timeout;
   SELECT_TYPE waitchannels;
   int xerrno;
+  Lisp_Object *wait_for_cell = 0;
+
+  /* If waiting for non-nil in a cell, record where.  */
+  if (CONSP (read_kbd))
+    {
+      wait_for_cell = &XCONS (read_kbd)->car;
+      XSETFASTINT (read_kbd, 0);
+    }
 
   /* What does time_limit really mean?  */
   if (time_limit || microsecs)
@@ -3874,17 +3879,16 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
       int nfds;
       int timeout_reduced_for_timers = 0;
 
-      if (XINT (read_kbd))
-	FD_SET (0, &waitchannels);
-      else
-	FD_ZERO (&waitchannels);
-
       /* 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;
 
+      /* Exit now if the cell we're waiting for became non-nil.  */
+      if (wait_for_cell && ! NILP (*wait_for_cell))
+	break;
+
       /* Compute time from now till when time limit is up */
       /* Exit if already run out */
       if (time_limit > 0 || microsecs)
@@ -3899,13 +3903,22 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
 	 run timer events directly.
 	 (Callers that will immediately read keyboard events
 	 call timer_delay on their own.)  */
-      if (XINT (read_kbd) >= 0)
+      if (1)
 	{
 	  EMACS_TIME timer_delay;
-	  int old_timers_run = timers_run;
+	  int old_timers_run;
+
+	retry:
+	  old_timers_run = timers_run;
 	  timer_delay = timer_check (1);
 	  if (timers_run != old_timers_run && do_display)
-	    redisplay_preserve_echo_area ();
+	    {
+	      redisplay_preserve_echo_area ();
+	      /* We must retry, since a timer may have requeued itself
+		 and that could alter the time delay.  */
+	      goto retry;
+	    }
+
 	  if (! EMACS_TIME_NEG_P (timer_delay) && time_limit != -1)
 	    {
 	      EMACS_TIME difference;
@@ -3923,15 +3936,30 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
       if (XINT (read_kbd) < 0)
 	set_waiting_for_input (&timeout);
 
+      /* Wait till there is something to do.  */
+
+      if (! XINT (read_kbd) && wait_for_cell == 0)
+	FD_ZERO (&waitchannels);
+      else
+	FD_SET (0, &waitchannels);
+
       /* If a frame has been newly mapped and needs updating,
 	 reprocess its display stuff.  */
       if (frame_garbaged && do_display)
-	redisplay_preserve_echo_area ();
+	{
+	  clear_waiting_for_input ();
+	  redisplay_preserve_echo_area ();
+	  if (XINT (read_kbd) < 0)
+	    set_waiting_for_input (&timeout);
+	}
 
       {
 	int old_timers_run = timers_run;
-	if (XINT (read_kbd) && detect_input_pending_run_timers (do_display))
-	  nfds = 0;
+	if (XINT (read_kbd) && detect_input_pending ())
+	  {
+	    nfds = 0;
+	    FD_ZERO (&waitchannels);
+	  }
 	else if (timers_run != old_timers_run)
 	  ;
 	else
@@ -3972,13 +4000,17 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
 
       /* Check for keyboard input */
 
-      if (XINT (read_kbd) != 0
+      if ((XINT (read_kbd) != 0 || wait_for_cell)
 	  && detect_input_pending_run_timers (do_display))
 	{
 	  swallow_events (do_display);
 	  if (detect_input_pending_run_timers (do_display))
 	    break;
 	}
+
+      /* Exit now if the cell we're waiting for became non-nil.  */
+      if (wait_for_cell && ! NILP (*wait_for_cell))
+	break;
     }
 
   start_polling ();