/***********************************************************
Copyright (c) 1993, Oracle and/or its affiliates. All rights reserved.

Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice (including the next
paragraph) shall be included in all copies or substantial portions of the
Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.

Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts.

                        All Rights Reserved

Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Digital not be
used in advertising or publicity pertaining to distribution of the
software without specific, written prior permission.

DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.

******************************************************************/

/*

Copyright 1987, 1988, 1994, 1998, 2001  The Open Group

Permission to use, copy, modify, distribute, and sell this software and its
documentation for any purpose is hereby granted without fee, provided that
the above copyright notice appear in all copies and that both that
copyright notice and this permission notice appear in supporting
documentation.

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Except as contained in this notice, the name of The Open Group shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from The Open Group.

*/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "IntrinsicI.h"
#include <stdio.h>
#include <errno.h>

#ifdef _WIN32
typedef long suseconds_t;
#endif

static TimerEventRec *freeTimerRecs;
static WorkProcRec *freeWorkRecs;
static SignalEventRec *freeSignalRecs;

/* Some systems running NTP daemons are known to return strange usec
 * values from gettimeofday.
 */

#ifndef NEEDS_NTPD_FIXUP
#if defined(sun) || defined(MOTOROLA) || (defined(__osf__) && defined(__alpha))
#define NEEDS_NTPD_FIXUP 1
#else
#define NEEDS_NTPD_FIXUP 0
#endif
#endif

#if NEEDS_NTPD_FIXUP
#define FIXUP_TIMEVAL(t) { \
        while ((t).tv_usec >= 1000000) { \
            (t).tv_usec -= 1000000; \
            (t).tv_sec++; \
        } \
        while ((t).tv_usec < 0) { \
            if ((t).tv_sec > 0) { \
                (t).tv_usec += 1000000; \
                (t).tv_sec--; \
            } else { \
                (t).tv_usec = 0; \
                break; \
            } \
        }}
#else
#define FIXUP_TIMEVAL(t)
#endif                          /*NEEDS_NTPD_FIXUP */

/*
 * Private routines
 */
#define ADD_TIME(dest, src1, src2) { \
        if(((dest).tv_usec = (src1).tv_usec + (src2).tv_usec) >= 1000000) {\
              (dest).tv_usec -= 1000000;\
              (dest).tv_sec = (src1).tv_sec + (src2).tv_sec + 1 ; \
        } else { (dest).tv_sec = (src1).tv_sec + (src2).tv_sec ; \
           if(((dest).tv_sec >= 1) && (((dest).tv_usec <0))) { \
            (dest).tv_sec --;(dest).tv_usec += 1000000; } } }

#define TIMEDELTA(dest, src1, src2) { \
        if(((dest).tv_usec = (src1).tv_usec - (src2).tv_usec) < 0) {\
              (dest).tv_usec += 1000000;\
              (dest).tv_sec = (src1).tv_sec - (src2).tv_sec - 1;\
        } else  (dest).tv_sec = (src1).tv_sec - (src2).tv_sec;  }

#define IS_AFTER(t1, t2) (((t2).tv_sec > (t1).tv_sec) \
        || (((t2).tv_sec == (t1).tv_sec)&& ((t2).tv_usec > (t1).tv_usec)))

#define IS_AT_OR_AFTER(t1, t2) (((t2).tv_sec > (t1).tv_sec) \
        || (((t2).tv_sec == (t1).tv_sec)&& ((t2).tv_usec >= (t1).tv_usec)))

#ifdef USE_POLL
#ifndef XT_DEFAULT_FDLIST_SIZE
#define XT_DEFAULT_FDLIST_SIZE 32
#endif
#endif

static void
AdjustHowLong(unsigned long *howlong, struct timeval *start_time)
{
    struct timeval new_time, time_spent, lstart_time;

    lstart_time = *start_time;
    X_GETTIMEOFDAY(&new_time);
    FIXUP_TIMEVAL(new_time);
    TIMEDELTA(time_spent, new_time, lstart_time);
    if (*howlong <=
        (unsigned long) (time_spent.tv_sec * 1000 + time_spent.tv_usec / 1000))
        *howlong = (unsigned long) 0;   /* Timed out */
    else
        *howlong =
            (*howlong -
             (unsigned long) (time_spent.tv_sec * 1000 +
                              time_spent.tv_usec / 1000));
}

typedef struct {
    struct timeval cur_time;
    struct timeval start_time;
    struct timeval wait_time;
    struct timeval new_time;
    struct timeval time_spent;
    struct timeval max_wait_time;
#ifdef USE_POLL
    int poll_wait;
#else
    struct timeval *wait_time_ptr;
#endif
} wait_times_t, *wait_times_ptr_t;

static struct timeval zero_time = { 0, 0 };

#ifdef USE_POLL
#define X_BLOCK -1
#define X_DONT_BLOCK 0
#else
static fd_set zero_fd;
#endif

static void
InitTimes(Boolean block,
          unsigned long *howlong,
          wait_times_ptr_t wt)
{
    if (block) {
        X_GETTIMEOFDAY(&wt->cur_time);
        FIXUP_TIMEVAL(wt->cur_time);
        wt->start_time = wt->cur_time;
        if (howlong == NULL) {  /* special case for ever */
#ifdef USE_POLL
            wt->poll_wait = X_BLOCK;
#else
            wt->wait_time_ptr = NULL;
#endif
        }
        else {                  /* block until at most */
            wt->max_wait_time.tv_sec = (time_t) (*howlong / 1000);
            wt->max_wait_time.tv_usec =
                (suseconds_t) ((*howlong % 1000) * 1000);
#ifdef USE_POLL
            wt->poll_wait = (int) *howlong;
#else
            wt->wait_time_ptr = &wt->max_wait_time;
#endif
        }
    }
    else {                      /* don't block */
        wt->max_wait_time = zero_time;
#ifdef USE_POLL
        wt->poll_wait = X_DONT_BLOCK;
#else
        wt->wait_time_ptr = &wt->max_wait_time;
#endif
    }
}

typedef struct {
#ifdef USE_POLL
    struct pollfd *fdlist;
    struct pollfd *stack;
    int fdlistlen, num_dpys;
#else
    fd_set rmask, wmask, emask;
    int nfds;
#endif
} wait_fds_t, *wait_fds_ptr_t;

