int
poll_fds_for_input (SELECT_TYPE mask)
{
EMACS_TIME sometime;
EMACS_SELECT_TIME select_time;
SELECT_TYPE temp_mask;
int retval;
while (1)
{
EMACS_SET_SECS_USECS (sometime, 0, 0);
EMACS_TIME_TO_SELECT_TIME (sometime, select_time);
temp_mask = mask;
/* To effect a poll, tell select() to block for zero seconds. */
retval = select (MAXDESC, &temp_mask, 0, 0, &select_time);
if (retval >= 0)
return retval;
if (errno != EINTR)
{
/* Something went seriously wrong; don't ABORT since maybe
the TTY just died at the wrong time. */
stderr_out ("xemacs: select failed: errno = %d\n", errno);
return 0;
}
/* else, we got interrupted by a signal, so try again. */
}
RETURN_NOT_REACHED(0) /* not reached */
}
static void
stop_async_timeouts (void)
{
if (async_timer_suppress_count == 0)
{
/* If timer was on, turn it off. */
EMACS_TIME thyme;
EMACS_SET_SECS_USECS (thyme, 0, 0);
set_one_shot_timer (thyme);
}
async_timer_suppress_count++;
}
static void
set_one_shot_timer (EMACS_TIME interval)
{
#ifdef HAVE_SETITIMER
struct itimerval it;
it.it_value = interval;
EMACS_SET_SECS_USECS (it.it_interval, 0, 0);
qxe_setitimer (ITIMER_REAL, &it, 0);
#else
int secs;
EMACS_TIME_TO_INT (interval, secs);
alarm (secs);
#endif
}
void
slow_down_interrupts (void)
{
EMACS_TIME thyme;
/* We have to set the flag *before* setting the slowed-down timer,
to avoid a race condition -- if the signal occurs between the
call to set_one_shot_timer() and the setting of this flag,
alarm_happened will get set, which will be a Bad Thing if
there were no timeouts on the queue. */
interrupts_slowed_down++;
if (interrupts_slowed_down == 1)
{
stop_interrupts ();
EMACS_SET_SECS_USECS (thyme, SLOWED_DOWN_INTERRUPTS_SECS, 0);
set_one_shot_timer (thyme);
}
}
static void
reset_interval_timer (void)
{
EMACS_TIME interval;
/* Get the interval to set. If an interval is available,
make sure it's not zero (this is a valid return, but it will
cause the timer to get disabled, so convert it to a very short
time). */
if (get_low_level_timeout_interval (async_timer_queue, &interval))
{
if (EMACS_SECS (interval) == 0 && EMACS_USECS (interval) == 0)
EMACS_SET_USECS (interval, 1);
}
else
/* A time of 0 means "disable". */
EMACS_SET_SECS_USECS (interval, 0, 0);
set_one_shot_timer (interval);
}
int
xg_select (int max_fds, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
EMACS_TIME *timeout)
{
SELECT_TYPE all_rfds, all_wfds;
EMACS_TIME tmo, *tmop = timeout;
GMainContext *context = g_main_context_default ();
int have_wfds = wfds != NULL;
int n_gfds = 0, our_tmo = 0, retval = 0, our_fds = 0;
int i, nfds, tmo_in_millisec;
if (rfds) memcpy (&all_rfds, rfds, sizeof (all_rfds));
else FD_ZERO (&all_rfds);
if (wfds) memcpy (&all_wfds, wfds, sizeof (all_rfds));
else FD_ZERO (&all_wfds);
/* Update event sources in GLib. */
g_main_context_pending (context);
do {
if (n_gfds > gfds_size)
{
while (n_gfds > gfds_size)
gfds_size *= 2;
xfree (gfds);
gfds = xmalloc (sizeof (*gfds) * gfds_size);
}
n_gfds = g_main_context_query (context,
G_PRIORITY_LOW,
&tmo_in_millisec,
gfds,
gfds_size);
} while (n_gfds > gfds_size);
for (i = 0; i < n_gfds; ++i)
{
if (gfds[i].events & G_IO_IN)
{
FD_SET (gfds[i].fd, &all_rfds);
if (gfds[i].fd > max_fds) max_fds = gfds[i].fd;
}
if (gfds[i].events & G_IO_OUT)
{
FD_SET (gfds[i].fd, &all_wfds);
if (gfds[i].fd > max_fds) max_fds = gfds[i].fd;
have_wfds = 1;
}
}
if (tmo_in_millisec >= 0)
{
EMACS_SET_SECS_USECS (tmo, tmo_in_millisec/1000,
1000 * (tmo_in_millisec % 1000));
if (!timeout) our_tmo = 1;
else
{
EMACS_TIME difference;
EMACS_SUB_TIME (difference, tmo, *timeout);
if (EMACS_TIME_NEG_P (difference)) our_tmo = 1;
}
if (our_tmo) tmop = &tmo;
}
nfds = select (max_fds+1, &all_rfds, have_wfds ? &all_wfds : NULL,
efds, tmop);
if (nfds < 0)
retval = nfds;
else if (nfds > 0)
{
for (i = 0; i < max_fds+1; ++i)
{
if (FD_ISSET (i, &all_rfds))
{
if (rfds && FD_ISSET (i, rfds)) ++retval;
else ++our_fds;
}
else if (rfds)
FD_CLR (i, rfds);
if (have_wfds && FD_ISSET (i, &all_wfds))
{
if (wfds && FD_ISSET (i, wfds)) ++retval;
else ++our_fds;
}
else if (wfds)
FD_CLR (i, wfds);
if (efds && FD_ISSET (i, efds))
++retval;
}
}
if (our_fds > 0 || (nfds == 0 && our_tmo))
{
/* If Gtk+ is in use eventually gtk_main_iteration will be called,
unless retval is zero. */
#ifdef USE_GTK
if (retval == 0)
#endif
while (g_main_context_pending (context))
g_main_context_dispatch (context);
/* To not have to recalculate timeout, return like this. */
if (retval == 0)
{
retval = -1;
errno = EINTR;
}
}
return retval;
}
