*** empty log message ***

[software/libev.git] / ev.c

diff --git a/ev.c b/ev.c
index 9d3a1302c0c9821a5ec9145b3e88470d1531e5e8..7995b34005258fadf4a96db371db620f17a8f822 100644 (file)
--- a/ev.c
+++ b/ev.c
@@ -1,4 +1,6 @@
 /*
 /*

+ * libev event processing core, watcher management
+ *

  * Copyright (c) 2007 Marc Alexander Lehmann <libev@schmorp.de>
  * All rights reserved.
  *
  * Copyright (c) 2007 Marc Alexander Lehmann <libev@schmorp.de>
  * All rights reserved.
  *


@@ -26,6 +28,9 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

+#if EV_USE_CONFIG_H
+# include "config.h"
+#endif

 
 #include <math.h>
 #include <stdlib.h>
 
 #include <math.h>
 #include <stdlib.h>


@@ -43,27 +48,31 @@
 #include <sys/time.h>
 #include <time.h>
 
 #include <sys/time.h>
 #include <time.h>
 

-#ifndef HAVE_MONOTONIC
+#ifndef EV_USE_MONOTONIC

 # ifdef CLOCK_MONOTONIC
 # ifdef CLOCK_MONOTONIC

-#  define HAVE_MONOTONIC 1
+#  define EV_USE_MONOTONIC 1

 # endif
 #endif
 
 # endif
 #endif
 

-#ifndef HAVE_SELECT
-# define HAVE_SELECT 1
+#ifndef EV_USE_SELECT
+# define EV_USE_SELECT 1

 #endif
 
 #endif
 

-#ifndef HAVE_EPOLL
-# define HAVE_EPOLL 0
+#ifndef EV_USE_EPOLL
+# define EV_USE_EPOLL 0

 #endif
 
 #endif
 

-#ifndef HAVE_REALTIME
-# define HAVE_REALTIME 1 /* posix requirement, but might be slower */
+#ifndef CLOCK_REALTIME
+# define EV_USE_REALTIME 0
+#endif
+#ifndef EV_USE_REALTIME
+# define EV_USE_REALTIME 1 /* posix requirement, but might be slower */

 #endif
 
 #define MIN_TIMEJUMP  1. /* minimum timejump that gets detected (if monotonic clock available) */
 #endif
 
 #define MIN_TIMEJUMP  1. /* minimum timejump that gets detected (if monotonic clock available) */

-#define MAX_BLOCKTIME 60.
-#define PID_HASHSIZE  16 /* size of pid hahs table, must be power of two */
+#define MAX_BLOCKTIME 59.731 /* never wait longer than this time (to detetc time jumps) */
+#define PID_HASHSIZE  16 /* size of pid hash table, must be power of two */
+#define CLEANUP_INTERVAL (MAX_BLOCKTIME * 5.) /* how often to try to free memory and re-check fds */

 
 #include "ev.h"
 
 
 #include "ev.h"
 