static void
InitFds(XtAppContext app,
        Boolean ignoreEvents,
        Boolean ignoreInputs,
        wait_fds_ptr_t wf)
{
    int ii;

    app->rebuild_fdlist = FALSE;
#ifdef USE_POLL
#ifndef POLLRDNORM
#define POLLRDNORM 0
#endif

#ifndef POLLRDBAND
#define POLLRDBAND 0
#endif

#ifndef POLLWRNORM
#define POLLWRNORM 0
#endif

#ifndef POLLWRBAND
#define POLLWRBAND 0
#endif

#define XPOLL_READ (POLLIN|POLLRDNORM|POLLPRI|POLLRDBAND)
#define XPOLL_WRITE (POLLOUT|POLLWRNORM|POLLWRBAND)
#define XPOLL_EXCEPT 0

    if (!ignoreEvents)
        wf->fdlistlen = wf->num_dpys = app->count;
    else
        wf->fdlistlen = wf->num_dpys = 0;

    if (!ignoreInputs && app->input_list != NULL) {
        for (ii = 0; ii < (int) app->input_max; ii++)
            if (app->input_list[ii] != NULL)
                wf->fdlistlen++;
    }

    if (!wf->fdlist || wf->fdlist == wf->stack) {
        wf->fdlist = (struct pollfd *)
            XtStackAlloc(sizeof(struct pollfd) * (size_t) wf->fdlistlen,
                         wf->stack);
    }
    else {
        wf->fdlist = (struct pollfd *)
            XtRealloc((char *) wf->fdlist,
                      (Cardinal) (sizeof(struct pollfd) *
                                  (size_t) wf->fdlistlen));
    }

    if (wf->fdlistlen) {
        struct pollfd *fdlp = wf->fdlist;
        InputEvent *iep;

        if (!ignoreEvents)
            for (ii = 0; ii < wf->num_dpys; ii++, fdlp++) {
                fdlp->fd = ConnectionNumber(app->list[ii]);
                fdlp->events = POLLIN;
            }
        if (!ignoreInputs && app->input_list != NULL)
            for (ii = 0; ii < app->input_max; ii++)
                if (app->input_list[ii] != NULL) {
                    iep = app->input_list[ii];
                    fdlp->fd = ii;
                    fdlp->events = 0;
                    for (; iep; iep = iep->ie_next) {
                        if (iep->ie_condition & XtInputReadMask)
                            fdlp->events |= XPOLL_READ;
                        if (iep->ie_condition & XtInputWriteMask)
                            fdlp->events |= XPOLL_WRITE;
                        if (iep->ie_condition & XtInputExceptMask)
                            fdlp->events |= XPOLL_EXCEPT;
                    }
                    fdlp++;
                }
    }
#else
    wf->nfds = app->fds.nfds;
    if (!ignoreInputs) {
        wf->rmask = app->fds.rmask;
        wf->wmask = app->fds.wmask;
        wf->emask = app->fds.emask;
    }
    else
        wf->rmask = wf->wmask = wf->emask = zero_fd;

    if (!ignoreEvents)
        for (ii = 0; ii < app->count; ii++) {
            FD_SET(ConnectionNumber(app->list[ii]), &wf->rmask);
        }
#endif
}

static void
AdjustTimes(XtAppContext app,
            Boolean block,
            unsigned long *howlong,
            Boolean ignoreTimers,
            wait_times_ptr_t wt)
{
    if (app->timerQueue != NULL && !ignoreTimers && block) {
#ifdef USE_POLL
        if (IS_AFTER(wt->cur_time, app->timerQueue->te_timer_value)) {
            TIMEDELTA(wt->wait_time, app->timerQueue->te_timer_value,
                      wt->cur_time);
            if (howlong == NULL || IS_AFTER(wt->wait_time, wt->max_wait_time))
                wt->poll_wait =
                    (int) (wt->wait_time.tv_sec * 1000 +
                           wt->wait_time.tv_usec / 1000);
            else
                wt->poll_wait =
                    (int) (wt->max_wait_time.tv_sec * 1000 +
                           wt->max_wait_time.tv_usec / 1000);
        }
        else
            wt->poll_wait = X_DONT_BLOCK;
#else
        if (IS_AFTER(wt->cur_time, app->timerQueue->te_timer_value)) {
            TIMEDELTA(wt->wait_time, app->timerQueue->te_timer_value,
                      wt->cur_time);
            if (howlong == NULL || IS_AFTER(wt->wait_time, wt->max_wait_time))
                wt->wait_time_ptr = &wt->wait_time;
            else
                wt->wait_time_ptr = &wt->max_wait_time;
        }
        else
            wt->wait_time_ptr = &zero_time;
#endif
    }
}

static int
IoWait(wait_times_ptr_t wt, wait_fds_ptr_t wf)
{
#ifdef USE_POLL
    return poll(wf->fdlist, (nfds_t) wf->fdlistlen, wt->poll_wait);
#else
    return Select (wf->nfds, &wf->rmask, &wf->wmask, &wf->emask,
                   wt->wait_time_ptr);
#endif
}

