--- cvsroot/EV/EV.xs	2007/10/31 13:57:34	1.20
+++ cvsroot/EV/EV.xs	2007/11/01 06:48:49	1.29
@@ -5,6 +5,7 @@
 /*#include <netinet/in.h>*/
 
 #define TIMEOUT_NONE HUGE_VAL
+#define HAVE_EPOLL 1
 
 #define EV_PROTOTYPES 1
 #include "EV/EVAPI.h"
@@ -23,7 +24,9 @@
   *stash_periodic,
   *stash_signal,
   *stash_idle,
-  *stash_check;
+  *stash_prepare,
+  *stash_check,
+  *stash_child;
 
 static int
 sv_signum (SV *sig)
@@ -72,7 +75,7 @@
 
   w = (struct ev_watcher *)SvPVX (self);
 
-  evw_init (w, e_cb);
+  ev_watcher_init (w, e_cb);
 
   w->fh    = 0;
   w->cb_sv = newSVsv (cb_sv);
@@ -103,7 +106,7 @@
 {
   dSP;
   I32 mark = SP - PL_stack_base;
-  SV *sv_self, *sv_events;
+  SV *sv_self, *sv_events, *sv_status = 0;
   static SV *sv_events_cache;
 
   sv_self = newRV_inc (w->self); /* w->self MUST be blessed by now */
@@ -120,11 +123,16 @@
   EXTEND (SP, 2);
   PUSHs (sv_self);
   PUSHs (sv_events);
+
+  if (revents & EV_CHILD)
+    XPUSHs (sv_status = newSViv (((struct ev_child *)w)->status));
+
   PUTBACK;
   call_sv (w->cb_sv, G_DISCARD | G_VOID | G_EVAL);
   SP = PL_stack_base + mark; PUTBACK;
 
   SvREFCNT_dec (sv_self);
+  SvREFCNT_dec (sv_status);
 
   if (sv_events_cache)
     SvREFCNT_dec (sv_events);
@@ -202,6 +210,8 @@
 
 MODULE = EV		PACKAGE = EV		PREFIX = ev_
 
+PROTOTYPES: ENABLE
+
 BOOT:
 {
   int i;
@@ -234,13 +244,15 @@
     newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
 
   stash_watcher  = gv_stashpv ("EV::Watcher" , 1);
-  stash_io       = gv_stashpv ("EV::IO"      , 1);
+  stash_io       = gv_stashpv ("EV::Io"      , 1);
   stash_time     = gv_stashpv ("EV::Time"    , 1);
   stash_timer    = gv_stashpv ("EV::Timer"   , 1);
   stash_periodic = gv_stashpv ("EV::Periodic", 1);
   stash_signal   = gv_stashpv ("EV::Signal"  , 1);
   stash_idle     = gv_stashpv ("EV::Idle"    , 1);
+  stash_prepare  = gv_stashpv ("EV::Prepare" , 1);
   stash_check    = gv_stashpv ("EV::Check"   , 1);
+  stash_child    = gv_stashpv ("EV::Child"   , 1);
 
   {
     SV *sv = perl_get_sv ("EV::API", TRUE);
@@ -257,19 +269,23 @@
     evapi.time           = ev_time;
     evapi.loop           = ev_loop;
     evapi.once           = ev_once;
-    evapi.io_start       = evio_start;
-    evapi.io_stop        = evio_stop;
-    evapi.timer_start    = evtimer_start;
-    evapi.timer_stop     = evtimer_stop;
-    evapi.timer_again    = evtimer_again;
-    evapi.periodic_start = evperiodic_start;
-    evapi.periodic_stop  = evperiodic_stop;
-    evapi.signal_start   = evsignal_start;
-    evapi.signal_stop    = evsignal_stop;
-    evapi.idle_start     = evidle_start;
-    evapi.idle_stop      = evidle_stop;
-    evapi.check_start    = evcheck_start;
-    evapi.check_stop     = evcheck_stop;
+    evapi.io_start       = ev_io_start;
+    evapi.io_stop        = ev_io_stop;
+    evapi.timer_start    = ev_timer_start;
+    evapi.timer_stop     = ev_timer_stop;
+    evapi.timer_again    = ev_timer_again;
+    evapi.periodic_start = ev_periodic_start;
+    evapi.periodic_stop  = ev_periodic_stop;
+    evapi.signal_start   = ev_signal_start;
+    evapi.signal_stop    = ev_signal_stop;
+    evapi.idle_start     = ev_idle_start;
+    evapi.idle_stop      = ev_idle_stop;
+    evapi.prepare_start  = ev_prepare_start;
+    evapi.prepare_stop   = ev_prepare_stop;
+    evapi.check_start    = ev_check_start;
+    evapi.check_stop     = ev_check_stop;
+    evapi.child_start    = ev_child_start;
+    evapi.child_stop     = ev_child_stop;
 
     sv_setiv (sv, (IV)&evapi);
     SvREADONLY_on (sv);
@@ -299,73 +315,87 @@
         ev_loop_done = value;
 
 struct ev_io *io (SV *fh, int events, SV *cb)
-	PROTOTYPE: $$&
 	ALIAS:
         io_ns = 1
 	CODE:
         RETVAL = e_new (sizeof (struct ev_io), cb);
         RETVAL->fh = newSVsv (fh);
-        evio_set (RETVAL, sv_fileno (RETVAL->fh), events);
-        if (!ix) evio_start (RETVAL);
+        ev_io_set (RETVAL, sv_fileno (RETVAL->fh), events);
+        if (!ix) ev_io_start (RETVAL);
 	OUTPUT:
         RETVAL
 
 struct ev_timer *timer (NV after, NV repeat, SV *cb)
-	PROTOTYPE: $$&
 	ALIAS:
         timer_ns = 1
         INIT:
         CHECK_REPEAT (repeat);
 	CODE:
         RETVAL = e_new (sizeof (struct ev_timer), cb);
-        evtimer_set (RETVAL, after, repeat);
-        if (!ix) evtimer_start (RETVAL);
+        ev_timer_set (RETVAL, after, repeat);
+        if (!ix) ev_timer_start (RETVAL);
 	OUTPUT:
         RETVAL
 
 struct ev_periodic *periodic (NV at, NV interval, SV *cb)
-	PROTOTYPE: $$&
 	ALIAS:
         periodic_ns = 1
         INIT:
         CHECK_REPEAT (interval);
 	CODE:
         RETVAL = e_new (sizeof (struct ev_periodic), cb);
-        evperiodic_set (RETVAL, at, interval);
-        if (!ix) evperiodic_start (RETVAL);
+        ev_periodic_set (RETVAL, at, interval);
+        if (!ix) ev_periodic_start (RETVAL);
 	OUTPUT:
         RETVAL
 
 struct ev_signal *signal (Signal signum, SV *cb)
-	PROTOTYPE: $&
 	ALIAS:
         signal_ns = 1
 	CODE:
         RETVAL = e_new (sizeof (struct ev_signal), cb);
-        evsignal_set (RETVAL, signum);
-        if (!ix) evsignal_start (RETVAL);
+        ev_signal_set (RETVAL, signum);
+        if (!ix) ev_signal_start (RETVAL);
 	OUTPUT:
         RETVAL
 
 struct ev_idle *idle (SV *cb)
-	PROTOTYPE: &
 	ALIAS:
         idle_ns = 1
 	CODE:
         RETVAL = e_new (sizeof (struct ev_idle), cb);
-        evidle_set (RETVAL);
-        if (!ix) evidle_start (RETVAL);
+        ev_idle_set (RETVAL);
+        if (!ix) ev_idle_start (RETVAL);
+	OUTPUT:
+        RETVAL
+
+struct ev_prepare *prepare (SV *cb)
+	ALIAS:
+        prepare_ns = 1
+	CODE:
+        RETVAL = e_new (sizeof (struct ev_prepare), cb);
+        ev_prepare_set (RETVAL);
+        if (!ix) ev_prepare_start (RETVAL);
 	OUTPUT:
         RETVAL
 
 struct ev_check *check (SV *cb)
-	PROTOTYPE: &
 	ALIAS:
         check_ns = 1
 	CODE:
         RETVAL = e_new (sizeof (struct ev_check), cb);
-        evcheck_set (RETVAL);
-        if (!ix) evcheck_start (RETVAL);
+        ev_check_set (RETVAL);
+        if (!ix) ev_check_start (RETVAL);
+	OUTPUT:
+        RETVAL
+
+struct ev_child *child (int pid, SV *cb)
+	ALIAS:
+        check_ns = 1
+	CODE:
+        RETVAL = e_new (sizeof (struct ev_check), cb);
+        ev_child_set (RETVAL, pid);
+        if (!ix) ev_child_start (RETVAL);
 	OUTPUT:
         RETVAL
 
@@ -387,22 +417,30 @@
 	OUTPUT:
         RETVAL
 
-MODULE = EV		PACKAGE = EV::IO	PREFIX = evio_
+void trigger (struct ev_watcher *w, int revents = EV_NONE)
+	CODE:
+        w->cb (w, revents);
+
+MODULE = EV		PACKAGE = EV::Io	PREFIX = ev_io_
+
+void ev_io_start (struct ev_io *w)
 
-void evio_start (struct ev_io *w)
+void ev_io_stop (struct ev_io *w)
 
-void evio_stop (struct ev_io *w)
+void DESTROY (struct ev_io *w)
+	CODE:
+        ev_io_stop (w);
 
 void set (struct ev_io *w, SV *fh, int events)
 	CODE:
 {
         int active = w->active;
-        if (active) evio_stop (w);
+        if (active) ev_io_stop (w);
 
         sv_setsv (w->fh, fh);
-        evio_set (w, sv_fileno (w->fh), events);
+        ev_io_set (w, sv_fileno (w->fh), events);
 
-        if (active) evio_start (w);
+        if (active) ev_io_start (w);
 }
 
 SV *fh (struct ev_io *w, SV *new_fh = 0)
@@ -413,12 +451,12 @@
         if (items > 1)
           {
             int active = w->active;
-            if (active) evio_stop (w);
+            if (active) ev_io_stop (w);
 
             sv_setsv (w->fh, new_fh);
-            evio_set (w, sv_fileno (w->fh), w->events);
+            ev_io_set (w, sv_fileno (w->fh), w->events);
 
-            if (active) evio_start (w);
+            if (active) ev_io_start (w);
           }
 }
 	OUTPUT:
@@ -432,21 +470,25 @@
         if (items > 1)
           {
             int active = w->active;
-            if (active) evio_stop (w);
+            if (active) ev_io_stop (w);
 
-            evio_set (w, w->fd, new_events);
+            ev_io_set (w, w->fd, new_events);
 
-            if (active) evio_start (w);
+            if (active) ev_io_start (w);
           }
 }
 	OUTPUT:
         RETVAL
 
-MODULE = EV		PACKAGE = EV::Signal	PREFIX = evsignal_
+MODULE = EV		PACKAGE = EV::Signal	PREFIX = ev_signal_
+
+void ev_signal_start (struct ev_signal *w)
 
-void evsignal_start (struct ev_signal *w)
+void ev_signal_stop (struct ev_signal *w)
 
-void evsignal_stop (struct ev_signal *w)
+void DESTROY (struct ev_signal *w)
+	CODE:
+        ev_signal_stop (w);
 
 void set (struct ev_signal *w, SV *signal = 0)
 	CODE:
@@ -454,43 +496,51 @@
 	Signal signum = sv_signum (signal); /* may croak here */
         int active = w->active;
 
-        if (active) evsignal_stop (w);
-        evsignal_set (w, signum);
-        if (active) evsignal_start (w);
+        if (active) ev_signal_stop (w);
+        ev_signal_set (w, signum);
+        if (active) ev_signal_start (w);
 }
 
 MODULE = EV		PACKAGE = EV::Time
 
