+inline void
+wlist_del (WL *head, WL elem)
+{
+ while (*head)
+ {
+ if (*head == elem)
+ {
+ *head = elem->next;
+ return;
+ }
+
+ head = &(*head)->next;
+ }
+}
+
+inline void
+ev_clear_pending (EV_P_ W w)
+{
+ if (w->pending)
+ {
+ pendings [ABSPRI (w)][w->pending - 1].w = 0;
+ w->pending = 0;
+ }
+}
+
+inline void
+ev_start (EV_P_ W w, int active)
+{
+ if (w->priority < EV_MINPRI) w->priority = EV_MINPRI;
+ if (w->priority > EV_MAXPRI) w->priority = EV_MAXPRI;
+
+ w->active = active;
+ ev_ref (EV_A);
+}
+
+inline void
+ev_stop (EV_P_ W w)
+{
+ ev_unref (EV_A);
+ w->active = 0;
+}
+
+/*****************************************************************************/
+
+void
+ev_io_start (EV_P_ struct ev_io *w)
+{
+ int fd = w->fd;
+
+ if (ev_is_active (w))
+ return;
+
+ assert (("ev_io_start called with negative fd", fd >= 0));
+
+ ev_start (EV_A_ (W)w, 1);
+ array_needsize (anfds, anfdmax, fd + 1, anfds_init);
+ wlist_add ((WL *)&anfds[fd].head, (WL)w);
+
+ fd_change (EV_A_ fd);
+}
+
+void
+ev_io_stop (EV_P_ struct ev_io *w)
+{
+ ev_clear_pending (EV_A_ (W)w);
+ if (!ev_is_active (w))
+ return;
+
+ wlist_del ((WL *)&anfds[w->fd].head, (WL)w);
+ ev_stop (EV_A_ (W)w);
+
+ fd_change (EV_A_ w->fd);
+}
+
+void
+ev_timer_start (EV_P_ struct ev_timer *w)
+{
+ if (ev_is_active (w))
+ return;
+
+ ((WT)w)->at += mn_now;
+
+ assert (("ev_timer_start called with negative timer repeat value", w->repeat >= 0.));
+
+ ev_start (EV_A_ (W)w, ++timercnt);
+ array_needsize (timers, timermax, timercnt, );
+ timers [timercnt - 1] = w;
+ upheap ((WT *)timers, timercnt - 1);
+
+ assert (("internal timer heap corruption", timers [((W)w)->active - 1] == w));
+}
+
+void
+ev_timer_stop (EV_P_ struct ev_timer *w)
+{
+ ev_clear_pending (EV_A_ (W)w);
+ if (!ev_is_active (w))
+ return;
+
+ assert (("internal timer heap corruption", timers [((W)w)->active - 1] == w));
+
+ if (((W)w)->active < timercnt--)
+ {
+ timers [((W)w)->active - 1] = timers [timercnt];
+ downheap ((WT *)timers, timercnt, ((W)w)->active - 1);
+ }
+
+ ((WT)w)->at = w->repeat;
+
+ ev_stop (EV_A_ (W)w);
+}
+
+void
+ev_timer_again (EV_P_ struct ev_timer *w)
+{
+ if (ev_is_active (w))
+ {
+ if (w->repeat)
+ {
+ ((WT)w)->at = mn_now + w->repeat;
+ downheap ((WT *)timers, timercnt, ((W)w)->active - 1);
+ }
+ else
+ ev_timer_stop (EV_A_ w);
+ }
+ else if (w->repeat)
+ ev_timer_start (EV_A_ w);
+}
+
+void
+ev_periodic_start (EV_P_ struct ev_periodic *w)
+{
+ if (ev_is_active (w))
+ return;
+
+ assert (("ev_periodic_start called with negative interval value", w->interval >= 0.));
+
+ /* this formula differs from the one in periodic_reify because we do not always round up */
+ if (w->interval)
+ ((WT)w)->at += ceil ((rt_now - ((WT)w)->at) / w->interval) * w->interval;
+
+ ev_start (EV_A_ (W)w, ++periodiccnt);
+ array_needsize (periodics, periodicmax, periodiccnt, );
+ periodics [periodiccnt - 1] = w;
+ upheap ((WT *)periodics, periodiccnt - 1);
+
+ assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == w));
+}
+
+void
+ev_periodic_stop (EV_P_ struct ev_periodic *w)
+{
+ ev_clear_pending (EV_A_ (W)w);
+ if (!ev_is_active (w))
+ return;
+
+ assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == w));
+
+ if (((W)w)->active < periodiccnt--)
+ {
+ periodics [((W)w)->active - 1] = periodics [periodiccnt];
+ downheap ((WT *)periodics, periodiccnt, ((W)w)->active - 1);
+ }
+
+ ev_stop (EV_A_ (W)w);
+}
+
+void
+ev_idle_start (EV_P_ struct ev_idle *w)
+{
+ if (ev_is_active (w))
+ return;
+
+ ev_start (EV_A_ (W)w, ++idlecnt);
+ array_needsize (idles, idlemax, idlecnt, );
+ idles [idlecnt - 1] = w;
+}
+
+void
+ev_idle_stop (EV_P_ struct ev_idle *w)
+{
+ ev_clear_pending (EV_A_ (W)w);
+ if (ev_is_active (w))
+ return;
+
+ idles [((W)w)->active - 1] = idles [--idlecnt];
+ ev_stop (EV_A_ (W)w);
+}
+
+void
+ev_prepare_start (EV_P_ struct ev_prepare *w)
+{
+ if (ev_is_active (w))
+ return;
+
+ ev_start (EV_A_ (W)w, ++preparecnt);
+ array_needsize (prepares, preparemax, preparecnt, );
+ prepares [preparecnt - 1] = w;
+}
+
+void
+ev_prepare_stop (EV_P_ struct ev_prepare *w)
+{
+ ev_clear_pending (EV_A_ (W)w);
+ if (ev_is_active (w))
+ return;
+
+ prepares [((W)w)->active - 1] = prepares [--preparecnt];
+ ev_stop (EV_A_ (W)w);
+}
+
+void
+ev_check_start (EV_P_ struct ev_check *w)
+{
+ if (ev_is_active (w))
+ return;
+
+ ev_start (EV_A_ (W)w, ++checkcnt);
+ array_needsize (checks, checkmax, checkcnt, );
+ checks [checkcnt - 1] = w;
+}
+
+void
+ev_check_stop (EV_P_ struct ev_check *w)
+{
+ ev_clear_pending (EV_A_ (W)w);
+ if (ev_is_active (w))
+ return;
+
+ checks [((W)w)->active - 1] = checks [--checkcnt];
+ ev_stop (EV_A_ (W)w);
+}
+
+#ifndef SA_RESTART
+# define SA_RESTART 0
+#endif
+
+void
+ev_signal_start (EV_P_ struct ev_signal *w)
+{
+#if EV_MULTIPLICITY
+ assert (("signal watchers are only supported in the default loop", loop == default_loop));
+#endif
+ if (ev_is_active (w))
+ return;
+
+ assert (("ev_signal_start called with illegal signal number", w->signum > 0));
+
+ ev_start (EV_A_ (W)w, 1);
+ array_needsize (signals, signalmax, w->signum, signals_init);
+ wlist_add ((WL *)&signals [w->signum - 1].head, (WL)w);
+
+ if (!((WL)w)->next)
+ {
+#if WIN32
+ signal (w->signum, sighandler);
+#else
+ struct sigaction sa;
+ sa.sa_handler = sighandler;
+ sigfillset (&sa.sa_mask);
+ sa.sa_flags = SA_RESTART; /* if restarting works we save one iteration */
+ sigaction (w->signum, &sa, 0);
+#endif
+ }
+}
+
+void
+ev_signal_stop (EV_P_ struct ev_signal *w)
+{
+ ev_clear_pending (EV_A_ (W)w);
+ if (!ev_is_active (w))
+ return;
+
+ wlist_del ((WL *)&signals [w->signum - 1].head, (WL)w);
+ ev_stop (EV_A_ (W)w);
+
+ if (!signals [w->signum - 1].head)
+ signal (w->signum, SIG_DFL);
+}
+
+void
+ev_child_start (EV_P_ struct ev_child *w)
+{
+#if EV_MULTIPLICITY
+ assert (("child watchers are only supported in the default loop", loop == default_loop));
+#endif
+ if (ev_is_active (w))
+ return;
+
+ ev_start (EV_A_ (W)w, 1);
+ wlist_add ((WL *)&childs [w->pid & (PID_HASHSIZE - 1)], (WL)w);
+}
+
+void
+ev_child_stop (EV_P_ struct ev_child *w)
+{
+ ev_clear_pending (EV_A_ (W)w);
+ if (ev_is_active (w))
+ return;
+
+ wlist_del ((WL *)&childs [w->pid & (PID_HASHSIZE - 1)], (WL)w);
+ ev_stop (EV_A_ (W)w);
+}
+
+/*****************************************************************************/
+
+struct ev_once
+{
+ struct ev_io io;
+ struct ev_timer to;
+ void (*cb)(int revents, void *arg);
+ void *arg;
+};
+
+static void
+once_cb (EV_P_ struct ev_once *once, int revents)
+{
+ void (*cb)(int revents, void *arg) = once->cb;
+ void *arg = once->arg;
+
+ ev_io_stop (EV_A_ &once->io);
+ ev_timer_stop (EV_A_ &once->to);
+ ev_free (once);
+
+ cb (revents, arg);
+}
+
+static void
+once_cb_io (EV_P_ struct ev_io *w, int revents)
+{
+ once_cb (EV_A_ (struct ev_once *)(((char *)w) - offsetof (struct ev_once, io)), revents);
+}
+
+static void
+once_cb_to (EV_P_ struct ev_timer *w, int revents)
+{
+ once_cb (EV_A_ (struct ev_once *)(((char *)w) - offsetof (struct ev_once, to)), revents);
+}
+
+void
+ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg)
+{
+ struct ev_once *once = ev_malloc (sizeof (struct ev_once));
+
+ if (!once)
+ cb (EV_ERROR | EV_READ | EV_WRITE | EV_TIMEOUT, arg);
+ else
+ {
+ once->cb = cb;
+ once->arg = arg;
+
+ ev_watcher_init (&once->io, once_cb_io);
+ if (fd >= 0)
+ {
+ ev_io_set (&once->io, fd, events);
+ ev_io_start (EV_A_ &once->io);
+ }
+
+ ev_watcher_init (&once->to, once_cb_to);
+ if (timeout >= 0.)
+ {
+ ev_timer_set (&once->to, timeout, 0.);
+ ev_timer_start (EV_A_ &once->to);
+ }
+ }
+}
projects / software / libev.git / blobdiff