static void
FindInputs(XtAppContext app,
           wait_fds_ptr_t wf,
           int nfds _X_UNUSED,
           Boolean ignoreEvents,
           Boolean ignoreInputs,
           int *dpy_no,
           int *found_input)
{
    InputEvent *ep;
    int ii;

#ifdef USE_POLL                 /* { check ready file descriptors block */
    struct pollfd *fdlp;

    *dpy_no = -1;
    *found_input = False;

    if (!ignoreEvents) {
        fdlp = wf->fdlist;
        for (ii = 0; ii < wf->num_dpys; ii++, fdlp++) {
            if (*dpy_no == -1 && fdlp->revents & (POLLIN | POLLHUP | POLLERR) &&
#ifdef XTHREADS
                !(fdlp->revents & POLLNVAL) &&
#endif
                XEventsQueued(app->list[ii], QueuedAfterReading)) {
                *dpy_no = ii;
                break;
            }
        }
    }

    if (!ignoreInputs) {
        fdlp = &wf->fdlist[wf->num_dpys];
        for (ii = wf->num_dpys; ii < wf->fdlistlen; ii++, fdlp++) {
            XtInputMask condition = 0;

            if (fdlp->revents) {
                if (fdlp->revents & (XPOLL_READ | POLLHUP | POLLERR)
#ifdef XTHREADS
                    && !(fdlp->revents & POLLNVAL)
#endif
                    )
                    condition = XtInputReadMask;
                if (fdlp->revents & XPOLL_WRITE)
                    condition |= XtInputWriteMask;
                if (fdlp->revents & XPOLL_EXCEPT)
                    condition |= XtInputExceptMask;
            }
            if (condition) {
                *found_input = True;
                for (ep = app->input_list[fdlp->fd]; ep; ep = ep->ie_next)
                    if (condition & ep->ie_condition) {
                        InputEvent *oq;

                        /* make sure this input isn't already marked outstanding */
                        for (oq = app->outstandingQueue; oq; oq = oq->ie_oq)
                            if (oq == ep)
                                break;
                        if (!oq) {
                            ep->ie_oq = app->outstandingQueue;
                            app->outstandingQueue = ep;
                        }
                    }
            }
        }
    }
#else                           /* }{ */
#ifdef XTHREADS
    fd_set rmask;
#endif
    int dd;

    *dpy_no = -1;
    *found_input = False;

#ifdef XTHREADS
    rmask = app->fds.rmask;
    for (dd = app->count; dd-- > 0;)
        FD_SET(ConnectionNumber(app->list[dd]), &rmask);
#endif

    for (ii = 0; ii < wf->nfds && nfds > 0; ii++) {
        XtInputMask condition = 0;

        if (FD_ISSET(ii, &wf->rmask)
#ifdef XTHREADS
            && FD_ISSET(ii, &rmask)
#endif
            ) {
            nfds--;
            if (!ignoreEvents) {
                for (dd = 0; dd < app->count; dd++) {
                    if (ii == ConnectionNumber(app->list[dd])) {
                        if (*dpy_no == -1) {
                            if (XEventsQueued
                                (app->list[dd], QueuedAfterReading))
                                *dpy_no = dd;
                            /*
                             * An error event could have arrived
                             * without any real events, or events
                             * could have been swallowed by Xlib,
                             * or the connection may be broken.
                             * We can't tell the difference, so
                             * assume Xlib will eventually discover
                             * a broken connection.
                             */
                        }
                        goto ENDILOOP;
                    }
                }
            }
            condition = XtInputReadMask;
        }
        if (FD_ISSET(ii, &wf->wmask)
#ifdef XTHREADS
            && FD_ISSET(ii, &app->fds.wmask)
#endif
            ) {
            condition |= XtInputWriteMask;
            nfds--;
        }
        if (FD_ISSET(ii, &wf->emask)
#ifdef XTHREADS
            && FD_ISSET(ii, &app->fds.emask)
#endif
            ) {
            condition |= XtInputExceptMask;
            nfds--;
        }
        if (condition) {
            for (ep = app->input_list[ii]; ep; ep = ep->ie_next)
                if (condition & ep->ie_condition) {
                    /* make sure this input isn't already marked outstanding */
                    InputEvent *oq;

                    for (oq = app->outstandingQueue; oq; oq = oq->ie_oq)
                        if (oq == ep)
                            break;
                    if (!oq) {
                        ep->ie_oq = app->outstandingQueue;
                        app->outstandingQueue = ep;
                    }
                }
            *found_input = True;
        }
 ENDILOOP:;
    }                           /* endfor */
#endif                          /* } */
}

/*
 * Routine to block in the toolkit.  This should be the only call to select.
 *
 * This routine returns when there is something to be done.
 *
 * Before calling this with ignoreInputs==False, app->outstandingQueue should
 * be checked; this routine will not verify that an alternate input source
 * has not already been enqueued.
 *
 *
 * _XtWaitForSomething( appContext,
 *                      ignoreEvent, ignoreTimers, ignoreInputs, ignoreSignals,
 *                      block, drop_lock, howlong)
 * XtAppContext app;         (Displays to check wait on)
 *
 * Boolean ignoreEvents;     (Don't return if XEvents are available
 *                              Also implies forget XEvents exist)
 *
 * Boolean ignoreTimers;     (Ditto for timers)
 *
 * Boolean ignoreInputs;     (Ditto for input callbacks )
 *
 * Boolean ignoreSignals;    (Ditto for signals)
 *
 * Boolean block;            (Okay to block)
 *
 * Boolean drop_lock         (drop lock before going into select/poll)
 *
 * TimeVal howlong;          (howlong to wait for if blocking and not
 *                              doing Timers... Null means forever.
 *                              Maybe should mean shortest of both)
 * Returns display for which input is available, if any
 * and if ignoreEvents==False, else returns -1
 *
 * if ignoring everything && block=True && howlong=NULL, you'll have
 * lots of time for coffee; better not try it!  In fact, it probably
 * makes little sense to do this regardless of the value of howlong
 * (bottom line is, we don't bother checking here).
 *
 * If drop_lock is FALSE, the app->lock->mutex is not unlocked before
 * entering select/poll. It is illegal for drop_lock to be FALSE if
 * ignoreTimers, ignoreInputs, or ignoreSignals is FALSE.
 */