-MODULE = EV		PACKAGE = EV::Timer	PREFIX = evtimer_
+MODULE = EV		PACKAGE = EV::Timer	PREFIX = ev_timer_
 
-void evtimer_start (struct ev_timer *w)
+void ev_timer_start (struct ev_timer *w)
         INIT:
         CHECK_REPEAT (w->repeat);
 
-void evtimer_stop (struct ev_timer *w)
+void ev_timer_stop (struct ev_timer *w)
 
-void evtimer_again (struct ev_timer *w)
+void ev_timer_again (struct ev_timer *w)
         INIT:
         CHECK_REPEAT (w->repeat);
 
+void DESTROY (struct ev_timer *w)
+	CODE:
+        ev_timer_stop (w);
+
 void set (struct ev_timer *w, NV after, NV repeat = 0.)
         INIT:
         CHECK_REPEAT (repeat);
 	CODE:
 {
         int active = w->active;
-        if (active) evtimer_stop (w);
-        evtimer_set (w, after, repeat);
-        if (active) evtimer_start (w);
+        if (active) ev_timer_stop (w);
+        ev_timer_set (w, after, repeat);
+        if (active) ev_timer_start (w);
 }
 
-MODULE = EV		PACKAGE = EV::Periodic	PREFIX = evperiodic_
+MODULE = EV		PACKAGE = EV::Periodic	PREFIX = ev_periodic_
 
