--- Coro/Event/Event.xs	2001/08/17 04:08:58	1.5
+++ Coro/Event/Event.xs	2006/12/01 20:49:54	1.14
@@ -2,6 +2,7 @@
 #include "perl.h"
 #include "XSUB.h"
 
+#include <assert.h>
 #include <string.h>
 
 #include "EventAPI.h"
@@ -10,51 +11,43 @@
 #define CD_CORO	0
 #define CD_TYPE	1
 #define CD_OK	2
-#define CD_GOT	3 /* hardcoded in Coro::Event, Coro::Handle */
-#define CD_MAX	3
-/* no support for hits and prio so far. */
-
-#define EV_CLASS "Coro::Event"
-
-static pe_idle *scheduler;
-static int do_schedule;
-
-#define NEED_SCHEDULE if (!do_schedule)					\
-                        {						\
- 		          do_schedule = 1;				\
-		          GEventAPI->now ((pe_watcher *)scheduler);	\
-                        }
+
+#define CD_HITS	4 /* hardcoded in Coro::Event */
+#define CD_GOT	5 /* hardcoded in Coro::Event, Coro::Handle */
+#define CD_MAX	5
 
 static void
-coro_std_cb(pe_event *pe)
+coro_std_cb (pe_event *pe)
 {
-  AV *priv = (AV *)SvRV ((SV *)pe->ext_data);
-  IV type = SvIV (*av_fetch (priv, CD_TYPE, 1));
-  SV *cd_coro = *av_fetch (priv, CD_CORO, 1);
+  AV *priv = (AV *)pe->ext_data;
+  IV type = SvIV (AvARRAY (priv)[CD_TYPE]);
+  SV **cd_coro;
+
+  SvIV_set (AvARRAY (priv)[CD_HITS], pe->hits);
 
   if (type == 1)
-    av_store (priv, CD_GOT, newSViv (((pe_ioevent *)pe)->got));
+    SvIV_set (AvARRAY (priv)[CD_GOT], ((pe_ioevent *)pe)->got);
 
-  if (SvROK (cd_coro))
-    {
-      CORO_READY (cd_coro);
-      av_store (priv, CD_CORO, &PL_sv_undef);
-      NEED_SCHEDULE;
-    }
-  else
+  GEventAPI->stop (pe->up, 0);
+
+  AvARRAY (priv)[CD_OK] = &PL_sv_yes;
+
+  cd_coro = &AvARRAY(priv)[CD_CORO];
+  if (*cd_coro != &PL_sv_undef)
     {
-      av_store (priv, CD_OK, &PL_sv_yes);
-      GEventAPI->stop (pe->up, 0);
+      AvARRAY (priv)[CD_OK] = &PL_sv_yes;
+      CORO_READY (*cd_coro);
+      SvREFCNT_dec (*cd_coro);
+      *cd_coro = &PL_sv_undef;
     }
 }
 
 static void
-scheduler_cb(pe_event *pe)
+asynccheck_hook (void *data)
 {
+  /* ceding from C means allocating a stack, but we assume this is a rare case */
   while (CORO_NREADY)
     CORO_CEDE;
-
-  do_schedule = 0;
 }
 
 MODULE = Coro::Event                PACKAGE = Coro::Event
@@ -63,58 +56,85 @@
 
 BOOT:
 {
-        I_EVENT_API("Coro::Event");
+        I_EVENT_API ("Coro::Event");
 	I_CORO_API ("Coro::Event");
 
-        /* create a fake idle handler (we only ever call now) */
-        scheduler = GEventAPI->new_idle (0, 0);
-        scheduler->base.callback = scheduler_cb;
-        scheduler->base.prio = 4; /* StarvePrio(?) */
-        scheduler->min_interval = newSVnv (0);
-        scheduler->max_interval = newSVnv (0);
-        GEventAPI->stop ((pe_watcher *)scheduler, 0);
+        GEventAPI->add_hook ("asynccheck", (void *)asynccheck_hook, 0);
 }
 
 void
