--- Coro/Event/Event.xs	2001/08/17 04:08:58	1.5
+++ Coro/Event/Event.xs	2001/08/18 02:58:38	1.6
@@ -4,15 +4,28 @@
 
 #include <string.h>
 
+/* this useful idiom is unfortunately missing... */
+static void
+confess (const char *msg)
+{
+  dSP;
+
+  PUSHMARK(SP);
+  XPUSHs (sv_2mortal(newSVpv("only one coroutine can wait for an event",0)));
+  PUTBACK;
+  call_pv ("Carp::confess", G_VOID);
+}
+
 #include "EventAPI.h"
 #include "../Coro/CoroAPI.h"
 
 #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 CD_PRIO	3 /* hardcoded in Coro::Event */
+#define CD_HITS	4 /* hardcoded in Coro::Event */
+#define CD_GOT	5 /* hardcoded in Coro::Event, Coro::Handle */
+#define CD_MAX	5
 
 #define EV_CLASS "Coro::Event"
 
@@ -28,22 +41,26 @@
 static void
 coro_std_cb(pe_event *pe)
 {
-  AV *priv = (AV *)SvRV ((SV *)pe->ext_data);
+  AV *priv = (AV *)pe->ext_data;
   IV type = SvIV (*av_fetch (priv, CD_TYPE, 1));
-  SV *cd_coro = *av_fetch (priv, CD_CORO, 1);
+  SV **cd_coro = &AvARRAY(priv)[CD_CORO];
+
+  sv_setiv (AvARRAY(priv)[CD_PRIO], pe->prio);
+  sv_setiv (AvARRAY(priv)[CD_HITS], pe->hits);
 
   if (type == 1)
-    av_store (priv, CD_GOT, newSViv (((pe_ioevent *)pe)->got));
+    sv_setiv (AvARRAY(priv)[CD_GOT], ((pe_ioevent *)pe)->got);
 
-  if (SvROK (cd_coro))
+  if (*cd_coro != &PL_sv_undef)
     {
-      CORO_READY (cd_coro);
-      av_store (priv, CD_CORO, &PL_sv_undef);
+      CORO_READY (*cd_coro);
+      SvREFCNT_dec (*cd_coro);
+      *cd_coro = &PL_sv_undef;
       NEED_SCHEDULE;
     }
   else
     {
-      av_store (priv, CD_OK, &PL_sv_yes);
+      AvARRAY(priv)[CD_OK] = &PL_sv_yes;
       GEventAPI->stop (pe->up, 0);
     }
 }
@@ -69,7 +86,7 @@
         /* 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->base.prio = PE_PRIO_NORMAL; /* StarvePrio */
         scheduler->min_interval = newSVnv (0);
         scheduler->max_interval = newSVnv (0);
         GEventAPI->stop ((pe_watcher *)scheduler, 0);
@@ -85,10 +102,16 @@
         SV *rv = newRV_noinc ((SV *)priv);
 
         av_extend (priv, CD_MAX);
+        av_store (priv, CD_CORO, &PL_sv_undef);
         av_store (priv, CD_TYPE, newSViv (type));
+        av_store (priv, CD_OK  , &PL_sv_no);
+        av_store (priv, CD_PRIO, newSViv (0));
+        av_store (priv, CD_HITS, newSViv (0));
+        av_store (priv, CD_GOT , type ? newSViv (0) : &PL_sv_undef);
+        SvREADONLY_on (priv);
 
         w->callback = coro_std_cb;
-        w->ext_data = rv;
+        w->ext_data = priv;
 
         hv_store ((HV *)SvRV (self),
                   EV_CLASS, strlen (EV_CLASS),
@@ -99,22 +122,33 @@
 	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);
+            AvARRAY(priv)[CD_OK] = &PL_sv_no;
             XSRETURN_NO;
           }
         else 
           {
-            av_store (priv, CD_CORO, SvREFCNT_inc (CORO_CURRENT));
+            if (AvARRAY(priv)[CD_CORO] != &PL_sv_undef)
+              confess ("only one coroutine can wait for an event");
+
+            AvARRAY(priv)[CD_CORO] = SvREFCNT_inc (CORO_CURRENT);
             XSRETURN_YES;
           }
 
+MODULE = Coro::Event                PACKAGE = Coro
+
+# overwrite the ready function
+void
+ready(self)
+	SV *	self
+	CODE:
+        NEED_SCHEDULE;
+        CORO_READY (self);
+
+