-void evperiodic_start (struct ev_periodic *w)
+void ev_periodic_start (struct ev_periodic *w)
         INIT:
         CHECK_REPEAT (w->interval);
 
-void evperiodic_stop (struct ev_periodic *w)
+void ev_periodic_stop (struct ev_periodic *w)
+
+void DESTROY (struct ev_periodic *w)
+	CODE:
+        ev_periodic_stop (w);
 
 void set (struct ev_periodic *w, NV at, NV interval = 0.)
         INIT:
@@ -498,22 +548,65 @@
 	CODE:
 {
         int active = w->active;
-        if (active) evperiodic_stop (w);
-        evperiodic_set (w, at, interval);
-        if (active) evperiodic_start (w);
+        if (active) ev_periodic_stop (w);
+        ev_periodic_set (w, at, interval);
+        if (active) ev_periodic_start (w);
 }
 
-MODULE = EV		PACKAGE = EV::Idle	PREFIX = evidle_
+MODULE = EV		PACKAGE = EV::Idle	PREFIX = ev_idle_
+
+void ev_idle_start (struct ev_idle *w)
+
+void ev_idle_stop (struct ev_idle *w)
+
+void DESTROY (struct ev_idle *w)
+	CODE:
+        ev_idle_stop (w);
+
+MODULE = EV		PACKAGE = EV::Prepare	PREFIX = ev_check_
+
+void ev_prepare_start (struct ev_prepare *w)
+
+void ev_prepare_stop (struct ev_prepare *w)
+
+void DESTROY (struct ev_prepare *w)
+	CODE:
+        ev_prepare_stop (w);
+
+MODULE = EV		PACKAGE = EV::Check	PREFIX = ev_check_
+
+void ev_check_start (struct ev_check *w)
 
-void evidle_start (struct ev_idle *w)
+void ev_check_stop (struct ev_check *w)
 
-void evidle_stop (struct ev_idle *w)
+void DESTROY (struct ev_check *w)
+	CODE:
+        ev_check_stop (w);
+
+MODULE = EV		PACKAGE = EV::Child	PREFIX = ev_child_
+
+void ev_child_start (struct ev_child *w)
 
-MODULE = EV		PACKAGE = EV::Check	PREFIX = evcheck_
+void ev_child_stop (struct ev_child *w)
 
-void evcheck_start (struct ev_check *w)
+void DESTROY (struct ev_child *w)
+	CODE:
+        ev_child_stop (w);
+
+void set (struct ev_child *w, int pid)
+	CODE:
+{
+        int active = w->active;
+        if (active) ev_child_stop (w);
+        ev_child_set (w, pid);
+        if (active) ev_child_start (w);
+}
 
-void evcheck_stop (struct ev_check *w)
+int status (struct ev_child *w)
+	CODE:
+        RETVAL = w->status;
+	OUTPUT:
+        RETVAL
 
 #if 0