int
_XtWaitForSomething(XtAppContext app,
                    _XtBoolean ignoreEvents,
                    _XtBoolean ignoreTimers,
                    _XtBoolean ignoreInputs,
                    _XtBoolean ignoreSignals,
                    _XtBoolean block,
                    _XtBoolean drop_lock, /* only needed with XTHREADS */
                    unsigned long *howlong)
{
    wait_times_t wt;
    wait_fds_t wf;
    int nfds, dpy_no, found_input, dd;

#ifdef XTHREADS
    Boolean push_thread = TRUE;
    Boolean pushed_thread = FALSE;
    int level = 0;
#endif
#ifdef USE_POLL
    struct pollfd fdlist[XT_DEFAULT_FDLIST_SIZE];
#endif

#ifdef XTHREADS
    /* assert ((ignoreTimers && ignoreInputs && ignoreSignals) || drop_lock); */
    /* If not multi-threaded, never drop lock */
    if (app->lock == (ThreadAppProc) NULL)
        drop_lock = FALSE;
#else
    drop_lock = drop_lock;      /* avoid unsed warning */
#endif

    InitTimes((Boolean) block, howlong, &wt);

#ifdef USE_POLL
    wf.fdlist = NULL;
    wf.stack = fdlist;
    wf.fdlistlen = wf.num_dpys = 0;
#endif

 WaitLoop:
    app->rebuild_fdlist = TRUE;

    while (1) {
        AdjustTimes(app, (Boolean) block, howlong, (Boolean) ignoreTimers, &wt);

        if (block && app->block_hook_list) {
            BlockHook hook;

            for (hook = app->block_hook_list; hook != NULL; hook = hook->next)
                (*hook->proc) (hook->closure);

            if (!ignoreEvents)
                /* see if the hook(s) generated any protocol */
                for (dd = 0; dd < app->count; dd++)
                    if (XEventsQueued(app->list[dd], QueuedAlready)) {
#ifdef USE_POLL
                        XtStackFree((XtPointer) wf.fdlist, fdlist);
#endif
                        return dd;
                    }
        }

        if (app->rebuild_fdlist)
            InitFds(app, (Boolean) ignoreEvents, (Boolean) ignoreInputs, &wf);

#ifdef XTHREADS                 /* { */
        if (drop_lock) {
            YIELD_APP_LOCK(app, &push_thread, &pushed_thread, &level);
            nfds = IoWait(&wt, &wf);
            RESTORE_APP_LOCK(app, level, &pushed_thread);
        }
        else
#endif                          /* } */
            nfds = IoWait(&wt, &wf);
        if (nfds == -1) {
            /*
             *  interrupt occured recalculate time value and wait again.
             */
            if (errno == EINTR || errno == EAGAIN) {
                if (errno == EAGAIN) {
                    errno = 0;  /* errno is not self reseting */
                    continue;
                }
                errno = 0;      /* errno is not self reseting */

                /* was it interrupted by a signal that we care about? */
                if (!ignoreSignals && app->signalQueue != NULL) {
                    SignalEventRec *se_ptr = app->signalQueue;

                    while (se_ptr != NULL) {
                        if (se_ptr->se_notice) {
                            if (block && howlong != NULL)
                                AdjustHowLong(howlong, &wt.start_time);
#ifdef USE_POLL
                            XtStackFree((XtPointer) wf.fdlist, fdlist);
#endif
                            return -1;
                        }
                        se_ptr = se_ptr->se_next;
                    }
                }

                if (!ignoreEvents)
                    /* get Xlib to detect a bad connection */
                    for (dd = 0; dd < app->count; dd++)
                        if (XEventsQueued(app->list[dd], QueuedAfterReading)) {
#ifdef USE_POLL
                            XtStackFree((XtPointer) wf.fdlist, fdlist);
#endif
                            return dd;
                        }

                if (block) {
#ifdef USE_POLL
                    if (wt.poll_wait == X_BLOCK)
#else
                    if (wt.wait_time_ptr == NULL)
#endif
                        continue;
                    X_GETTIMEOFDAY(&wt.new_time);
                    FIXUP_TIMEVAL(wt.new_time);
                    TIMEDELTA(wt.time_spent, wt.new_time, wt.cur_time);
                    wt.cur_time = wt.new_time;
#ifdef USE_POLL
                    if ((wt.time_spent.tv_sec * 1000 +
                         wt.time_spent.tv_usec / 1000) < wt.poll_wait) {
                        wt.poll_wait -=
                            (int) (wt.time_spent.tv_sec * 1000 +
                                   wt.time_spent.tv_usec / 1000);
                        continue;
                    }
                    else
#else
                    if (IS_AFTER(wt.time_spent, *wt.wait_time_ptr)) {
                        TIMEDELTA(wt.wait_time, *wt.wait_time_ptr,
                                  wt.time_spent);
                        wt.wait_time_ptr = &wt.wait_time;
                        continue;
                    }
                    else
#endif
                        nfds = 0;
                }
            }
            else {
                char Errno[12];
                String param = Errno;
                Cardinal param_count = 1;

                sprintf(Errno, "%d", errno);
                XtAppWarningMsg(app, "communicationError", "select",
                                XtCXtToolkitError,
                                "Select failed; error code %s", &param,
                                &param_count);
                continue;
            }
        }                       /* timed out or input available */
        break;
    }

    if (nfds == 0) {
        /* Timed out */
        if (howlong)
            *howlong = (unsigned long) 0;
#ifdef USE_POLL
        XtStackFree((XtPointer) wf.fdlist, fdlist);
#endif
        return -1;
    }

    if (block && howlong != NULL)
        AdjustHowLong(howlong, &wt.start_time);

    if (ignoreInputs && ignoreEvents) {
#ifdef USE_POLL
        XtStackFree((XtPointer) wf.fdlist, fdlist);
#endif
        return -1;
    }
    else
        FindInputs(app, &wf, nfds,
                   (Boolean) ignoreEvents, (Boolean) ignoreInputs,
                   &dpy_no, &found_input);

    if (dpy_no >= 0 || found_input) {
#ifdef USE_POLL
        XtStackFree((XtPointer) wf.fdlist, fdlist);
#endif
        return dpy_no;
    }
    if (block)
        goto WaitLoop;
    else {
#ifdef USE_POLL
        XtStackFree((XtPointer) wf.fdlist, fdlist);
#endif
        return -1;
    }
}

#define IeCallProc(ptr) \
    (*ptr->ie_proc) (ptr->ie_closure, &ptr->ie_source, (XtInputId*)&ptr);

#define TeCallProc(ptr) \
    (*ptr->te_proc) (ptr->te_closure, (XtIntervalId*)&ptr);

#define SeCallProc(ptr) \
    (*ptr->se_proc) (ptr->se_closure, (XtSignalId*)&ptr);

/*
 * Public Routines
 */

XtIntervalId
XtAddTimeOut(unsigned long interval,
             XtTimerCallbackProc proc,
             XtPointer closure)
{
    return XtAppAddTimeOut(_XtDefaultAppContext(), interval, proc, closure);
}

static void
QueueTimerEvent(XtAppContext app, TimerEventRec *ptr)
{
    TimerEventRec *t, **tt;

    tt = &app->timerQueue;
    t = *tt;
    while (t != NULL && IS_AFTER(t->te_timer_value, ptr->te_timer_value)) {
        tt = &t->te_next;
        t = *tt;
    }
    ptr->te_next = t;
    *tt = ptr;
}

