--- rxvt-unicode/src/iom.C 2003/11/25 15:25:17 1.2 +++ rxvt-unicode/src/iom.C 2004/01/29 23:26:01 1.12 @@ -1,6 +1,6 @@ /* iom.C -- generic I/O multiplexor - Copyright (C) 2003 Marc Lehmann + Copyright (C) 2003, 2004 Marc Lehmann This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -17,60 +17,105 @@ Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -#include "../config.h" - #include +#include +#include -#include #include +#if 1 // older unices need these includes for select(2) +# include +# include +#endif + +// if the BSDs would at least be marginally POSIX-compatible.. *sigh* +// until that happens, sys/select.h must come last +#include + #include "iom.h" +// TSTAMP_MAX must still fit into a positive struct timeval +#define TSTAMP_MAX (double)(1UL<<31) + +// this is a dummy time watcher to ensure that the first +// time watcher is _always_ valid, this gets rid of a lot +// of null-pointer-checks +// (must come _before_ iom is being defined) +static struct tw0 : time_watcher { + void cb (time_watcher &w) + { + // should never get called + // reached end-of-time, or tstamp has a bogus definition, + // or compiler initilization order broken, or somethine else :) + abort (); + } + + tw0() + : time_watcher (this, &tw0::cb) + { } +} tw0; + tstamp NOW; -bool iom_valid; +static bool iom_valid; io_manager iom; -void time_watcher::trigger () +template +void io_manager::reg (watcher *w, io_manager_vec &queue) { - call (*this); - - iom.reg (this); -} + if (!iom_valid) + abort (); -time_watcher::~time_watcher () -{ - if (iom_valid) - iom.unreg (this); + if (!w->active) + { +#if IOM_CHECK + queue.activity = true; +#endif + queue.push_back (w); + w->active = queue.size (); + } } -io_watcher::~io_watcher () +template +void io_manager::unreg (watcher *w, io_manager_vec &queue) { - if (iom_valid) - iom.unreg (this); -} + if (!iom_valid) + return; -void io_manager::reg (io_watcher *w) -{ - if (find (iow.begin (), iow.end (), w) == iow.end ()) - iow.push_back (w); + if (w->active) + { + queue [w->active - 1] = 0; + w->active = 0; + } } -void io_manager::unreg (io_watcher *w) +#if IOM_TIME +void time_watcher::trigger () { - iow.erase (find (iow.begin (), iow.end (), w)); -} + call (*this); -void io_manager::reg (time_watcher *w) -{ - if (find (tw.begin (), tw.end (), w) == tw.end ()) - tw.push_back (w); + iom.reg (this); } -void io_manager::unreg (time_watcher *w) -{ - tw.erase (find (tw.begin (), tw.end (), w)); -} +void io_manager::reg (time_watcher *w) { reg (w, tw); } +void io_manager::unreg (time_watcher *w) { unreg (w, tw); } +#endif + +#if IOM_IO +void io_manager::reg (io_watcher *w) { reg (w, iow); } +void io_manager::unreg (io_watcher *w) { unreg (w, iow); } +#endif + +#if IOM_CHECK +void io_manager::reg (check_watcher *w) { reg (w, cw); } +void io_manager::unreg (check_watcher *w) { unreg (w, cw); } +#endif + +#if IOM_IDLE +void io_manager::reg (idle_watcher *w) { reg (w, iw); } +void io_manager::unreg (idle_watcher *w) { unreg (w, iw); } +#endif +#if IOM_TIME inline void set_now (void) { struct timeval tv; @@ -78,86 +123,154 @@ gettimeofday (&tv, 0); NOW = (tstamp)tv.tv_sec + (tstamp)tv.tv_usec / 1000000; +#endif } void io_manager::loop () { +#if IOM_TIME set_now (); +#endif for (;;) { - time_watcher *w; + struct timeval *to = 0; + struct timeval tval; - for (;;) +#if IOM_IDLE + if (iw.size ()) + { + tval.tv_sec = 0; + tval.tv_usec = 0; + to = &tval; + } + else +#endif { - w = tw[0]; +#if IOM_TIME + time_watcher *next; - for (time_watcher **i = tw.begin (); i != tw.end (); ++i) - if ((*i)->at < w->at) - w = *i; + for (;;) + { + next = tw[0]; // the first time-watcher must exist at ALL times + + for (int i = tw.size (); i--; ) + if (!tw[i]) + tw.erase_unordered (i); + else if (tw[i]->at < next->at) + next = tw[i]; + + if (next->at > NOW) + { + if (next != tw[0]) + { + double diff = next->at - NOW; + tval.tv_sec = (int)diff; + tval.tv_usec = (int)((diff - tval.tv_sec) * 1000000); + to = &tval; + } + break; + } + else + { + unreg (next); + next->call (*next); + } + } +#endif + } - if (w->at > NOW) - break; +#if IOM_CHECK + tw.activity = false; - // call it - w->call (*w); + for (int i = cw.size (); i--; ) + if (!cw[i]) + cw.erase_unordered (i); + else + cw[i]->call (*cw[i]); - // re-add it if necessary - if (w->at >= 0) - reg (w); + if (tw.activity) + { + tval.tv_sec = 0; + tval.tv_usec = 0; + to = &tval; } +#endif - struct timeval to; - double diff = w->at - NOW; - to.tv_sec = (int)diff; - to.tv_usec = (int)((diff - to.tv_sec) * 1000000); - - fd_set rfd, wfd; +#if IOM_IO + fd_set rfd, wfd, efd; FD_ZERO (&rfd); FD_ZERO (&wfd); int fds = 0; - for (io_watcher **w = iow.begin (); w < iow.end (); ++w) - { - if ((*w)->events & EVENT_READ ) FD_SET ((*w)->fd, &rfd); - if ((*w)->events & EVENT_WRITE) FD_SET ((*w)->fd, &wfd); + for (io_manager_vec::iterator i = iow.end (); i-- > iow.begin (); ) + if (*i) + { + if ((*i)->events & EVENT_READ ) FD_SET ((*i)->fd, &rfd); + if ((*i)->events & EVENT_WRITE) FD_SET ((*i)->fd, &wfd); - if ((*w)->fd > fds) fds = (*w)->fd; - } + if ((*i)->fd >= fds) fds = (*i)->fd + 1; + } - fds = select (fds + 1, &rfd, &wfd, 0, &to); + if (!to && !fds) //TODO: also check idle_watchers and check_watchers + break; // no events + fds = select (fds, &rfd, &wfd, &efd, to); +# if IOM_TIME set_now (); +# endif if (fds > 0) - for (io_watcher **w = iow.begin (); w < iow.end (); ++w) - { - short revents = (*w)->events; - - if (!FD_ISSET ((*w)->fd, &rfd)) revents &= ~EVENT_READ; - if (!FD_ISSET ((*w)->fd, &wfd)) revents &= ~EVENT_WRITE; + for (int i = iow.size (); i--; ) + if (!iow[i]) + iow.erase_unordered (i); + else + { + short revents = iow[i]->events; + + if (!FD_ISSET (iow[i]->fd, &rfd)) revents &= ~EVENT_READ; + if (!FD_ISSET (iow[i]->fd, &wfd)) revents &= ~EVENT_WRITE; + + if (revents) + iow[i]->call (*iow[i], revents); + } + else if (fds < 0 && errno != EINTR) + { + perror ("Error while waiting for I/O or time event"); + abort (); + } +#if IOM_IDLE + else + for (int i = iw.size (); i--; ) + if (!iw[i]) + iw.erase_unordered (i); + else + iw[i]->call (*iw[i]); +#endif + +#elif IOM_TIME + if (!to) + break; - if (revents) - (*w)->call (**w, revents); - } + select (0, 0, 0, 0, &to); + set_now (); +#else + break; +#endif } } -void io_manager::idle_cb (time_watcher &w) -{ - w.at = NOW + 1000000000; -} - io_manager::io_manager () { - set_now (); - iom_valid = true; - idle = new time_watcher (this, &io_manager::idle_cb); - idle->start (0); +#if IOM_TIME + set_now (); + + tw0.start (TSTAMP_MAX); +#endif } io_manager::~io_manager ()