[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Emacs-diffs] Changes to emacs/src/process.c [emacs-unicode-2]
|
From: |
Miles Bader |
|
Subject: |
[Emacs-diffs] Changes to emacs/src/process.c [emacs-unicode-2] |
|
Date: |
Fri, 27 Aug 2004 07:06:26 -0400 |
Index: emacs/src/process.c
diff -c emacs/src/process.c:1.408.2.7 emacs/src/process.c:1.408.2.8
*** emacs/src/process.c:1.408.2.7 Tue Aug 3 00:03:00 2004
--- emacs/src/process.c Fri Aug 27 07:00:32 2004
***************
*** 3719,3725 ****
}
DEFUN ("accept-process-output", Faccept_process_output,
Saccept_process_output,
! 0, 3, 0,
doc: /* Allow any pending output from subprocesses to be read by Emacs.
It is read into the process' buffers or given to their filter functions.
Non-nil arg PROCESS means do not return until some output has been received
--- 3719,3725 ----
}
DEFUN ("accept-process-output", Faccept_process_output,
Saccept_process_output,
! 0, 4, 0,
doc: /* Allow any pending output from subprocesses to be read by Emacs.
It is read into the process' buffers or given to their filter functions.
Non-nil arg PROCESS means do not return until some output has been received
***************
*** 3727,3741 ****
Non-nil second arg TIMEOUT and third arg TIMEOUT-MSECS are number of
seconds and microseconds to wait; return after that much time whether
or not there is input.
Return non-nil iff we received any output before the timeout expired. */)
! (process, timeout, timeout_msecs)
! register Lisp_Object process, timeout, timeout_msecs;
{
int seconds;
int useconds;
if (! NILP (process))
CHECK_PROCESS (process);
if (! NILP (timeout_msecs))
{
--- 3727,3746 ----
Non-nil second arg TIMEOUT and third arg TIMEOUT-MSECS are number of
seconds and microseconds to wait; return after that much time whether
or not there is input.
+ If optional fourth arg JUST-THIS-ONE is non-nil, only accept output
+ from PROCESS, suspending reading output from other processes.
+ If JUST-THIS-ONE is an integer, don't run any timers either.
Return non-nil iff we received any output before the timeout expired. */)
! (process, timeout, timeout_msecs, just_this_one)
! register Lisp_Object process, timeout, timeout_msecs, just_this_one;
{
int seconds;
int useconds;
if (! NILP (process))
CHECK_PROCESS (process);
+ else
+ just_this_one = Qnil;
if (! NILP (timeout_msecs))
{
***************
*** 3773,3783 ****
else
seconds = NILP (process) ? -1 : 0;
- if (NILP (process))
- XSETFASTINT (process, 0);
-
return
! (wait_reading_process_input (seconds, useconds, process, 0)
? Qt : Qnil);
}
--- 3778,3789 ----
else
seconds = NILP (process) ? -1 : 0;
return
! (wait_reading_process_output (seconds, useconds, 0, 0,
! Qnil,
! !NILP (process) ? XPROCESS (process) : NULL,
! NILP (just_this_one) ? 0 :
! !INTEGERP (just_this_one) ? 1 : -1)
? Qt : Qnil);
}
***************
*** 3977,3988 ****
lisp code is being evalled.
This is also used in record_asynch_buffer_change.
For that purpose, this must be 0
! when not inside wait_reading_process_input. */
static int waiting_for_user_input_p;
/* This is here so breakpoints can be put on it. */
static void
! wait_reading_process_input_1 ()
{
}
--- 3983,3994 ----
lisp code is being evalled.
This is also used in record_asynch_buffer_change.
For that purpose, this must be 0
! when not inside wait_reading_process_output. */
static int waiting_for_user_input_p;
/* This is here so breakpoints can be put on it. */
static void
! wait_reading_process_output_1 ()
{
}
***************
*** 4004,4028 ****
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.
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 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;
{
register int channel, nfds;
SELECT_TYPE Available;
--- 4010,4041 ----
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
DO_DISPLAY != 0 means redisplay should be done to show subprocess
! output that arrives.
!
! 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_output (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;
***************
*** 4032,4064 ****
Lisp_Object proc;
EMACS_TIME timeout, end_time;
int wait_channel = -1;
- struct Lisp_Process *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 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);
/* Since we may need to wait several times,
compute the absolute time to return at. */
--- 4045,4063 ----
Lisp_Object proc;
EMACS_TIME timeout, end_time;
int wait_channel = -1;
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. */
int saved_waiting_for_user_input_p = waiting_for_user_input_p;
FD_ZERO (&Available);
FD_ZERO (&Connecting);
! /* 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. */
***************
*** 4086,4092 ****
/* 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;
#ifdef SYNC_INPUT
else if (interrupt_input_pending)
--- 4085,4091 ----
/* 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;
#ifdef SYNC_INPUT
else if (interrupt_input_pending)
***************
*** 4123,4129 ****
But not if wait_for_cell; in those cases,
the wait is supposed to be short,
and those callers cannot handle running arbitrary Lisp code here. */
! if (NILP (wait_for_cell))
{
EMACS_TIME timer_delay;
--- 4122,4129 ----
But not if wait_for_cell; in those cases,
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 >= 0)
{
EMACS_TIME timer_delay;
***************
*** 4151,4157 ****
while (!detect_input_pending ());
/* If there is unread keyboard input, also return. */
! if (XINT (read_kbd) != 0
&& requeued_events_pending_p ())
break;
--- 4151,4157 ----
while (!detect_input_pending ());
/* If there is unread keyboard input, also return. */
! if (read_kbd != 0
&& requeued_events_pending_p ())
break;
***************
*** 4169,4175 ****
else if (time_limit != -1)
{
/* This is so a breakpoint can be put here. */
! wait_reading_process_input_1 ();
}
}
--- 4169,4175 ----
else if (time_limit != -1)
{
/* This is so a breakpoint can be put here. */
! wait_reading_process_output_1 ();
}
}
***************
*** 4179,4185 ****
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)
set_waiting_for_input (&timeout);
/* If status of something has changed, and no input is
--- 4179,4185 ----
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 (read_kbd < 0)
set_waiting_for_input (&timeout);
/* If status of something has changed, and no input is
***************
*** 4259,4272 ****
/* Wait till there is something to do */
! if (!NILP (wait_for_cell))
{
Available = non_process_wait_mask;
check_connect = check_delay = 0;
}
else
{
! if (! XINT (read_kbd))
Available = non_keyboard_wait_mask;
else
Available = input_wait_mask;
--- 4259,4279 ----
/* Wait till there is something to do */
! 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;
! }
! else if (!NILP (wait_for_cell))
{
Available = non_process_wait_mask;
check_connect = check_delay = 0;
}
else
{
! if (! read_kbd)
Available = non_keyboard_wait_mask;
else
Available = input_wait_mask;
***************
*** 4283,4294 ****
{
clear_waiting_for_input ();
redisplay_preserve_echo_area (11);
! if (XINT (read_kbd) < 0)
set_waiting_for_input (&timeout);
}
no_avail = 0;
! if (XINT (read_kbd) && detect_input_pending ())
{
nfds = 0;
no_avail = 1;
--- 4290,4301 ----
{
clear_waiting_for_input ();
redisplay_preserve_echo_area (11);
! if (read_kbd < 0)
set_waiting_for_input (&timeout);
}
no_avail = 0;
! if (read_kbd && detect_input_pending ())
{
nfds = 0;
no_avail = 1;
***************
*** 4405,4414 ****
/* If we are using polling for input,
and we see input available, make it get read now.
Otherwise it might not actually get read for a second.
! 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
&& keyboard_bit_set (&Available)
&& input_polling_used ())
kill (getpid (), SIGALRM);
--- 4412,4421 ----
/* If we are using polling for input,
and we see input available, make it get read now.
Otherwise it might not actually get read for a second.
! And on hpux, since we turn off polling in wait_reading_process_output,
it might never get read at all if we don't spend much time
! outside of wait_reading_process_output. */
! if (read_kbd && interrupt_input
&& keyboard_bit_set (&Available)
&& input_polling_used ())
kill (getpid (), SIGALRM);
***************
*** 4418,4424 ****
/* If there is any, return immediately
to give it higher priority than subprocesses */
! if (XINT (read_kbd) != 0)
{
int old_timers_run = timers_run;
struct buffer *old_buffer = current_buffer;
--- 4425,4431 ----
/* If there is any, return immediately
to give it higher priority than subprocesses */
! if (read_kbd != 0)
{
int old_timers_run = timers_run;
struct buffer *old_buffer = current_buffer;
***************
*** 4443,4449 ****
}
/* If there is unread keyboard input, also return. */
! if (XINT (read_kbd) != 0
&& requeued_events_pending_p ())
break;
--- 4450,4456 ----
}
/* If there is unread keyboard input, also return. */
! if (read_kbd != 0
&& requeued_events_pending_p ())
break;
***************
*** 4454,4460 ****
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 ())
{
swallow_events (do_display);
#if 0 /* Exiting when read_kbd doesn't request that seems wrong, though. */
--- 4461,4467 ----
That would causes delays in pasting selections, for example.
(We used to do this only if wait_for_cell.) */
! if (read_kbd == 0 && detect_input_pending ())
{
swallow_events (do_display);
#if 0 /* Exiting when read_kbd doesn't request that seems wrong, though. */
***************
*** 4473,4479 ****
In that case, there really is no input and no SIGIO,
but select says there is input. */
! if (XINT (read_kbd) && interrupt_input
&& keyboard_bit_set (&Available) && ! noninteractive)
kill (getpid (), SIGIO);
#endif
--- 4480,4486 ----
In that case, there really is no input and no SIGIO,
but select says there is input. */
! if (read_kbd && interrupt_input
&& keyboard_bit_set (&Available) && ! noninteractive)
kill (getpid (), SIGIO);
#endif
***************
*** 4483,4489 ****
/* 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))
do_pending_window_change (0);
/* Check for data from a process. */
--- 4490,4496 ----
/* If checking input just got us a size-change event from X,
obey it now if we should. */
! if (read_kbd || ! NILP (wait_for_cell))
do_pending_window_change (0);
/* Check for data from a process. */
***************
*** 4658,4664 ****
/* 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 ();
--- 4665,4671 ----
/* 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 ();
***************
*** 5303,5309 ****
that may allow the program
to finish doing output and read more. */
{
- Lisp_Object zero;
int offset = 0;
#ifdef BROKEN_PTY_READ_AFTER_EAGAIN
--- 5310,5315 ----
***************
*** 5338,5348 ****
else if (STRINGP (object))
offset = buf - SDATA (object);
- XSETFASTINT (zero, 0);
#ifdef EMACS_HAS_USECS
! wait_reading_process_input (0, 20000, zero, 0);
#else
! wait_reading_process_input (1, 0, zero, 0);
#endif
if (BUFFERP (object))
--- 5344,5353 ----
else if (STRINGP (object))
offset = buf - SDATA (object);
#ifdef EMACS_HAS_USECS
! wait_reading_process_output (0, 20000, 0, 0, Qnil, NULL,
0);
#else
! wait_reading_process_output (1, 0, 0, 0, Qnil, NULL, 0);
#endif
if (BUFFERP (object))
***************
*** 5548,5576 ****
work. If the system has it, use it. */
#ifdef HAVE_TERMIOS
struct termios t;
switch (signo)
{
case SIGINT:
! tcgetattr (XINT (p->infd), &t);
! send_process (proc, &t.c_cc[VINTR], 1, Qnil);
! return;
case SIGQUIT:
! tcgetattr (XINT (p->infd), &t);
! send_process (proc, &t.c_cc[VQUIT], 1, Qnil);
! return;
case SIGTSTP:
- tcgetattr (XINT (p->infd), &t);
#if defined (VSWTCH) && !defined (PREFER_VSUSP)
! send_process (proc, &t.c_cc[VSWTCH], 1, Qnil);
#else
! send_process (proc, &t.c_cc[VSUSP], 1, Qnil);
#endif
! return;
}
#else /* ! HAVE_TERMIOS */
/* On Berkeley descendants, the following IOCTL's retrieve the
--- 5553,5588 ----
work. If the system has it, use it. */
#ifdef HAVE_TERMIOS
struct termios t;
+ cc_t *sig_char = NULL;
+
+ tcgetattr (XINT (p->infd), &t);
switch (signo)
{
case SIGINT:
! sig_char = &t.c_cc[VINTR];
! break;
case SIGQUIT:
! sig_char = &t.c_cc[VQUIT];
! break;
case SIGTSTP:
#if defined (VSWTCH) && !defined (PREFER_VSUSP)
! sig_char = &t.c_cc[VSWTCH];
#else
! sig_char = &t.c_cc[VSUSP];
#endif
! break;
}
+ if (sig_char && *sig_char != CDISABLE)
+ {
+ send_process (proc, sig_char, 1, Qnil);
+ return;
+ }
+ /* If we can't send the signal with a character,
+ fall through and send it another way. */
#else /* ! HAVE_TERMIOS */
/* On Berkeley descendants, the following IOCTL's retrieve the
***************
*** 5627,5635 ****
you'd better be using one of the alternatives above! */
#endif /* ! defined (TCGETA) */
#endif /* ! defined (TIOCGLTC) && defined (TIOCGETC) */
! #endif /* ! defined HAVE_TERMIOS */
abort ();
! /* The code above always returns from the function. */
#endif /* defined (SIGNALS_VIA_CHARACTERS) */
#ifdef TIOCGPGRP
--- 5639,5650 ----
you'd better be using one of the alternatives above! */
#endif /* ! defined (TCGETA) */
#endif /* ! defined (TIOCGLTC) && defined (TIOCGETC) */
! /* In this case, the code above should alway returns. */
abort ();
! #endif /* ! defined HAVE_TERMIOS */
!
! /* The code above may fall through if it can't
! handle the signal. */
#endif /* defined (SIGNALS_VIA_CHARACTERS) */
#ifdef TIOCGPGRP
***************
*** 6201,6207 ****
FD_CLR (XINT (p->infd), &non_keyboard_wait_mask);
}
! /* Tell wait_reading_process_input that it needs to wake up and
look around. */
if (input_available_clear_time)
EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0);
--- 6216,6222 ----
FD_CLR (XINT (p->infd), &non_keyboard_wait_mask);
}
! /* Tell wait_reading_process_output that it needs to wake up and
look around. */
if (input_available_clear_time)
EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0);
***************
*** 6219,6225 ****
else if (WIFSIGNALED (w))
synch_process_termsig = WTERMSIG (w);
! /* Tell wait_reading_process_input that it needs to wake up and
look around. */
if (input_available_clear_time)
EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0);
--- 6234,6240 ----
else if (WIFSIGNALED (w))
synch_process_termsig = WTERMSIG (w);
! /* Tell wait_reading_process_output that it needs to wake up and
look around. */
if (input_available_clear_time)
EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0);
***************
*** 6861,6870 ****
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.
do_display != 0 means redisplay should be done to show subprocess
output that arrives.
--- 6876,6884 ----
1 to return when input is available, or
-1 means caller will actually read the input, so don't throw to
the quit handler.
!
! 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.
***************
*** 6872,6898 ****
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;
{
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)
--- 6886,6902 ----
Return true iff we received input from any process. */
int
! wait_reading_process_output (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;
/* What does time_limit really mean? */
if (time_limit || microsecs)
***************
*** 6915,6921 ****
/* 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. */
--- 6919,6925 ----
/* 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;
/* Exit now if the cell we're waiting for became non-nil. */
***************
*** 6966,6972 ****
while (!detect_input_pending ());
/* If there is unread keyboard input, also return. */
! if (XINT (read_kbd) != 0
&& requeued_events_pending_p ())
break;
--- 6970,6976 ----
while (!detect_input_pending ());
/* If there is unread keyboard input, also return. */
! if (read_kbd != 0
&& requeued_events_pending_p ())
break;
***************
*** 6984,6995 ****
/* 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. */
! if (! XINT (read_kbd) && NILP (wait_for_cell))
FD_ZERO (&waitchannels);
else
FD_SET (0, &waitchannels);
--- 6988,6999 ----
/* 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. */
! if (! read_kbd && NILP (wait_for_cell))
FD_ZERO (&waitchannels);
else
FD_SET (0, &waitchannels);
***************
*** 7000,7010 ****
{
clear_waiting_for_input ();
redisplay_preserve_echo_area (15);
! if (XINT (read_kbd) < 0)
set_waiting_for_input (&timeout);
}
! if (XINT (read_kbd) && detect_input_pending ())
{
nfds = 0;
FD_ZERO (&waitchannels);
--- 7004,7014 ----
{
clear_waiting_for_input ();
redisplay_preserve_echo_area (15);
! if (read_kbd < 0)
set_waiting_for_input (&timeout);
}
! if (read_kbd && detect_input_pending ())
{
nfds = 0;
FD_ZERO (&waitchannels);
***************
*** 7040,7052 ****
kill (getpid (), SIGIO);
#endif
#ifdef SIGIO
! if (XINT (read_kbd) && interrupt_input && (waitchannels & 1))
kill (getpid (), SIGIO);
#endif
/* Check for keyboard input */
! if ((XINT (read_kbd) != 0)
&& detect_input_pending_run_timers (do_display))
{
swallow_events (do_display);
--- 7044,7056 ----
kill (getpid (), SIGIO);
#endif
#ifdef SIGIO
! if (read_kbd && interrupt_input && (waitchannels & 1))
kill (getpid (), SIGIO);
#endif
/* Check for keyboard input */
! if (read_kbd
&& detect_input_pending_run_timers (do_display))
{
swallow_events (do_display);
***************
*** 7055,7061 ****
}
/* If there is unread keyboard input, also return. */
! if (XINT (read_kbd) != 0
&& requeued_events_pending_p ())
break;
--- 7059,7065 ----
}
/* If there is unread keyboard input, also return. */
! if (read_kbd
&& requeued_events_pending_p ())
break;