XtIntervalId
XtAppAddTimeOut(XtAppContext app,
                unsigned long interval,
                XtTimerCallbackProc proc,
                XtPointer closure)
{
    TimerEventRec *tptr;
    struct timeval current_time;

    LOCK_APP(app);
    LOCK_PROCESS;
    if (freeTimerRecs) {
        tptr = freeTimerRecs;
        freeTimerRecs = tptr->te_next;
    }
    else
        tptr = XtNew(TimerEventRec);

    UNLOCK_PROCESS;
    tptr->te_next = NULL;
    tptr->te_closure = closure;
    tptr->te_proc = proc;
    tptr->app = app;
    tptr->te_timer_value.tv_sec = (time_t) (interval / 1000);
    tptr->te_timer_value.tv_usec = (suseconds_t) ((interval % 1000) * 1000);
    X_GETTIMEOFDAY(&current_time);
    FIXUP_TIMEVAL(current_time);
    ADD_TIME(tptr->te_timer_value, tptr->te_timer_value, current_time);
    QueueTimerEvent(app, tptr);
    UNLOCK_APP(app);

    return ((XtIntervalId) tptr);
}

void
XtRemoveTimeOut(XtIntervalId id)
{
    TimerEventRec *t, *last, *tid = (TimerEventRec *) id;
    XtAppContext app = tid->app;

    /* find it */
    LOCK_APP(app);
    for (t = app->timerQueue, last = NULL;
         t != NULL && t != tid; t = t->te_next)
        last = t;

    if (t == NULL) {
        UNLOCK_APP(app);
        return;                 /* couldn't find it */
    }
    if (last == NULL) {         /* first one on the list */
        app->timerQueue = t->te_next;
    }
    else
        last->te_next = t->te_next;

    LOCK_PROCESS;
    t->te_next = freeTimerRecs;
    freeTimerRecs = t;
    UNLOCK_PROCESS;
    UNLOCK_APP(app);
}

XtWorkProcId
XtAddWorkProc(XtWorkProc proc, XtPointer closure)
{
    return XtAppAddWorkProc(_XtDefaultAppContext(), proc, closure);
}

XtWorkProcId
XtAppAddWorkProc(XtAppContext app, XtWorkProc proc, XtPointer closure)
{
    WorkProcRec *wptr;

    LOCK_APP(app);
    LOCK_PROCESS;
    if (freeWorkRecs) {
        wptr = freeWorkRecs;
        freeWorkRecs = wptr->next;
    }
    else
        wptr = XtNew(WorkProcRec);

    UNLOCK_PROCESS;
    wptr->next = app->workQueue;
    wptr->closure = closure;
    wptr->proc = proc;
    wptr->app = app;
    app->workQueue = wptr;
    UNLOCK_APP(app);

    return (XtWorkProcId) wptr;
}

void
XtRemoveWorkProc(XtWorkProcId id)
{
    WorkProcRec *wid = (WorkProcRec *) id, *w, *last;
    XtAppContext app = wid->app;

    LOCK_APP(app);
    /* find it */
    for (w = app->workQueue, last = NULL; w != NULL && w != wid; w = w->next)
        last = w;

    if (w == NULL) {
        UNLOCK_APP(app);
        return;                 /* couldn't find it */
    }

    if (last == NULL)
        app->workQueue = w->next;
    else
        last->next = w->next;
    LOCK_PROCESS;
    w->next = freeWorkRecs;
    freeWorkRecs = w;
    UNLOCK_PROCESS;
    UNLOCK_APP(app);
}

XtSignalId
XtAddSignal(XtSignalCallbackProc proc, XtPointer closure)
{
    return XtAppAddSignal(_XtDefaultAppContext(), proc, closure);
}

XtSignalId
XtAppAddSignal(XtAppContext app, XtSignalCallbackProc proc, XtPointer closure)
{
    SignalEventRec *sptr;

    LOCK_APP(app);
    LOCK_PROCESS;
    if (freeSignalRecs) {
        sptr = freeSignalRecs;
        freeSignalRecs = sptr->se_next;
    }
    else
        sptr = XtNew(SignalEventRec);

    UNLOCK_PROCESS;
    sptr->se_next = app->signalQueue;
    sptr->se_closure = closure;
    sptr->se_proc = proc;
    sptr->app = app;
    sptr->se_notice = FALSE;
    app->signalQueue = sptr;
    UNLOCK_APP(app);
    return (XtSignalId) sptr;
}

void
XtRemoveSignal(XtSignalId id)
{
    SignalEventRec *sid = (SignalEventRec *) id, *s, *last = NULL;
    XtAppContext app = sid->app;

    LOCK_APP(app);
    for (s = app->signalQueue; s != NULL && s != sid; s = s->se_next)
        last = s;
    if (s == NULL) {
        UNLOCK_APP(app);
        return;
    }
    if (last == NULL)
        app->signalQueue = s->se_next;
    else
        last->se_next = s->se_next;
    LOCK_PROCESS;
    s->se_next = freeSignalRecs;
    freeSignalRecs = s;
    UNLOCK_PROCESS;
    UNLOCK_APP(app);
}

void
XtNoticeSignal(XtSignalId id)
{
    /*
     * It would be overkill to lock the app to set this flag.
     * In the worst case, 2..n threads would be modifying this
     * flag. The last one wins. Since signals occur asynchronously
     * anyway, this can occur with or without threads.
     *
     * The other issue is that thread t1 sets the flag in a
     * signalrec that has been deleted in thread t2. We rely
     * on a detail of the implementation, i.e. free'd signalrecs
     * aren't really free'd, they're just moved to a list of
     * free recs, so deref'ing one won't hurt anything.
     *
     * Lastly, and perhaps most importantly, since POSIX threads
     * says that the handling of asynchronous signals in a synchronous
     * threads environment is undefined. Therefor it would be an
     * error for both signals and threads to be in use in the same
     * program.
     */
    SignalEventRec *sid = (SignalEventRec *) id;

    sid->se_notice = TRUE;
}

XtInputId
XtAddInput(int source,
           XtPointer Condition,
           XtInputCallbackProc proc,
           XtPointer closure)
{
    return XtAppAddInput(_XtDefaultAppContext(),
                         source, Condition, proc, closure);
}

