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; }