-_install_std_cb(self,type)
-	SV *	self
-        int	type
+_install_std_cb (SV *self, int type)
         CODE:
+{
         pe_watcher *w = GEventAPI->sv_2watcher (self);
-        AV *priv = newAV ();
-        SV *rv = newRV_noinc ((SV *)priv);
-
-        av_extend (priv, CD_MAX);
-        av_store (priv, CD_TYPE, newSViv (type));
 
-        w->callback = coro_std_cb;
-        w->ext_data = rv;
+        if (w->callback)
+          croak ("Coro::Event watchers must not have a callback (see Coro::Event), caught");
 
-        hv_store ((HV *)SvRV (self),
-                  EV_CLASS, strlen (EV_CLASS),
-                  rv, 0);
+        {
+          AV *priv = newAV ();
+          SV *rv = newRV_noinc ((SV *)priv);
+
+          av_extend (priv, CD_MAX);
+          AvARRAY (priv)[CD_CORO] = &PL_sv_undef;
+          AvARRAY (priv)[CD_TYPE] = newSViv (type);
+          AvARRAY (priv)[CD_OK  ] = &PL_sv_no;
+          AvARRAY (priv)[CD_HITS] = newSViv (0);
+          AvARRAY (priv)[CD_GOT ] = newSViv (0);
+          SvREADONLY_on (priv);
+
+          w->callback = coro_std_cb;
+          w->ext_data = priv;
+
+          /* make sure Event does not use PERL_MAGIC_uvar, which */
+          /* we abuse for non-uvar purposes. */
+          sv_magicext (SvRV (self), rv, PERL_MAGIC_uvar, 0, 0, 0);
+        }
+}
 
 void
-_next(self)
-	SV *	self
+_next (SV *self)
         CODE:
+{
         pe_watcher *w = GEventAPI->sv_2watcher (self);
-        AV *priv = (AV *)SvRV ((SV *)w->ext_data);
-
-        if (SvOK (*av_fetch (priv, CD_CORO, 1)))
-          croak ("only one coroutine can wait for an event");
+        AV *priv = (AV *)w->ext_data;
 
-        if (!w->running)
-          GEventAPI->start (w, 1);
-
-        if (*av_fetch (priv, CD_OK, 1) == &PL_sv_yes)
+        if (AvARRAY (priv)[CD_OK] == &PL_sv_yes)
           {
-            av_store (priv, CD_OK, &PL_sv_no);
-            XSRETURN_NO;
+            AvARRAY (priv)[CD_OK] = &PL_sv_no;
+            XSRETURN_NO; /* got an event */
           }
-        else 
+
+        if (!w->running)
           {
-            av_store (priv, CD_CORO, SvREFCNT_inc (CORO_CURRENT));
-            XSRETURN_YES;
+            SvIV_set (AvARRAY (priv)[CD_GOT],  0);
+            SvIV_set (AvARRAY (priv)[CD_HITS], 0);
+
+            GEventAPI->start (w, 1);
           }
 
+        if (AvARRAY (priv)[CD_CORO] == &PL_sv_undef)
+          AvARRAY (priv)[CD_CORO] = SvREFCNT_inc (CORO_CURRENT);
+        else if (AvARRAY (priv)[CD_CORO] != CORO_CURRENT)
+          croak ("Coro::Event::next can only be called from a single coroutine at a time, caught");
+
+        XSRETURN_YES; /* schedule */
+}
+
+SV *
+_event (SV *self)
+	CODE:
+{
+        if (GIMME_V == G_VOID)
+          XSRETURN_EMPTY;
+
+        {
+          pe_watcher *w = GEventAPI->sv_2watcher (self);
+          AV *priv = (AV *)w->ext_data;
+
+          RETVAL = newRV_inc ((SV *)priv);
+        }
+}
+	OUTPUT:
+        RETVAL
+