Return to select.c CVS log

Up to [Research Unix] / researchv10no / ncurses / screen

Annotation of researchv10no/ncurses/screen/select.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Code for various kinds of delays.  Most of this is nonportable and
                      3:  * requires various enhancements to the operating system, so it won't
                      4:  * work on all systems.  It is included in curses to provide a portable
                      5:  * interface, and so curses itself can use it for function keys.
                      6:  */
                      7: 
                      8: /*     @(#) select.c: 1.1 10/15/83     (1.10   3/6/83) */
                      9: 
                     10: #include "curses.ext"
                     11: #include <signal.h>
                     12: 
                     13: #define NAPINTERVAL 100
                     14: 
                     15: /* From early specs - this may change by 4.2BSD */
                     16: struct _timeval {
                     17:        long tv_sec;
                     18:        long tv_usec;
                     19: };
                     20: 
                     21: #ifdef FIONREAD
                     22: # ifndef TIOCREMOTE
                     23: /*
                     24:  * Decide if we can emulate select but don't have it.  This is
                     25:  * intended to be true only on 4.1BSD, not 4.2BSD or USG.
                     26:  */
                     27: #  define NEEDSELECT
                     28: # endif
                     29: #endif
                     30: 
                     31: #ifdef NEEDSELECT
                     32: /*
                     33:  * Emulation of 4.2BSD select system call.  This is somewhat crude but
                     34:  * better than nothing.  We do FIONREAD on each fd, and if we have to
                     35:  * wait we use nap to avoid a busy wait.  The resolution of the nap
                     36:  * will hurt response - so will the fact that we ignore the write fds.
                     37:  * If we are simulating nap with a 1 second sleep, this will be very poor.
                     38:  *
                     39:  * nfds is the number of fds to check - this is usually 20.
                     40:  * prfds is a pointer to a bit vector of file descriptors - in the case
                     41:  *     where nfds < 32, prfds points to an integer, where bit 1<<fd
                     42:  *     is 1 if we are supposed to check file descriptor fd.
                     43:  * pwfds is like prfds but for write checks instead of read checks.
                     44:  * ms is the max number of milliseconds to wait before returning failure.
                     45:  * The value returned is the number of file descriptors ready for input.
                     46:  * The bit vectors are updated in place.
                     47:  */
                     48: 
                     49: int
                     50: select(nfds, prfds, pwfds, pefds, timeout)
                     51: register int nfds;
                     52: int *prfds, *pwfds, *pefds;
                     53: struct _timeval *timeout;
                     54: {
                     55:        register int fd;
                     56:        register int rfds = *prfds;
                     57:        register int n;
                     58:        int nwaiting, rv = 0;
                     59:        long ms = timeout->tv_sec * 1000 + timeout->tv_usec / 1000;
                     60: 
                     61:        for (;;) {
                     62:                /* check the fds */
                     63:                for (fd=0; fd<nfds; fd++)
                     64:                        if (1<<fd & rfds) {
                     65:                                ioctl(fd, FIONREAD, &nwaiting);
                     66:                                if (nwaiting > 0) {
                     67:                                        rv++;
                     68:                                } else
                     69:                                        *prfds &= ~(1<<fd);
                     70:                        }
                     71:                if (rv)
                     72:                        return rv;
                     73: 
                     74:                /* Nothing ready.  Should we give up? */
                     75:                if (ms <= 0)
                     76:                        return 0;
                     77: 
                     78:                *prfds = rfds;  /* we clobbered it, so restore. */
                     79: 
                     80:                /* Wait a bit */
                     81:                n = NAPINTERVAL;
                     82:                if (ms < NAPINTERVAL)
                     83:                        n = ms;
                     84:                ms -= n;
                     85:                napms(n);
                     86:        }
                     87: }
                     88: #else
                     89: #ifndef FIONREAD
                     90: int
                     91: select(nfds, prfds, pwfds, pefds, ms)
                     92: register int nfds;
                     93: int *prfds, *pwfds, *pefds;
                     94: struct _timeval *ms;
                     95: {
                     96:        /* Can't do it, but at least compile right */
                     97:        return ERR;
                     98: }
                     99: #endif FIONREAD
                    100: #endif NEEDSELECT

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.