--- cvsroot/EV/EV.xs 2007/10/31 10:50:05 1.15 +++ cvsroot/EV/EV.xs 2007/11/02 11:02:22 1.39 @@ -2,17 +2,16 @@ #include "perl.h" #include "XSUB.h" -#include -#include - -#define TIMEOUT_NONE HUGE_VAL - -#define EV_COMMON \ - SV *self; /* contains this struct */ \ - SV *cb_sv, *fh; +/*#include */ +#define EV_PROTOTYPES 1 #include "EV/EVAPI.h" +#include "libev/ev.c" +#include "libev/event.h" +#include "libev/event.c" +#include "libev/evdns.c" + typedef int Signal; static struct EVAPI evapi; @@ -20,41 +19,29 @@ static HV *stash_watcher, *stash_io, - *stash_time, *stash_timer, *stash_periodic, *stash_signal, *stash_idle, - *stash_check; + *stash_prepare, + *stash_check, + *stash_child; static int sv_signum (SV *sig) { int signum; - if (SvIV (sig) > 0) - return SvIV (sig); + SvGETMAGIC (sig); for (signum = 1; signum < SIG_SIZE; ++signum) if (strEQ (SvPV_nolen (sig), PL_sig_name [signum])) return signum; - return -1; -} + if (SvIV (sig) > 0) + return SvIV (sig); -static void -api_once (int fd, short events, double timeout, void (*cb)(int, short, void *), void *arg) -{ -#if 0 - if (timeout >= 0.) - { - struct timeval tv; - tv_set (&tv, timeout); - event_once (fd, events, cb, arg, &tv); - } - else - event_once (fd, events, cb, arg, 0); -#endif + return -1; } ///////////////////////////////////////////////////////////////////////////// @@ -73,7 +60,7 @@ if (SvTYPE (fh) == SVt_PVGV) return PerlIO_fileno (IoIFP (sv_2io (fh))); - if (SvIOK (fh)) + if ((SvIV (fh) >= 0) && (SvIV (fh) < 0x7ffffff)) return SvIV (fh); return -1; @@ -89,7 +76,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); @@ -98,6 +85,15 @@ return (void *)w; } +static void * +e_destroy (void *w_) +{ + struct ev_watcher *w = w_; + + SvREFCNT_dec (w->fh ); w->fh = 0; + SvREFCNT_dec (w->cb_sv); w->cb_sv = 0; +} + static SV * e_bless (struct ev_watcher *w, HV *stash) { @@ -120,7 +116,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 */ @@ -137,11 +133,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); @@ -157,7 +158,6 @@ } } -#if 0 ///////////////////////////////////////////////////////////////////////////// // DNS @@ -209,13 +209,20 @@ LEAVE; } -#endif + +#define CHECK_REPEAT(repeat) if (repeat < 0.) \ + croak (# repeat " value must be >= 0"); + +#define CHECK_FD(fh,fd) if ((fd) < 0) \ + croak ("illegal file descriptor or filehandle (either no attached file descriptor or illegal value): %s", SvPV_nolen (fh)); ///////////////////////////////////////////////////////////////////////////// // XS interface functions MODULE = EV PACKAGE = EV PREFIX = ev_ +PROTOTYPES: ENABLE + BOOT: { int i; @@ -226,6 +233,7 @@ IV iv; } *civ, const_iv[] = { # define const_iv(pfx, name) { # name, (IV) pfx ## name }, + const_iv (EV_, UNDEF) const_iv (EV_, NONE) const_iv (EV_, TIMEOUT) const_iv (EV_, READ) @@ -233,6 +241,7 @@ const_iv (EV_, SIGNAL) const_iv (EV_, IDLE) const_iv (EV_, CHECK) + const_iv (EV_, ERROR) const_iv (EV, LOOP_ONESHOT) const_iv (EV, LOOP_NONBLOCK) @@ -246,13 +255,14 @@ newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); stash_watcher = gv_stashpv ("EV::Watcher" , 1); - stash_io = gv_stashpv ("EV::IO" , 1); - stash_time = gv_stashpv ("EV::Time" , 1); + stash_io = gv_stashpv ("EV::Io" , 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); @@ -261,7 +271,6 @@ /* the poor man's shared library emulator */ evapi.ver = EV_API_VERSION; evapi.rev = EV_API_REVISION; - evapi.once = api_once; evapi.sv_fileno = sv_fileno; evapi.sv_signum = sv_signum; evapi.now = &ev_now; @@ -269,22 +278,30 @@ evapi.loop_done = &ev_loop_done; evapi.time = ev_time; evapi.loop = ev_loop; - evapi.io_start = evio_start; - evapi.io_stop = evio_stop; - evapi.timer_start = evtimer_start; - evapi.timer_stop = evtimer_stop; - 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.once = ev_once; + 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); } + + pthread_atfork (ev_fork_prepare, ev_fork_parent, ev_fork_child); } NV ev_now () @@ -313,30 +330,39 @@ ALIAS: io_ns = 1 CODE: +{ + int fd = sv_fileno (fh); + CHECK_FD (fh, fd); + 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, fd, events); + if (!ix) ev_io_start (RETVAL); +} OUTPUT: RETVAL struct ev_timer *timer (NV after, NV repeat, SV *cb) 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) 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 @@ -345,8 +371,8 @@ 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 @@ -355,8 +381,18 @@ 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 @@ -365,8 +401,18 @@ 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 @@ -388,22 +434,34 @@ 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 evio_start (struct ev_io *w) +void ev_io_start (struct ev_io *w) -void evio_stop (struct ev_io *w) +void ev_io_stop (struct ev_io *w) + +void DESTROY (struct ev_io *w) + CODE: + ev_io_stop (w); + e_destroy (w); void set (struct ev_io *w, SV *fh, int events) CODE: { int active = w->active; - if (active) evio_stop (w); + int fd = sv_fileno (fh); + CHECK_FD (fh, fd); + + if (active) ev_io_stop (w); sv_setsv (w->fh, fh); - evio_set (w, sv_fileno (w->fh), events); + ev_io_set (w, fd, events); - if (active) evio_start (w); + if (active) ev_io_start (w); } SV *fh (struct ev_io *w, SV *new_fh = 0) @@ -414,18 +472,18 @@ 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: RETVAL -short events (struct ev_io *w, short new_events = EV_UNDEF) +int events (struct ev_io *w, int new_events = EV_UNDEF) CODE: { RETVAL = w->events; @@ -433,21 +491,26 @@ 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 evsignal_start (struct ev_signal *w) +void ev_signal_start (struct ev_signal *w) -void evsignal_stop (struct ev_signal *w) +void ev_signal_stop (struct ev_signal *w) + +void DESTROY (struct ev_signal *w) + CODE: + ev_signal_stop (w); + e_destroy (w); void set (struct ev_signal *w, SV *signal = 0) CODE: @@ -455,56 +518,167 @@ 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); +} + +int signal (struct ev_signal *w, SV *new_signal = 0) + CODE: +{ + Signal signum = new_signal ? sv_signum (signal) : 0; /* may croak here */ + RETVAL = w->signum; + + if (items > 1) + { + int active = w->active; + if (active) ev_signal_stop (w); + + ev_signal_set (w, signum); + + if (active) ev_signal_start (w); + } } + OUTPUT: + RETVAL 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 ev_timer_again (struct ev_timer *w) + INIT: + CHECK_REPEAT (w->repeat); + +void DESTROY (struct ev_timer *w) + CODE: + ev_timer_stop (w); + e_destroy (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 ev_periodic_start (struct ev_periodic *w) + INIT: + CHECK_REPEAT (w->interval); -void evperiodic_start (struct ev_periodic *w) +void ev_periodic_stop (struct ev_periodic *w) -void evperiodic_stop (struct ev_periodic *w) +void DESTROY (struct ev_periodic *w) + CODE: + ev_periodic_stop (w); + e_destroy (w); void set (struct ev_periodic *w, NV at, NV interval = 0.) + INIT: + CHECK_REPEAT (interval); 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 evidle_start (struct ev_idle *w) +void ev_idle_start (struct ev_idle *w) -void evidle_stop (struct ev_idle *w) +void ev_idle_stop (struct ev_idle *w) -MODULE = EV PACKAGE = EV::Check PREFIX = evcheck_ +void DESTROY (struct ev_idle *w) + CODE: + ev_idle_stop (w); + e_destroy (w); -void evcheck_start (struct ev_check *w) +MODULE = EV PACKAGE = EV::Prepare PREFIX = ev_check_ -void evcheck_stop (struct ev_check *w) +void ev_prepare_start (struct ev_prepare *w) -#if 0 +void ev_prepare_stop (struct ev_prepare *w) + +void DESTROY (struct ev_prepare *w) + CODE: + ev_prepare_stop (w); + e_destroy (w); + +MODULE = EV PACKAGE = EV::Check PREFIX = ev_check_ + +void ev_check_start (struct ev_check *w) + +void ev_check_stop (struct ev_check *w) + +void DESTROY (struct ev_check *w) + CODE: + ev_check_stop (w); + e_destroy (w); + +MODULE = EV PACKAGE = EV::Child PREFIX = ev_child_ + +void ev_child_start (struct ev_child *w) + +void ev_child_stop (struct ev_child *w) + +void DESTROY (struct ev_child *w) + CODE: + ev_child_stop (w); + e_destroy (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); +} + +int pid (struct ev_child *w, int new_pid = 0) + CODE: +{ + RETVAL = newSVsv (w->pid); + + if (items > 1) + { + int active = w->active; + if (active) ev_child_stop (w); + + ev_child_set (w, new_pid); + + if (active) ev_child_start (w); + } +} + OUTPUT: + RETVAL + + +int status (struct ev_child *w) + CODE: + RETVAL = w->status; + OUTPUT: + RETVAL MODULE = EV PACKAGE = EV::DNS PREFIX = evdns_ @@ -597,6 +771,7 @@ void evdns_search_ndots_set (int ndots) +#if 0 MODULE = EV PACKAGE = EV::HTTP PREFIX = evhttp_