@@ -86,7 +95,7 @@ static void (*method_poll)(ev_tstamp timeout);
 ev_tstamp
 ev_time (void)
 {
 ev_tstamp
 ev_time (void)
 {

-#if HAVE_REALTIME
+#if EV_USE_REALTIME

   struct timespec ts;
   clock_gettime (CLOCK_REALTIME, &ts);
   return ts.tv_sec + ts.tv_nsec * 1e-9;
   struct timespec ts;
   clock_gettime (CLOCK_REALTIME, &ts);
   return ts.tv_sec + ts.tv_nsec * 1e-9;


@@ -100,7 +109,7 @@ ev_time (void)
 static ev_tstamp
 get_clock (void)
 {
 static ev_tstamp
 get_clock (void)
 {

-#if HAVE_MONOTONIC
+#if EV_USE_MONOTONIC

   if (have_monotonic)
     {
       struct timespec ts;
   if (have_monotonic)
     {
       struct timespec ts;


@@ -112,13 +121,15 @@ get_clock (void)
   return ev_time ();
 }
 
   return ev_time ();
 }
 

+#define array_roundsize(base,n) ((n) | 4 & ~3)
+

 #define array_needsize(base,cur,cnt,init)              \
   if ((cnt) > cur)                                     \
     {                                                  \
       int newcnt = cur;                                        \
       do                                               \
         {                                              \
 #define array_needsize(base,cur,cnt,init)              \
   if ((cnt) > cur)                                     \
     {                                                  \
       int newcnt = cur;                                        \
       do                                               \
         {                                              \

-          newcnt = (newcnt << 1) | 4 & ~3;             \
+          newcnt = array_roundsize (base, newcnt << 1);        \

         }                                              \
       while ((cnt) > newcnt);                          \
                                                        \
         }                                              \
       while ((cnt) > newcnt);                          \
                                                        \


@@ -132,7 +143,8 @@ get_clock (void)
 typedef struct
 {
   struct ev_io *head;
 typedef struct
 {
   struct ev_io *head;

-  int events;
+  unsigned char events;
+  unsigned char reify;

 } ANFD;
 
 static ANFD *anfds;
 } ANFD;
 
 static ANFD *anfds;


@@ -145,6 +157,8 @@ anfds_init (ANFD *base, int count)
     {
       base->head   = 0;
       base->events = EV_NONE;
     {
       base->head   = 0;
       base->events = EV_NONE;

+      base->reify  = 0;
+

       ++base;
     }
 }
       ++base;
     }
 }


@@ -161,13 +175,16 @@ static int pendingmax, pendingcnt;
 static void
 event (W w, int events)
 {
 static void
 event (W w, int events)
 {

-  if (w->active)
+  if (w->pending)

     {
     {

-      w->pending = ++pendingcnt;
-      array_needsize (pendings, pendingmax, pendingcnt, );
-      pendings [pendingcnt - 1].w      = w;
-      pendings [pendingcnt - 1].events = events;
+      pendings [w->pending - 1].events |= events;
+      return;

     }
     }

+
+  w->pending = ++pendingcnt;
+  array_needsize (pendings, pendingmax, pendingcnt, );
+  pendings [pendingcnt - 1].w      = w;
+  pendings [pendingcnt - 1].events = events;

 }
 
 static void
 }
 
 static void


@@ -215,7 +232,7 @@ fd_reify (void)
       for (w = anfd->head; w; w = w->next)
         events |= w->events;
 
       for (w = anfd->head; w; w = w->next)
         events |= w->events;
 

-      anfd->events &= ~EV_REIFY;
+      anfd->reify = 0;

 
       if (anfd->events != events)
         {
 
       if (anfd->events != events)
         {


@@ -230,10 +247,10 @@ fd_reify (void)
 static void
 fd_change (int fd)
 {
 static void
 fd_change (int fd)
 {

-  if (anfds [fd].events & EV_REIFY)
+  if (anfds [fd].reify || fdchangecnt < 0)

     return;
 
     return;
 

-  anfds [fd].events |= EV_REIFY;
+  anfds [fd].reify = 1;

 
   ++fdchangecnt;
   array_needsize (fdchanges, fdchangemax, fdchangecnt, );
 
   ++fdchangecnt;
   array_needsize (fdchanges, fdchangemax, fdchangecnt, );


@@ -251,8 +268,8 @@ fd_recheck (void)
       if (fcntl (fd, F_GETFD) == -1 && errno == EBADF)
         while (anfds [fd].head)
           {
       if (fcntl (fd, F_GETFD) == -1 && errno == EBADF)
         while (anfds [fd].head)
           {

-            event ((W)anfds [fd].head, EV_ERROR);
-            evio_stop (anfds [fd].head);
+            ev_io_stop (anfds [fd].head);
+            event ((W)anfds [fd].head, EV_ERROR | EV_READ | EV_WRITE);

           }
 }
 
           }
 }
 


@@ -310,14 +327,14 @@ downheap (WT *timers, int N, int k)
 typedef struct
 {
   struct ev_signal *head;
 typedef struct
 {
   struct ev_signal *head;

-  sig_atomic_t gotsig;
+  sig_atomic_t volatile gotsig;

 } ANSIG;
 
 static ANSIG *signals;
 static int signalmax;
 
 static int sigpipe [2];
 } ANSIG;
 
 static ANSIG *signals;
 static int signalmax;
 
 static int sigpipe [2];

-static sig_atomic_t gotsig;
+static sig_atomic_t volatile gotsig;

 static struct ev_io sigev;
 
 static void
 static struct ev_io sigev;
 
 static void


@@ -327,6 +344,7 @@ signals_init (ANSIG *base, int count)
     {
       base->head   = 0;
       base->gotsig = 0;
     {
       base->head   = 0;
       base->gotsig = 0;

+

       ++base;
     }
 }
       ++base;
     }
 }


@@ -339,7 +357,7 @@ sighandler (int signum)
   if (!gotsig)
     {
       gotsig = 1;
   if (!gotsig)
     {
       gotsig = 1;

-      write (sigpipe [1], &gotsig, 1);
+      write (sigpipe [1], &signum, 1);

     }
 }
 
     }
 }
 


@@ -349,8 +367,8 @@ sigcb (struct ev_io *iow, int revents)
   struct ev_signal *w;
   int sig;
 
   struct ev_signal *w;
   int sig;
 

-  gotsig = 0;

   read (sigpipe [0], &revents, 1);
   read (sigpipe [0], &revents, 1);

+  gotsig = 0;

 
   for (sig = signalmax; sig--; )
     if (signals [sig].gotsig)
 
   for (sig = signalmax; sig--; )
     if (signals [sig].gotsig)


@@ -372,8 +390,8 @@ siginit (void)
   fcntl (sigpipe [0], F_SETFL, O_NONBLOCK);
   fcntl (sigpipe [1], F_SETFL, O_NONBLOCK);
 
   fcntl (sigpipe [0], F_SETFL, O_NONBLOCK);
   fcntl (sigpipe [1], F_SETFL, O_NONBLOCK);
 

-  evio_set (&sigev, sigpipe [0], EV_READ);
-  evio_start (&sigev);
+  ev_io_set (&sigev, sigpipe [0], EV_READ);
+  ev_io_start (&sigev);

 }
 
 /*****************************************************************************/
 }
 
 /*****************************************************************************/