XtInputId
XtAppAddInput(XtAppContext app,
              int source,
              XtPointer Condition,
              XtInputCallbackProc proc,
              XtPointer closure)
{
    InputEvent *sptr;
    XtInputMask condition = (XtInputMask) Condition;

    LOCK_APP(app);
    if (!condition ||
        condition & (unsigned
                     long) (~(XtInputReadMask | XtInputWriteMask |
                              XtInputExceptMask)))
        XtAppErrorMsg(app, "invalidParameter", "xtAddInput", XtCXtToolkitError,
                      "invalid condition passed to XtAppAddInput", NULL, NULL);

    if (app->input_max <= source) {
        Cardinal n = (Cardinal) (source + 1);
        int ii;

        app->input_list = (InputEvent **) XtRealloc((char *) app->input_list,
                                                    (Cardinal) ((size_t) n *
                                                                sizeof
                                                                (InputEvent
                                                                 *)));
        for (ii = app->input_max; ii < (int) n; ii++)
            app->input_list[ii] = (InputEvent *) NULL;
        app->input_max = (short) n;
    }
    sptr = XtNew(InputEvent);

    sptr->ie_proc = proc;
    sptr->ie_closure = closure;
    sptr->app = app;
    sptr->ie_oq = NULL;
    sptr->ie_source = source;
    sptr->ie_condition = condition;
    sptr->ie_next = app->input_list[source];
    app->input_list[source] = sptr;

#ifdef USE_POLL
    if (sptr->ie_next == NULL)
        app->fds.nfds++;
#else
    if (condition & XtInputReadMask)
        FD_SET(source, &app->fds.rmask);
    if (condition & XtInputWriteMask)
        FD_SET(source, &app->fds.wmask);
    if (condition & XtInputExceptMask)
        FD_SET(source, &app->fds.emask);

    if (app->fds.nfds < (source + 1))
        app->fds.nfds = source + 1;
#endif
    app->input_count++;
    app->rebuild_fdlist = TRUE;
    UNLOCK_APP(app);
    return ((XtInputId) sptr);
}

void
XtRemoveInput(register XtInputId id)
{
    register InputEvent *sptr, *lptr;
    XtAppContext app = ((InputEvent *) id)->app;
    register int source = ((InputEvent *) id)->ie_source;
    Boolean found = False;

    LOCK_APP(app);
    sptr = app->outstandingQueue;
    lptr = NULL;
    for (; sptr != NULL; sptr = sptr->ie_oq) {
        if (sptr == (InputEvent *) id) {
            if (lptr == NULL)
                app->outstandingQueue = sptr->ie_oq;
            else
                lptr->ie_oq = sptr->ie_oq;
        }
        lptr = sptr;
    }

    if (app->input_list && (sptr = app->input_list[source]) != NULL) {
        for (lptr = NULL; sptr; sptr = sptr->ie_next) {
            if (sptr == (InputEvent *) id) {
#ifndef USE_POLL
                XtInputMask condition = 0;
#endif
                if (lptr == NULL) {
                    app->input_list[source] = sptr->ie_next;
                }
                else {
                    lptr->ie_next = sptr->ie_next;
                }
#ifndef USE_POLL
                for (lptr = app->input_list[source]; lptr; lptr = lptr->ie_next)
                    condition |= lptr->ie_condition;
                if ((sptr->ie_condition & XtInputReadMask) &&
                    !(condition & XtInputReadMask))
                    FD_CLR(source, &app->fds.rmask);
                if ((sptr->ie_condition & XtInputWriteMask) &&
                    !(condition & XtInputWriteMask))
                    FD_CLR(source, &app->fds.wmask);
                if ((sptr->ie_condition & XtInputExceptMask) &&
                    !(condition & XtInputExceptMask))
                    FD_CLR(source, &app->fds.emask);
#endif
                XtFree((char *) sptr);
                found = True;
                break;
            }
            lptr = sptr;
        }
    }

    if (found) {
        app->input_count--;
#ifdef USE_POLL
        if (app->input_list[source] == NULL)
            app->fds.nfds--;
#endif
        app->rebuild_fdlist = TRUE;
    }
    else
        XtAppWarningMsg(app, "invalidProcedure", "inputHandler",
                        XtCXtToolkitError,
                        "XtRemoveInput: Input handler not found", NULL, NULL);
    UNLOCK_APP(app);
}

void
_XtRemoveAllInputs(XtAppContext app)
{
    int i;

    for (i = 0; i < app->input_max; i++) {
        InputEvent *ep = app->input_list[i];

        while (ep) {
            InputEvent *next = ep->ie_next;

            XtFree((char *) ep);
            ep = next;
        }
    }
    XtFree((char *) app->input_list);
}

/* Do alternate input and timer callbacks if there are any */

static void
DoOtherSources(XtAppContext app)
{
    TimerEventRec *te_ptr;
    InputEvent *ie_ptr;
    struct timeval cur_time;

#define DrainQueue() \
        for (ie_ptr = app->outstandingQueue; ie_ptr != NULL;) { \
            app->outstandingQueue = ie_ptr->ie_oq;              \
            ie_ptr ->ie_oq = NULL;                              \
            IeCallProc(ie_ptr);                                 \
            ie_ptr = app->outstandingQueue;                     \
        }
/*enddef*/
    DrainQueue();
    if (app->input_count > 0) {
        /* Call _XtWaitForSomething to get input queued up */
        (void) _XtWaitForSomething(app,
                                   TRUE, TRUE, FALSE, TRUE,
                                   FALSE, TRUE, (unsigned long *) NULL);
        DrainQueue();
    }
    if (app->timerQueue != NULL) {      /* check timeout queue */
        X_GETTIMEOFDAY(&cur_time);
        FIXUP_TIMEVAL(cur_time);
        while (IS_AT_OR_AFTER(app->timerQueue->te_timer_value, cur_time)) {
            te_ptr = app->timerQueue;
            app->timerQueue = te_ptr->te_next;
            te_ptr->te_next = NULL;
            if (te_ptr->te_proc != NULL)
                TeCallProc(te_ptr);
            LOCK_PROCESS;
            te_ptr->te_next = freeTimerRecs;
            freeTimerRecs = te_ptr;
            UNLOCK_PROCESS;
            if (app->timerQueue == NULL)
                break;
        }
    }
    if (app->signalQueue != NULL) {
        SignalEventRec *se_ptr = app->signalQueue;

        while (se_ptr != NULL) {
            if (se_ptr->se_notice) {
                se_ptr->se_notice = FALSE;
                if (se_ptr->se_proc != NULL)
                    SeCallProc(se_ptr);
            }
            se_ptr = se_ptr->se_next;
        }
    }
#undef DrainQueue
}

/* If there are any work procs, call them.  Return whether we did so */

