*** empty log message ***

[software/libev.git] / ev.c

diff --git a/ev.c b/ev.c
index b852e45f98bf739a563b04a203a415687e5d4043..00edbd2d2bcfc55696b2d2a678820b7203880976 100644 (file)
--- a/ev.c
+++ b/ev.c
@@ -128,7 +128,11 @@
 #define PID_HASHSIZE  16 /* size of pid hash table, must be power of two */
 /*#define CLEANUP_INTERVAL 300. /* how often to try to free memory and re-check fds */
 
 #define PID_HASHSIZE  16 /* size of pid hash table, must be power of two */
 /*#define CLEANUP_INTERVAL 300. /* how often to try to free memory and re-check fds */
 

-#include "ev.h"
+#ifdef EV_H
+# include EV_H
+#else
+# include "ev.h"
+#endif

 
 #if __GNUC__ >= 3
 # define expect(expr,value)         __builtin_expect ((expr),(value))
 
 #if __GNUC__ >= 3
 # define expect(expr,value)         __builtin_expect ((expr),(value))


@@ -217,19 +221,24 @@ typedef struct
 
 #if EV_MULTIPLICITY
 
 
 #if EV_MULTIPLICITY
 

-struct ev_loop
-{
-# define VAR(name,decl) decl;
-# include "ev_vars.h"
-};
-# undef VAR
-# include "ev_wrap.h"
+  struct ev_loop
+  {
+    #define VAR(name,decl) decl;
+      #include "ev_vars.h"
+    #undef VAR
+  };
+  #include "ev_wrap.h"
+
+  struct ev_loop default_loop_struct;
+  static struct ev_loop *default_loop;

 
 #else
 
 
 #else
 

-# define VAR(name,decl) static decl;
-# include "ev_vars.h"
-# undef VAR
+  #define VAR(name,decl) static decl;
+    #include "ev_vars.h"
+  #undef VAR
+
+  static int default_loop;

 
 #endif
 
 
 #endif
 


@@ -318,19 +327,21 @@ anfds_init (ANFD *base, int count)
     }
 }
 
     }
 }
 

-static void
-event (EV_P_ W w, int events)
+void
+ev_feed_event (EV_P_ void *w, int revents)

 {
 {

-  if (w->pending)
+  W w_ = (W)w;
+
+  if (w_->pending)

     {
     {

-      pendings [ABSPRI (w)][w->pending - 1].events |= events;
+      pendings [ABSPRI (w_)][w_->pending - 1].events |= revents;

       return;
     }
 
       return;
     }
 

-  w->pending = ++pendingcnt [ABSPRI (w)];
-  array_needsize (ANPENDING, pendings [ABSPRI (w)], pendingmax [ABSPRI (w)], pendingcnt [ABSPRI (w)], (void));
-  pendings [ABSPRI (w)][w->pending - 1].w      = w;
-  pendings [ABSPRI (w)][w->pending - 1].events = events;
+  w_->pending = ++pendingcnt [ABSPRI (w_)];
+  array_needsize (ANPENDING, pendings [ABSPRI (w_)], pendingmax [ABSPRI (w_)], pendingcnt [ABSPRI (w_)], (void));
+  pendings [ABSPRI (w_)][w_->pending - 1].w      = w_;
+  pendings [ABSPRI (w_)][w_->pending - 1].events = revents;

 }
 
 static void
 }
 
 static void


@@ -339,24 +350,30 @@ queue_events (EV_P_ W *events, int eventcnt, int type)
   int i;
 
   for (i = 0; i < eventcnt; ++i)
   int i;
 
   for (i = 0; i < eventcnt; ++i)

-    event (EV_A_ events [i], type);
+    ev_feed_event (EV_A_ events [i], type);

 }
 
 }
 

-static void
-fd_event (EV_P_ int fd, int events)
+inline void
+fd_event (EV_P_ int fd, int revents)

 {
   ANFD *anfd = anfds + fd;
   struct ev_io *w;
 
   for (w = (struct ev_io *)anfd->head; w; w = (struct ev_io *)((WL)w)->next)
     {
 {
   ANFD *anfd = anfds + fd;
   struct ev_io *w;
 
   for (w = (struct ev_io *)anfd->head; w; w = (struct ev_io *)((WL)w)->next)
     {

-      int ev = w->events & events;
+      int ev = w->events & revents;

 
       if (ev)
 
       if (ev)

-        event (EV_A_ (W)w, ev);
+        ev_feed_event (EV_A_ (W)w, ev);

     }
 }
 
     }
 }
 

+void
+ev_feed_fd_event (EV_P_ int fd, int revents)
+{
+  fd_event (EV_A_ fd, revents);
+}
+

 /*****************************************************************************/
 
 static void
 /*****************************************************************************/
 
 static void


@@ -405,7 +422,7 @@ fd_kill (EV_P_ int fd)
   while ((w = (struct ev_io *)anfds [fd].head))
     {
       ev_io_stop (EV_A_ w);
   while ((w = (struct ev_io *)anfds [fd].head))
     {
       ev_io_stop (EV_A_ w);

-      event (EV_A_ (W)w, EV_ERROR | EV_READ | EV_WRITE);
+      ev_feed_event (EV_A_ (W)w, EV_ERROR | EV_READ | EV_WRITE);

     }
 }
 
     }
 }
 


@@ -552,10 +569,29 @@ sighandler (int signum)
     }
 }
 
     }
 }
 