@@ -413,10 +431,10 @@ childcb (struct ev_signal *sw, int revents)
 
 /*****************************************************************************/
 
 
 /*****************************************************************************/
 

-#if HAVE_EPOLL
+#if EV_USE_EPOLL

 # include "ev_epoll.c"
 #endif
 # include "ev_epoll.c"
 #endif

-#if HAVE_SELECT
+#if EV_USE_SELECT

 # include "ev_select.c"
 #endif
 
 # include "ev_select.c"
 #endif
 


@@ -436,7 +454,7 @@ int ev_init (int flags)
 {
   if (!ev_method)
     {
 {
   if (!ev_method)
     {

-#if HAVE_MONOTONIC
+#if EV_USE_MONOTONIC

       {
         struct timespec ts;
         if (!clock_gettime (CLOCK_MONOTONIC, &ts))
       {
         struct timespec ts;
         if (!clock_gettime (CLOCK_MONOTONIC, &ts))


@@ -452,20 +470,20 @@ int ev_init (int flags)
         return 0;
 
       ev_method = EVMETHOD_NONE;
         return 0;
 
       ev_method = EVMETHOD_NONE;

-#if HAVE_EPOLL
+#if EV_USE_EPOLL

       if (ev_method == EVMETHOD_NONE) epoll_init (flags);
 #endif
       if (ev_method == EVMETHOD_NONE) epoll_init (flags);
 #endif

-#if HAVE_SELECT
+#if EV_USE_SELECT

       if (ev_method == EVMETHOD_NONE) select_init (flags);
 #endif
 
       if (ev_method)
         {
       if (ev_method == EVMETHOD_NONE) select_init (flags);
 #endif
 
       if (ev_method)
         {

-          evw_init (&sigev, sigcb);
+          ev_watcher_init (&sigev, sigcb);

           siginit ();
 
           siginit ();
 

-          evsignal_init (&childev, childcb, SIGCHLD);
-          evsignal_start (&childev);
+          ev_signal_init (&childev, childcb, SIGCHLD);
+          ev_signal_start (&childev);

         }
     }
 
         }
     }
 


@@ -475,26 +493,26 @@ int ev_init (int flags)
 /*****************************************************************************/
 
 void
 /*****************************************************************************/
 
 void

-ev_prefork (void)
+ev_fork_prepare (void)

 {
   /* nop */
 }
 
 void
 {
   /* nop */
 }
 
 void

-ev_postfork_parent (void)
+ev_fork_parent (void)

 {
   /* nop */
 }
 
 void
 {
   /* nop */
 }
 
 void

-ev_postfork_child (void)
+ev_fork_child (void)

 {
 {

-#if HAVE_EPOLL
+#if EV_USE_EPOLL

   if (ev_method == EVMETHOD_EPOLL)
     epoll_postfork_child ();
 #endif
 
   if (ev_method == EVMETHOD_EPOLL)
     epoll_postfork_child ();
 #endif
 

-  evio_stop (&sigev);
+  ev_io_stop (&sigev);

   close (sigpipe [0]);
   close (sigpipe [1]);
   pipe (sigpipe);
   close (sigpipe [0]);
   close (sigpipe [1]);
   pipe (sigpipe);


@@ -525,17 +543,17 @@ timers_reify (void)
     {
       struct ev_timer *w = timers [0];
 
     {
       struct ev_timer *w = timers [0];
 

-      event ((W)w, EV_TIMEOUT);
-

       /* first reschedule or stop timer */
       if (w->repeat)
         {
       /* first reschedule or stop timer */
       if (w->repeat)
         {

+          assert (("negative ev_timer repeat value found while processing timers", w->repeat > 0.));

           w->at = now + w->repeat;
           w->at = now + w->repeat;

-          assert (("timer timeout in the past, negative repeat?", w->at > now));

           downheap ((WT *)timers, timercnt, 0);
         }
       else
           downheap ((WT *)timers, timercnt, 0);
         }
       else

-        evtimer_stop (w); /* nonrepeating: stop timer */
+        ev_timer_stop (w); /* nonrepeating: stop timer */
+
+      event ((W)w, EV_TIMEOUT);

     }
 }
 
     }
 }
 


@@ -550,13 +568,13 @@ periodics_reify (void)
       if (w->interval)
         {
           w->at += floor ((ev_now - w->at) / w->interval + 1.) * w->interval;
       if (w->interval)
         {
           w->at += floor ((ev_now - w->at) / w->interval + 1.) * w->interval;

-          assert (("periodic timeout in the past, negative interval?", w->at > ev_now));
+          assert (("ev_periodic timeout in the past detected while processing timers, negative interval?", w->at > ev_now));

           downheap ((WT *)periodics, periodiccnt, 0);
         }
       else
           downheap ((WT *)periodics, periodiccnt, 0);
         }
       else

-        evperiodic_stop (w); /* nonrepeating: stop timer */
+        ev_periodic_stop (w); /* nonrepeating: stop timer */

 
 

-      event ((W)w, EV_TIMEOUT);
+      event ((W)w, EV_PERIODIC);

     }
 }
 
     }
 }
 