static Boolean
CallWorkProc(XtAppContext app)
{
    register WorkProcRec *w = app->workQueue;
    Boolean delete;

    if (w == NULL)
        return FALSE;

    app->workQueue = w->next;

    delete = (*(w->proc)) (w->closure);

    if (delete) {
        LOCK_PROCESS;
        w->next = freeWorkRecs;
        freeWorkRecs = w;
        UNLOCK_PROCESS;
    }
    else {
        w->next = app->workQueue;
        app->workQueue = w;
    }
    return TRUE;
}

/*
 * XtNextEvent()
 * return next event;
 */

void
XtNextEvent(XEvent *event)
{
    XtAppNextEvent(_XtDefaultAppContext(), event);
}

void
_XtRefreshMapping(XEvent *event, _XtBoolean dispatch)
{
    XtPerDisplay pd;

    LOCK_PROCESS;
    pd = _XtGetPerDisplay(event->xmapping.display);

    if (event->xmapping.request != MappingPointer &&
        pd && pd->keysyms && (event->xmapping.serial >= pd->keysyms_serial))
        _XtBuildKeysymTables(event->xmapping.display, pd);

    XRefreshKeyboardMapping(&event->xmapping);
    if (dispatch && pd && pd->mapping_callbacks)
        XtCallCallbackList((Widget) NULL,
                           (XtCallbackList) pd->mapping_callbacks,
                           (XtPointer) event);
    UNLOCK_PROCESS;
}

void
XtAppNextEvent(XtAppContext app, XEvent *event)
{
    int i, d;

    LOCK_APP(app);
    for (;;) {
        if (app->count == 0)
            DoOtherSources(app);
        else {
            for (i = 1; i <= app->count; i++) {
                d = (i + app->last) % app->count;
                if (d == 0)
                    DoOtherSources(app);
                if (XEventsQueued(app->list[d], QueuedAfterReading))
                    goto GotEvent;
            }
            for (i = 1; i <= app->count; i++) {
                d = (i + app->last) % app->count;
                if (XEventsQueued(app->list[d], QueuedAfterFlush))
                    goto GotEvent;
            }
        }

        /* We're ready to wait...if there is a work proc, call it */
        if (CallWorkProc(app))
            continue;

        d = _XtWaitForSomething(app,
                                FALSE, FALSE, FALSE, FALSE,
                                TRUE, TRUE, (unsigned long *) NULL);

        if (d != -1) {
 GotEvent:
            XNextEvent(app->list[d], event);
            app->last = (short) d;
            if (event->xany.type == MappingNotify)
                _XtRefreshMapping(event, False);
            UNLOCK_APP(app);
            return;
        }

    }                           /* for */
}

void
XtProcessEvent(XtInputMask mask)
{
    XtAppProcessEvent(_XtDefaultAppContext(), mask);
}

void
XtAppProcessEvent(XtAppContext app, XtInputMask mask)
{
    int i, d;
    XEvent event;
    struct timeval cur_time;

    LOCK_APP(app);
    if (mask == 0) {
        UNLOCK_APP(app);
        return;
    }

    for (;;) {

        if (mask & XtIMSignal && app->signalQueue != NULL) {
            SignalEventRec *se_ptr = app->signalQueue;

            while (se_ptr != NULL) {
                if (se_ptr->se_notice) {
                    se_ptr->se_notice = FALSE;
                    SeCallProc(se_ptr);
                    UNLOCK_APP(app);
                    return;
                }
                se_ptr = se_ptr->se_next;
            }
        }

        if (mask & XtIMTimer && app->timerQueue != NULL) {
            X_GETTIMEOFDAY(&cur_time);
            FIXUP_TIMEVAL(cur_time);
            if (IS_AT_OR_AFTER(app->timerQueue->te_timer_value, cur_time)) {
                TimerEventRec *te_ptr = app->timerQueue;

                app->timerQueue = app->timerQueue->te_next;
                te_ptr->te_next = NULL;
                if (te_ptr->te_proc != NULL)
                    TeCallProc(te_ptr);
                LOCK_PROCESS;
                te_ptr->te_next = freeTimerRecs;
                freeTimerRecs = te_ptr;
                UNLOCK_PROCESS;
                UNLOCK_APP(app);
                return;
            }
        }

        if (mask & XtIMAlternateInput) {
            if (app->input_count > 0 && app->outstandingQueue == NULL) {
                /* Call _XtWaitForSomething to get input queued up */
                (void) _XtWaitForSomething(app,
                                           TRUE, TRUE, FALSE, TRUE,
                                           FALSE, TRUE, (unsigned long *) NULL);
            }
            if (app->outstandingQueue != NULL) {
                InputEvent *ie_ptr = app->outstandingQueue;

                app->outstandingQueue = ie_ptr->ie_oq;
                ie_ptr->ie_oq = NULL;
                IeCallProc(ie_ptr);
                UNLOCK_APP(app);
                return;
            }
        }

        if (mask & XtIMXEvent) {
            for (i = 1; i <= app->count; i++) {
                d = (i + app->last) % app->count;
                if (XEventsQueued(app->list[d], QueuedAfterReading))
                    goto GotEvent;
            }
            for (i = 1; i <= app->count; i++) {
                d = (i + app->last) % app->count;
                if (XEventsQueued(app->list[d], QueuedAfterFlush))
                    goto GotEvent;
            }
        }

        /* Nothing to do...wait for something */

        if (CallWorkProc(app))
            continue;

        d = _XtWaitForSomething(app,
                                ((mask & XtIMXEvent) ? FALSE : TRUE),
                                ((mask & XtIMTimer) ? FALSE : TRUE),
                                ((mask & XtIMAlternateInput) ? FALSE : TRUE),
                                ((mask & XtIMSignal) ? FALSE : TRUE),
                                TRUE, TRUE, (unsigned long *) NULL);

        if (mask & XtIMXEvent && d != -1) {
 GotEvent:
            XNextEvent(app->list[d], &event);
            app->last = (short) d;
            if (event.xany.type == MappingNotify) {
                _XtRefreshMapping(&event, False);
            }
            XtDispatchEvent(&event);
            UNLOCK_APP(app);
            return;
        }

    }
}

Boolean
XtPending(void)
{
    return (XtAppPending(_XtDefaultAppContext()) != 0);
}