+void
+ev_feed_signal_event (EV_P_ int signum)
+{
+  WL w;
+
+#if EV_MULTIPLICITY
+  assert (("feeding signal events is only supported in the default loop", loop == default_loop));
+#endif
+
+  --signum;
+
+  if (signum < 0 || signum >= signalmax)
+    return;
+
+  signals [signum].gotsig = 0;
+
+  for (w = signals [signum].head; w; w = w->next)
+    ev_feed_event (EV_A_ (W)w, EV_SIGNAL);
+}
+

 static void
 sigcb (EV_P_ struct ev_io *iow, int revents)
 {
 static void
 sigcb (EV_P_ struct ev_io *iow, int revents)
 {

-  WL w;

   int signum;
 
 #ifdef WIN32
   int signum;
 
 #ifdef WIN32


@@ -567,12 +603,7 @@ sigcb (EV_P_ struct ev_io *iow, int revents)
 
   for (signum = signalmax; signum--; )
     if (signals [signum].gotsig)
 
   for (signum = signalmax; signum--; )
     if (signals [signum].gotsig)

-      {
-        signals [signum].gotsig = 0;
-
-        for (w = signals [signum].head; w; w = w->next)
-          event (EV_A_ (W)w, EV_SIGNAL);
-      }
+      ev_feed_signal_event (EV_A_ signum + 1);

 }
 
 static void
 }
 
 static void


@@ -615,7 +646,7 @@ child_reap (EV_P_ struct ev_signal *sw, int chain, int pid, int status)
         ev_priority (w) = ev_priority (sw); /* need to do it *now* */
         w->rpid         = pid;
         w->rstatus      = status;
         ev_priority (w) = ev_priority (sw); /* need to do it *now* */
         w->rpid         = pid;
         w->rstatus      = status;

-        event (EV_A_ (W)w, EV_CHILD);
+        ev_feed_event (EV_A_ (W)w, EV_CHILD);

       }
 }
 
       }
 }
 


@@ -627,7 +658,7 @@ childcb (EV_P_ struct ev_signal *sw, int revents)
   if (0 < (pid = waitpid (-1, &status, WNOHANG | WUNTRACED | WCONTINUED)))
     {
       /* make sure we are called again until all childs have been reaped */
   if (0 < (pid = waitpid (-1, &status, WNOHANG | WUNTRACED | WCONTINUED)))
     {
       /* make sure we are called again until all childs have been reaped */

-      event (EV_A_ (W)sw, EV_SIGNAL);
+      ev_feed_event (EV_A_ (W)sw, EV_SIGNAL);

 
       child_reap (EV_A_ sw, pid, pid, status);
       child_reap (EV_A_ sw,   0, pid, status); /* this might trigger a watcher twice, but event catches that */
 
       child_reap (EV_A_ sw, pid, pid, status);
       child_reap (EV_A_ sw,   0, pid, status); /* this might trigger a watcher twice, but event catches that */


@@ -722,7 +753,7 @@ loop_init (EV_P_ int methods)
       if (!method && (methods & EVMETHOD_SELECT)) method = select_init (EV_A_ methods);
 #endif
 
       if (!method && (methods & EVMETHOD_SELECT)) method = select_init (EV_A_ methods);
 #endif
 

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

       ev_set_priority (&sigev, EV_MAXPRI);
     }
 }
       ev_set_priority (&sigev, EV_MAXPRI);
     }
 }


@@ -822,13 +853,8 @@ ev_loop_fork (EV_P)
 #endif
 
 #if EV_MULTIPLICITY
 #endif
 
 #if EV_MULTIPLICITY

-struct ev_loop default_loop_struct;
-static struct ev_loop *default_loop;
-

 struct ev_loop *
 #else
 struct ev_loop *
 #else

-static int default_loop;
-

 int
 #endif
 ev_default_loop (int methods)
 int
 #endif
 ev_default_loop (int methods)


@@ -924,7 +950,7 @@ call_pending (EV_P)
         if (p->w)
           {
             p->w->pending = 0;
         if (p->w)
           {
             p->w->pending = 0;

-            p->w->cb (EV_A_ p->w, p->events);
+            EV_CB_INVOKE (p->w, p->events);

           }
       }
 }
           }
       }
 }


@@ -948,7 +974,7 @@ timers_reify (EV_P)
       else
         ev_timer_stop (EV_A_ w); /* nonrepeating: stop timer */
 
       else
         ev_timer_stop (EV_A_ w); /* nonrepeating: stop timer */
 

-      event (EV_A_ (W)w, EV_TIMEOUT);
+      ev_feed_event (EV_A_ (W)w, EV_TIMEOUT);

     }
 }
 
     }
 }
 


@@ -978,7 +1004,7 @@ periodics_reify (EV_P)
       else
         ev_periodic_stop (EV_A_ w); /* nonrepeating: stop timer */
 
       else
         ev_periodic_stop (EV_A_ w); /* nonrepeating: stop timer */
 

-      event (EV_A_ (W)w, EV_PERIODIC);
+      ev_feed_event (EV_A_ (W)w, EV_PERIODIC);

     }
 }
 
     }
 }
 


@@ -1540,14 +1566,14 @@ ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, vo
       once->cb  = cb;
       once->arg = arg;
 
       once->cb  = cb;
       once->arg = arg;
 

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

       if (fd >= 0)
         {
           ev_io_set (&once->io, fd, events);
           ev_io_start (EV_A_ &once->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);
+      ev_init (&once->to, once_cb_to);

       if (timeout >= 0.)
         {
           ev_timer_set (&once->to, timeout, 0.);
       if (timeout >= 0.)
         {
           ev_timer_set (&once->to, timeout, 0.);