@@ -576,8 +594,8 @@ periodics_reschedule (ev_tstamp diff)
 
           if (fabs (diff) >= 1e-4)
             {
 
           if (fabs (diff) >= 1e-4)
             {

-              evperiodic_stop (w);
-              evperiodic_start (w);
+              ev_periodic_stop (w);
+              ev_periodic_start (w);

 
               i = 0; /* restart loop, inefficient, but time jumps should be rare */
             }
 
               i = 0; /* restart loop, inefficient, but time jumps should be rare */
             }


@@ -721,7 +739,7 @@ wlist_del (WL *head, WL elem)
 }
 
 static void
 }
 
 static void

-ev_clear (W w)
+ev_clear_pending (W w)

 {
   if (w->pending)
     {
 {
   if (w->pending)
     {


@@ -745,13 +763,15 @@ ev_stop (W w)
 /*****************************************************************************/
 
 void
 /*****************************************************************************/
 
 void

-evio_start (struct ev_io *w)
+ev_io_start (struct ev_io *w)

 {
   if (ev_is_active (w))
     return;
 
   int fd = w->fd;
 
 {
   if (ev_is_active (w))
     return;
 
   int fd = w->fd;
 

+  assert (("ev_io_start called with negative fd", fd >= 0));
+

   ev_start ((W)w, 1);
   array_needsize (anfds, anfdmax, fd + 1, anfds_init);
   wlist_add ((WL *)&anfds[fd].head, (WL)w);
   ev_start ((W)w, 1);
   array_needsize (anfds, anfdmax, fd + 1, anfds_init);
   wlist_add ((WL *)&anfds[fd].head, (WL)w);


@@ -760,9 +780,9 @@ evio_start (struct ev_io *w)
 }
 
 void
 }
 
 void

-evio_stop (struct ev_io *w)
+ev_io_stop (struct ev_io *w)

 {
 {

-  ev_clear ((W)w);
+  ev_clear_pending ((W)w);

   if (!ev_is_active (w))
     return;
 
   if (!ev_is_active (w))
     return;
 


@@ -773,14 +793,14 @@ evio_stop (struct ev_io *w)
 }
 
 void
 }
 
 void

-evtimer_start (struct ev_timer *w)
+ev_timer_start (struct ev_timer *w)

 {
   if (ev_is_active (w))
     return;
 
   w->at += now;
 
 {
   if (ev_is_active (w))
     return;
 
   w->at += now;
 

-  assert (("timer repeat value less than zero not allowed", w->repeat >= 0.));
+  assert (("ev_timer_start called with negative timer repeat value", w->repeat >= 0.));

 
   ev_start ((W)w, ++timercnt);
   array_needsize (timers, timermax, timercnt, );
 
   ev_start ((W)w, ++timercnt);
   array_needsize (timers, timermax, timercnt, );


@@ -789,9 +809,9 @@ evtimer_start (struct ev_timer *w)
 }
 
 void
 }
 
 void

-evtimer_stop (struct ev_timer *w)
+ev_timer_stop (struct ev_timer *w)

 {
 {

-  ev_clear ((W)w);
+  ev_clear_pending ((W)w);

   if (!ev_is_active (w))
     return;
 
   if (!ev_is_active (w))
     return;
 


@@ -807,7 +827,7 @@ evtimer_stop (struct ev_timer *w)
 }
 
 void
 }
 
 void

-evtimer_again (struct ev_timer *w)
+ev_timer_again (struct ev_timer *w)

 {
   if (ev_is_active (w))
     {
 {
   if (ev_is_active (w))
     {


@@ -817,19 +837,19 @@ evtimer_again (struct ev_timer *w)
           downheap ((WT *)timers, timercnt, w->active - 1);
         }
       else
           downheap ((WT *)timers, timercnt, w->active - 1);
         }
       else

-        evtimer_stop (w);
+        ev_timer_stop (w);

     }
   else if (w->repeat)
     }
   else if (w->repeat)

-    evtimer_start (w);
+    ev_timer_start (w);

 }
 
 void
 }
 
 void

-evperiodic_start (struct ev_periodic *w)
+ev_periodic_start (struct ev_periodic *w)

 {
   if (ev_is_active (w))
     return;
 
 {
   if (ev_is_active (w))
     return;
 

-  assert (("periodic interval value less than zero not allowed", w->interval >= 0.));
+  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)
 
   /* this formula differs from the one in periodic_reify because we do not always round up */
   if (w->interval)


@@ -842,9 +862,9 @@ evperiodic_start (struct ev_periodic *w)
 }
 
 void
 }
 
 void

-evperiodic_stop (struct ev_periodic *w)
+ev_periodic_stop (struct ev_periodic *w)

 {
 {

-  ev_clear ((W)w);
+  ev_clear_pending ((W)w);

   if (!ev_is_active (w))
     return;
 
   if (!ev_is_active (w))
     return;
 


@@ -858,11 +878,13 @@ evperiodic_stop (struct ev_periodic *w)
 }
 
 void
 }
 
 void

-evsignal_start (struct ev_signal *w)
+ev_signal_start (struct ev_signal *w)

 {
   if (ev_is_active (w))
     return;
 
 {
   if (ev_is_active (w))
     return;
 

+  assert (("ev_signal_start called with illegal signal number", w->signum > 0));
+

   ev_start ((W)w, 1);
   array_needsize (signals, signalmax, w->signum, signals_init);
   wlist_add ((WL *)&signals [w->signum - 1].head, (WL)w);
   ev_start ((W)w, 1);
   array_needsize (signals, signalmax, w->signum, signals_init);
   wlist_add ((WL *)&signals [w->signum - 1].head, (WL)w);


@@ -878,9 +900,9 @@ evsignal_start (struct ev_signal *w)
 }
 
 void
 }
 
 void

-evsignal_stop (struct ev_signal *w)
+ev_signal_stop (struct ev_signal *w)

 {
 {

-  ev_clear ((W)w);
+  ev_clear_pending ((W)w);

   if (!ev_is_active (w))
     return;
 
   if (!ev_is_active (w))
     return;
 


@@ -891,7 +913,8 @@ evsignal_stop (struct ev_signal *w)
     signal (w->signum, SIG_DFL);
 }
 
     signal (w->signum, SIG_DFL);
 }
 

-void evidle_start (struct ev_idle *w)
+void
+ev_idle_start (struct ev_idle *w)

 {
   if (ev_is_active (w))
     return;
 {
   if (ev_is_active (w))
     return;


@@ -901,9 +924,10 @@ void evidle_start (struct ev_idle *w)
   idles [idlecnt - 1] = w;
 }
 
   idles [idlecnt - 1] = w;
 }
 

-void evidle_stop (struct ev_idle *w)
+void
+ev_idle_stop (struct ev_idle *w)

 {
 {

-  ev_clear ((W)w);
+  ev_clear_pending ((W)w);

   if (ev_is_active (w))
     return;
 
   if (ev_is_active (w))
     return;
 


@@ -911,7 +935,8 @@ void evidle_stop (struct ev_idle *w)
   ev_stop ((W)w);
 }
 
   ev_stop ((W)w);
 }
 

-void evprepare_start (struct ev_prepare *w)
+void
+ev_prepare_start (struct ev_prepare *w)

 {
   if (ev_is_active (w))
     return;
 {
   if (ev_is_active (w))
     return;


@@ -921,9 +946,10 @@ void evprepare_start (struct ev_prepare *w)
   prepares [preparecnt - 1] = w;
 }
 
   prepares [preparecnt - 1] = w;
 }
 

-void evprepare_stop (struct ev_prepare *w)
+void
+ev_prepare_stop (struct ev_prepare *w)

 {
 {

-  ev_clear ((W)w);
+  ev_clear_pending ((W)w);

   if (ev_is_active (w))
     return;
 
   if (ev_is_active (w))
     return;
 


@@ -931,7 +957,8 @@ void evprepare_stop (struct ev_prepare *w)
   ev_stop ((W)w);
 }
 
   ev_stop ((W)w);
 }
 

-void evcheck_start (struct ev_check *w)
+void
+ev_check_start (struct ev_check *w)

 {
   if (ev_is_active (w))
     return;
 {
   if (ev_is_active (w))
     return;


@@ -941,9 +968,10 @@ void evcheck_start (struct ev_check *w)
   checks [checkcnt - 1] = w;
 }
 
   checks [checkcnt - 1] = w;
 }
 

-void evcheck_stop (struct ev_check *w)
+void
+ev_check_stop (struct ev_check *w)

 {
 {

-  ev_clear ((W)w);
+  ev_clear_pending ((W)w);

   if (ev_is_active (w))
     return;
 
   if (ev_is_active (w))
     return;
 


@@ -951,7 +979,8 @@ void evcheck_stop (struct ev_check *w)
   ev_stop ((W)w);
 }
 
   ev_stop ((W)w);
 }
 

-void evchild_start (struct ev_child *w)
+void
+ev_child_start (struct ev_child *w)

 {
   if (ev_is_active (w))
     return;
 {
   if (ev_is_active (w))
     return;


@@ -960,9 +989,10 @@ void evchild_start (struct ev_child *w)
   wlist_add ((WL *)&childs [w->pid & (PID_HASHSIZE - 1)], (WL)w);
 }
 
   wlist_add ((WL *)&childs [w->pid & (PID_HASHSIZE - 1)], (WL)w);
 }
 

-void evchild_stop (struct ev_child *w)
+void
+ev_child_stop (struct ev_child *w)

 {
 {

-  ev_clear ((W)w);
+  ev_clear_pending ((W)w);

   if (ev_is_active (w))
     return;
 
   if (ev_is_active (w))
     return;
 


@@ -986,8 +1016,8 @@ once_cb (struct ev_once *once, int revents)
   void (*cb)(int revents, void *arg) = once->cb;
   void *arg = once->arg;
 
   void (*cb)(int revents, void *arg) = once->cb;
   void *arg = once->arg;
 

-  evio_stop (&once->io);
-  evtimer_stop (&once->to);
+  ev_io_stop (&once->io);
+  ev_timer_stop (&once->to);

   free (once);
 
   cb (revents, arg);
   free (once);
 
   cb (revents, arg);


@@ -1011,26 +1041,24 @@ ev_once (int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *ar
   struct ev_once *once = malloc (sizeof (struct ev_once));
 
   if (!once)
   struct ev_once *once = malloc (sizeof (struct ev_once));
 
   if (!once)

-    cb (EV_ERROR, arg);
+    cb (EV_ERROR | EV_READ | EV_WRITE | EV_TIMEOUT, arg);

   else
     {
       once->cb  = cb;
       once->arg = arg;
 
   else
     {
       once->cb  = cb;
       once->arg = arg;
 

-      evw_init (&once->io, once_cb_io);
-
+      ev_watcher_init (&once->io, once_cb_io);

       if (fd >= 0)
         {
       if (fd >= 0)
         {

-          evio_set (&once->io, fd, events);
-          evio_start (&once->io);
+          ev_io_set (&once->io, fd, events);
+          ev_io_start (&once->io);

         }
 
         }
 

-      evw_init (&once->to, once_cb_to);
-
+      ev_watcher_init (&once->to, once_cb_to);

       if (timeout >= 0.)
         {
       if (timeout >= 0.)
         {

-          evtimer_set (&once->to, timeout, 0.);
-          evtimer_start (&once->to);
+          ev_timer_set (&once->to, timeout, 0.);
+          ev_timer_start (&once->to);

         }
     }
 }
         }
     }
 }


@@ -1051,16 +1079,16 @@ static void
 ocb (struct ev_timer *w, int revents)
 {
   //fprintf (stderr, "timer %f,%f (%x) (%f) d%p\n", w->at, w->repeat, revents, w->at - ev_time (), w->data);
 ocb (struct ev_timer *w, int revents)
 {
   //fprintf (stderr, "timer %f,%f (%x) (%f) d%p\n", w->at, w->repeat, revents, w->at - ev_time (), w->data);

-  evtimer_stop (w);
-  evtimer_start (w);
+  ev_timer_stop (w);
+  ev_timer_start (w);

 }
 
 static void
 scb (struct ev_signal *w, int revents)
 {
   fprintf (stderr, "signal %x,%d\n", revents, w->signum);
 }
 
 static void
 scb (struct ev_signal *w, int revents)
 {
   fprintf (stderr, "signal %x,%d\n", revents, w->signum);

-  evio_stop (&wio);
-  evio_start (&wio);
+  ev_io_stop (&wio);
+  ev_io_start (&wio);

 }
 
 static void
 }
 
 static void


@@ -1074,8 +1102,8 @@ int main (void)
 {
   ev_init (0);
 
 {
   ev_init (0);
 

-  evio_init (&wio, sin_cb, 0, EV_READ);
-  evio_start (&wio);
+  ev_io_init (&wio, sin_cb, 0, EV_READ);
+  ev_io_start (&wio);

 
   struct ev_timer t[10000];
 
 
   struct ev_timer t[10000];
 


@@ -1084,29 +1112,29 @@ int main (void)
   for (i = 0; i < 10000; ++i)
     {
       struct ev_timer *w = t + i;
   for (i = 0; i < 10000; ++i)
     {
       struct ev_timer *w = t + i;

-      evw_init (w, ocb, i);
-      evtimer_init_abs (w, ocb, drand48 (), 0.99775533);
-      evtimer_start (w);
+      ev_watcher_init (w, ocb, i);
+      ev_timer_init_abs (w, ocb, drand48 (), 0.99775533);
+      ev_timer_start (w);

       if (drand48 () < 0.5)
       if (drand48 () < 0.5)

-        evtimer_stop (w);
+        ev_timer_stop (w);

     }
 #endif
 
   struct ev_timer t1;
     }
 #endif
 
   struct ev_timer t1;

-  evtimer_init (&t1, ocb, 5, 10);
-  evtimer_start (&t1);
+  ev_timer_init (&t1, ocb, 5, 10);
+  ev_timer_start (&t1);

 
   struct ev_signal sig;
 
   struct ev_signal sig;

-  evsignal_init (&sig, scb, SIGQUIT);
-  evsignal_start (&sig);
+  ev_signal_init (&sig, scb, SIGQUIT);
+  ev_signal_start (&sig);

 
   struct ev_check cw;
 
   struct ev_check cw;

-  evcheck_init (&cw, gcb);
-  evcheck_start (&cw);
+  ev_check_init (&cw, gcb);
+  ev_check_start (&cw);

 
   struct ev_idle iw;
 
   struct ev_idle iw;

-  evidle_init (&iw, gcb);
-  evidle_start (&iw);
+  ev_idle_init (&iw, gcb);
+  ev_idle_start (&iw);

 
   ev_loop (0);
 
 
   ev_loop (0);