XtInputMask
XtAppPending(XtAppContext app)
{
    struct timeval cur_time;
    int d;
    XtInputMask ret = 0;

/*
 * Check for pending X events
 */
    LOCK_APP(app);
    for (d = 0; d < app->count; d++) {
        if (XEventsQueued(app->list[d], QueuedAfterReading)) {
            ret = XtIMXEvent;
            break;
        }
    }
    if (ret == 0) {
        for (d = 0; d < app->count; d++) {
            if (XEventsQueued(app->list[d], QueuedAfterFlush)) {
                ret = XtIMXEvent;
                break;
            }
        }
    }

    if (app->signalQueue != NULL) {
        SignalEventRec *se_ptr = app->signalQueue;

        while (se_ptr != NULL) {
            if (se_ptr->se_notice) {
                ret |= XtIMSignal;
                break;
            }
            se_ptr = se_ptr->se_next;
        }
    }

/*
 * Check for pending alternate input
 */
    if (app->timerQueue != NULL) {      /* check timeout queue */
        X_GETTIMEOFDAY(&cur_time);
        FIXUP_TIMEVAL(cur_time);
        if ((IS_AT_OR_AFTER(app->timerQueue->te_timer_value, cur_time)) &&
            (app->timerQueue->te_proc != NULL)) {
            ret |= XtIMTimer;
        }
    }

    if (app->outstandingQueue != NULL)
        ret |= XtIMAlternateInput;
    else {
        /* This won't cause a wait, but will enqueue any input */

        if (_XtWaitForSomething(app,
                                FALSE, TRUE, FALSE, TRUE,
                                FALSE, TRUE, (unsigned long *) NULL) != -1)
            ret |= XtIMXEvent;
        if (app->outstandingQueue != NULL)
            ret |= XtIMAlternateInput;
    }
    UNLOCK_APP(app);
    return ret;
}

/* Peek at alternate input and timer callbacks if there are any */

static Boolean
PeekOtherSources(XtAppContext app)
{
    struct timeval cur_time;

    if (app->outstandingQueue != NULL)
        return TRUE;

    if (app->signalQueue != NULL) {
        SignalEventRec *se_ptr = app->signalQueue;

        while (se_ptr != NULL) {
            if (se_ptr->se_notice)
                return TRUE;
            se_ptr = se_ptr->se_next;
        }
    }

    if (app->input_count > 0) {
        /* Call _XtWaitForSomething to get input queued up */
        (void) _XtWaitForSomething(app,
                                   TRUE, TRUE, FALSE, TRUE,
                                   FALSE, TRUE, (unsigned long *) NULL);
        if (app->outstandingQueue != NULL)
            return TRUE;
    }

    if (app->timerQueue != NULL) {      /* check timeout queue */
        X_GETTIMEOFDAY(&cur_time);
        FIXUP_TIMEVAL(cur_time);
        if (IS_AT_OR_AFTER(app->timerQueue->te_timer_value, cur_time))
            return TRUE;
    }

    return FALSE;
}

Boolean
XtPeekEvent(XEvent *event)
{
    return XtAppPeekEvent(_XtDefaultAppContext(), event);
}

Boolean XtAppPeekEvent_SkipTimer;

Boolean
XtAppPeekEvent(XtAppContext app, XEvent *event)
{
    int i, d;
    Boolean foundCall = FALSE;

    LOCK_APP(app);
    for (i = 1; i <= app->count; i++) {
        d = (i + app->last) % app->count;
        if (d == 0)
            foundCall = PeekOtherSources(app);
        if (XEventsQueued(app->list[d], QueuedAfterReading))
            goto GotEvent;
    }
    for (i = 1; i <= app->count; i++) {
        d = (i + app->last) % app->count;
        if (XEventsQueued(app->list[d], QueuedAfterFlush))
            goto GotEvent;
    }

    if (foundCall) {
        event->xany.type = 0;
        event->xany.display = NULL;

        event->xany.window = 0;
        UNLOCK_APP(app);
        return FALSE;
    }

    while (1) {
        d = _XtWaitForSomething(app,
                                FALSE, FALSE, FALSE, FALSE,
                                TRUE, TRUE, (unsigned long *) NULL);

        if (d != -1) {          /* event */
 GotEvent:
            XPeekEvent(app->list[d], event);
            app->last = (short) ((d == 0 ? app->count : d) - 1);
            UNLOCK_APP(app);
            return TRUE;
        }
        else {                  /* input or timer or signal */
            /*
             * Check to see why a -1 was returned, if a timer expired,
             * call it and block some more
             */
            if ((app->timerQueue != NULL) && !XtAppPeekEvent_SkipTimer) {       /* timer */
                struct timeval cur_time;
                Bool did_timer = False;

                X_GETTIMEOFDAY(&cur_time);
                FIXUP_TIMEVAL(cur_time);
                while (IS_AT_OR_AFTER
                       (app->timerQueue->te_timer_value, cur_time)) {
                    TimerEventRec *te_ptr = app->timerQueue;

                    app->timerQueue = app->timerQueue->te_next;
                    te_ptr->te_next = NULL;
                    if (te_ptr->te_proc != NULL) {
                        TeCallProc(te_ptr);
                        did_timer = True;
                    }
                    LOCK_PROCESS;
                    te_ptr->te_next = freeTimerRecs;
                    freeTimerRecs = te_ptr;
                    UNLOCK_PROCESS;
                    if (app->timerQueue == NULL)
                        break;
                }
                if (did_timer) {
                    for (d = 0; d < app->count; d++)
                        /* the timer's procedure may have caused an event */
                        if (XEventsQueued(app->list[d], QueuedAfterFlush)) {
                            goto GotEvent;
                        }
                    continue;   /* keep blocking */
                }
            }
            /*
             * spec is vague here; we'll assume signals also return FALSE,
             * of course to determine whether a signal is pending requires
             * walking the signalQueue looking for se_notice flags which
             * this code doesn't do.
             */
#if 0
            if (app->signalQueue != NULL) {     /* signal */
                event->xany.type = 0;
                event->xany.display = NULL;

                event->xany.window = 0;
                UNLOCK_APP(app);
                return FALSE;
            }
            else
#endif
            {                   /* input */
                event->xany.type = 0;
                event->xany.display = NULL;

                event->xany.window = 0;
                UNLOCK_APP(app);
                return FALSE;
            }
        }
    }                           /* end while */
}
