--- cvsroot/EV/EV.xs 2007/10/31 11:52:11 1.17 +++ cvsroot/EV/EV.xs 2007/11/27 07:27:10 1.80 @@ -2,18 +2,72 @@ #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" +/* fix perl api breakage */ +#undef signal +#undef sigaction + +#define EV_SELECT_IS_WINSOCKET 0 +#ifdef _WIN32 +# define EV_SELECT_USE_FD_SET 0 +# define NFDBITS PERL_NFDBITS +# define fd_mask Perl_fd_mask +#endif +/* due to bugs in OS X we have to use libev/ explicitly here */ #include "libev/ev.c" +#include "event.c" + +#ifndef _WIN32 +#define DNS_USE_GETTIMEOFDAY_FOR_ID 1 +#if !defined (WIN32) && !defined(__CYGWIN__) +# define HAVE_STRUCT_IN6_ADDR 1 +#endif +#undef HAVE_STRTOK_R +#undef strtok_r +#define strtok_r fake_strtok_r +#include "evdns.h" +#include "evdns.c" +#endif + +#ifndef _WIN32 +# include +#endif + +#define WFLAG_KEEPALIVE 1 + +#define UNREF(w) \ + if (!((w)->flags & WFLAG_KEEPALIVE) \ + && !ev_is_active (w)) \ + ev_unref (); + +#define REF(w) \ + if (!((w)->flags & WFLAG_KEEPALIVE) \ + && ev_is_active (w)) \ + ev_ref (); + +#define START(type,w) \ + do { \ + UNREF (w); \ + ev_ ## type ## _start (w); \ + } while (0) + +#define STOP(type,w) \ + do { \ + REF (w); \ + ev_ ## type ## _stop (w); \ + } while (0) + +#define RESET(type,w,seta) \ + do { \ + int active = ev_is_active (w); \ + if (active) STOP (type, w); \ + ev_ ## type ## _set seta; \ + if (active) START (type, w); \ + } while (0) typedef int Signal; @@ -22,47 +76,45 @@ static HV *stash_watcher, *stash_io, - *stash_time, *stash_timer, *stash_periodic, *stash_signal, *stash_idle, - *stash_check; + *stash_prepare, + *stash_check, + *stash_child, + *stash_embed, + *stash_stat; + +#ifndef SIG_SIZE +/* kudos to Slaven Rezic for the idea */ +static char sig_size [] = { SIG_NUM }; +# define SIG_SIZE (sizeof (sig_size) + 1) +#endif -static int +static Signal sv_signum (SV *sig) { - int signum; + Signal 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; -} + signum = 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 + if (signum > 0 && signum < SIG_SIZE) + return signum; + + return -1; } ///////////////////////////////////////////////////////////////////////////// // Event -static void e_cb (struct ev_watcher *w, int revents); +static void e_cb (ev_watcher *w, int revents); static int sv_fileno (SV *fh) @@ -75,7 +127,7 @@ if (SvTYPE (fh) == SVt_PVGV) return PerlIO_fileno (IoIFP (sv_2io (fh))); - if (SvIOK (fh)) + if (SvOK (fh) && (SvIV (fh) >= 0) && (SvIV (fh) < 0x7fffffffL)) return SvIV (fh); return -1; @@ -84,15 +136,17 @@ static void * e_new (int size, SV *cb_sv) { - struct ev_watcher *w; + ev_watcher *w; SV *self = NEWSV (0, size); SvPOK_only (self); SvCUR_set (self, size); - w = (struct ev_watcher *)SvPVX (self); + w = (ev_watcher *)SvPVX (self); - evw_init (w, e_cb); + ev_init (w, e_cb); + w->flags = WFLAG_KEEPALIVE; + w->data = 0; w->fh = 0; w->cb_sv = newSVsv (cb_sv); w->self = self; @@ -100,8 +154,18 @@ return (void *)w; } +static void +e_destroy (void *w_) +{ + ev_watcher *w = (ev_watcher *)w_; + + SvREFCNT_dec (w->fh ); w->fh = 0; + SvREFCNT_dec (w->cb_sv); w->cb_sv = 0; + SvREFCNT_dec (w->data ); w->data = 0; +} + static SV * -e_bless (struct ev_watcher *w, HV *stash) +e_bless (ev_watcher *w, HV *stash) { SV *rv; @@ -117,13 +181,14 @@ return rv; } +static SV *sv_events_cache; + static void -e_cb (struct ev_watcher *w, int revents) +e_cb (ev_watcher *w, int revents) { dSP; I32 mark = SP - PL_stack_base; SV *sv_self, *sv_events; - static SV *sv_events_cache; sv_self = newRV_inc (w->self); /* w->self MUST be blessed by now */ @@ -139,9 +204,9 @@ EXTEND (SP, 2); PUSHs (sv_self); PUSHs (sv_events); + PUTBACK; call_sv (w->cb_sv, G_DISCARD | G_VOID | G_EVAL); - SP = PL_stack_base + mark; PUTBACK; SvREFCNT_dec (sv_self); @@ -155,14 +220,98 @@ PUSHMARK (SP); PUTBACK; call_sv (get_sv ("EV::DIED", 1), G_DISCARD | G_VOID | G_EVAL | G_KEEPERR); - SP = PL_stack_base + mark; PUTBACK; } + + SP = PL_stack_base + mark; + PUTBACK; +} + +static void +e_once_cb (int revents, void *arg) +{ + dSP; + I32 mark = SP - PL_stack_base; + SV *sv_events; + + if (sv_events_cache) + { + sv_events = sv_events_cache; sv_events_cache = 0; + SvIV_set (sv_events, revents); + } + else + sv_events = newSViv (revents); + + PUSHMARK (SP); + XPUSHs (sv_events); + + PUTBACK; + call_sv ((SV *)arg, G_DISCARD | G_VOID | G_EVAL); + + SvREFCNT_dec ((SV *)arg); + + if (sv_events_cache) + SvREFCNT_dec (sv_events); + else + sv_events_cache = sv_events; + + if (SvTRUE (ERRSV)) + { + PUSHMARK (SP); + PUTBACK; + call_sv (get_sv ("EV::DIED", 1), G_DISCARD | G_VOID | G_EVAL | G_KEEPERR); + } + + SP = PL_stack_base + mark; + PUTBACK; +} + +static ev_tstamp +e_periodic_cb (ev_periodic *w, ev_tstamp now) +{ + ev_tstamp retval; + int count; + dSP; + + ENTER; + SAVETMPS; + + PUSHMARK (SP); + EXTEND (SP, 2); + PUSHs (newRV_inc (w->self)); /* w->self MUST be blessed by now */ + PUSHs (newSVnv (now)); + + PUTBACK; + count = call_sv (w->fh, G_SCALAR | G_EVAL); + SPAGAIN; + + if (SvTRUE (ERRSV)) + { + PUSHMARK (SP); + PUTBACK; + call_sv (get_sv ("EV::DIED", 1), G_DISCARD | G_VOID | G_EVAL | G_KEEPERR); + SPAGAIN; + } + + if (count > 0) + { + retval = SvNV (TOPs); + + if (retval < now) + retval = now; + } + else + retval = now; + + FREETMPS; + LEAVE; + + return retval; } -#if 0 ///////////////////////////////////////////////////////////////////////////// // DNS +#ifndef _WIN32 static void dns_cb (int result, char type, int count, int ttl, void *addresses, void *arg) { @@ -213,14 +362,24 @@ } #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)); + +#define CHECK_SIG(sv,num) if ((num) < 0) \ + croak ("illegal signal number or name: %s", SvPV_nolen (sv)); + ///////////////////////////////////////////////////////////////////////////// // XS interface functions MODULE = EV PACKAGE = EV PREFIX = ev_ +PROTOTYPES: ENABLE + BOOT: { - int i; HV *stash = gv_stashpv ("EV", 1); static const struct { @@ -228,6 +387,10 @@ IV iv; } *civ, const_iv[] = { # define const_iv(pfx, name) { # name, (IV) pfx ## name }, + const_iv (EV_, MINPRI) + const_iv (EV_, MAXPRI) + + const_iv (EV_, UNDEF) const_iv (EV_, NONE) const_iv (EV_, TIMEOUT) const_iv (EV_, READ) @@ -235,13 +398,21 @@ 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) + const_iv (EV, UNLOOP_ONE) + const_iv (EV, UNLOOP_ALL) - const_iv (EV, METHOD_NONE) - const_iv (EV, METHOD_SELECT) - const_iv (EV, METHOD_EPOLL) + const_iv (EV, BACKEND_SELECT) + const_iv (EV, BACKEND_POLL) + const_iv (EV, BACKEND_EPOLL) + const_iv (EV, BACKEND_KQUEUE) + const_iv (EV, BACKEND_DEVPOLL) + const_iv (EV, BACKEND_PORT) + const_iv (EV, FLAG_AUTO) + const_iv (EV, FLAG_NOENV) }; for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) @@ -249,12 +420,15 @@ stash_watcher = gv_stashpv ("EV::Watcher" , 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); + stash_embed = gv_stashpv ("EV::Embed" , 1); + stash_stat = gv_stashpv ("EV::Stat" , 1); { SV *sv = perl_get_sv ("EV::API", TRUE); @@ -263,124 +437,202 @@ /* 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; - evapi.method = &ev_method; - evapi.loop_done = &ev_loop_done; + evapi.now = ev_now; + evapi.backend = ev_backend; + evapi.unloop = ev_unloop; + evapi.ref = ev_ref; + evapi.unref = ev_unref; 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.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.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; + evapi.stat_start = ev_stat_start; + evapi.stat_stop = ev_stat_stop; + evapi.stat_stat = ev_stat_stat; sv_setiv (sv, (IV)&evapi); SvREADONLY_on (sv); } +#ifndef _WIN32 + pthread_atfork (0, 0, ev_default_fork); +#endif } NV ev_now () - CODE: - RETVAL = ev_now; - OUTPUT: - RETVAL -int ev_method () - CODE: - RETVAL = ev_method; - OUTPUT: - RETVAL +unsigned int ev_backend () NV ev_time () -void ev_init (int flags = 0) +unsigned int ev_default_loop (unsigned int flags = ev_supported_backends ()) void ev_loop (int flags = 0) -void ev_loop_done (int value = 1) - CODE: - ev_loop_done = value; +void ev_unloop (int how = 1) -struct ev_io *io (SV *fh, int events, SV *cb) +ev_io *io (SV *fh, int events, SV *cb) ALIAS: io_ns = 1 CODE: - RETVAL = e_new (sizeof (struct ev_io), cb); +{ + int fd = sv_fileno (fh); + CHECK_FD (fh, fd); + + RETVAL = e_new (sizeof (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) START (io, RETVAL); +} OUTPUT: RETVAL -struct ev_timer *timer (NV after, NV repeat, SV *cb) +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); + RETVAL = e_new (sizeof (ev_timer), cb); + ev_timer_set (RETVAL, after, repeat); + if (!ix) START (timer, RETVAL); OUTPUT: RETVAL -struct ev_periodic *periodic (NV at, NV interval, SV *cb) +SV *periodic (NV at, NV interval, SV *reschedule_cb, 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 *w; + w = e_new (sizeof (ev_periodic), cb); + w->fh = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0; + ev_periodic_set (w, at, interval, w->fh ? e_periodic_cb : 0); + RETVAL = e_bless ((ev_watcher *)w, stash_periodic); + if (!ix) START (periodic, w); +} OUTPUT: RETVAL -struct ev_signal *signal (Signal signum, SV *cb) +ev_signal *signal (SV *signal, SV *cb) ALIAS: signal_ns = 1 CODE: - RETVAL = e_new (sizeof (struct ev_signal), cb); - evsignal_set (RETVAL, signum); - if (!ix) evsignal_start (RETVAL); +{ + Signal signum = sv_signum (signal); + CHECK_SIG (signal, signum); + + RETVAL = e_new (sizeof (ev_signal), cb); + ev_signal_set (RETVAL, signum); + if (!ix) START (signal, RETVAL); +} OUTPUT: RETVAL -struct ev_idle *idle (SV *cb) +ev_idle *idle (SV *cb) ALIAS: idle_ns = 1 CODE: - RETVAL = e_new (sizeof (struct ev_idle), cb); - evidle_set (RETVAL); - if (!ix) evidle_start (RETVAL); + RETVAL = e_new (sizeof (ev_idle), cb); + ev_idle_set (RETVAL); + if (!ix) START (idle, RETVAL); OUTPUT: RETVAL -struct ev_check *check (SV *cb) +ev_prepare *prepare (SV *cb) + ALIAS: + prepare_ns = 1 + CODE: + RETVAL = e_new (sizeof (ev_prepare), cb); + ev_prepare_set (RETVAL); + if (!ix) START (prepare, RETVAL); + OUTPUT: + RETVAL + +ev_check *check (SV *cb) ALIAS: check_ns = 1 CODE: - RETVAL = e_new (sizeof (struct ev_check), cb); - evcheck_set (RETVAL); - if (!ix) evcheck_start (RETVAL); + RETVAL = e_new (sizeof (ev_check), cb); + ev_check_set (RETVAL); + if (!ix) START (check, RETVAL); + OUTPUT: + RETVAL + +ev_child *child (int pid, SV *cb) + ALIAS: + child_ns = 1 + CODE: + RETVAL = e_new (sizeof (ev_child), cb); + ev_child_set (RETVAL, pid); + if (!ix) START (child, RETVAL); OUTPUT: RETVAL +ev_stat *stat (SV *path, NV interval, SV *cb) + ALIAS: + stat_ns = 1 + CODE: + RETVAL = e_new (sizeof (ev_stat), cb); + RETVAL->fh = newSVsv (path); + ev_stat_set (RETVAL, SvPVbyte_nolen (RETVAL->fh), interval); + if (!ix) START (stat, RETVAL); + OUTPUT: + RETVAL + +void once (SV *fh, int events, SV *timeout, SV *cb) + CODE: + ev_once ( + sv_fileno (fh), events, + SvOK (timeout) ? SvNV (timeout) : -1., + e_once_cb, + newSVsv (cb) + ); PROTOTYPES: DISABLE MODULE = EV PACKAGE = EV::Watcher PREFIX = ev_ -int ev_is_active (struct ev_watcher *w) +int ev_is_active (ev_watcher *w) -SV *cb (struct ev_watcher *w, SV *new_cb = 0) +int ev_is_pending (ev_watcher *w) + +int keepalive (ev_watcher *w, int new_value = 0) + CODE: +{ + RETVAL = w->flags & WFLAG_KEEPALIVE; + new_value = new_value ? WFLAG_KEEPALIVE : 0; + + if (items > 1 && ((new_value ^ w->flags) & WFLAG_KEEPALIVE)) + { + REF (w); + w->flags = (w->flags & ~WFLAG_KEEPALIVE) | new_value; + UNREF (w); + } +} + OUTPUT: + RETVAL + +SV *cb (ev_watcher *w, SV *new_cb = 0) CODE: { RETVAL = newSVsv (w->cb_sv); @@ -391,125 +643,350 @@ OUTPUT: RETVAL -MODULE = EV PACKAGE = EV::IO PREFIX = evio_ +SV *data (ev_watcher *w, SV *new_data = 0) + CODE: +{ + RETVAL = w->data ? newSVsv (w->data) : &PL_sv_undef; -void evio_start (struct ev_io *w) + if (items > 1) + { + SvREFCNT_dec (w->data); + w->data = newSVsv (new_data); + } +} + OUTPUT: + RETVAL -void evio_stop (struct ev_io *w) +void trigger (ev_watcher *w, int revents = EV_NONE) + CODE: + w->cb (w, revents); -void set (struct ev_io *w, SV *fh, int events) +int priority (ev_watcher *w, int new_priority = 0) CODE: { - int active = w->active; - if (active) evio_stop (w); + RETVAL = w->priority; - sv_setsv (w->fh, fh); - evio_set (w, sv_fileno (w->fh), events); + if (items > 1) + { + int active = ev_is_active (w); + + if (new_priority < EV_MINPRI || new_priority > EV_MAXPRI) + croak ("watcher priority out of range, value must be between %d and %d, inclusive", EV_MINPRI, EV_MAXPRI); - if (active) evio_start (w); + if (active) + { + /* grrr. */ + PUSHMARK (SP); + XPUSHs (ST (0)); + call_method ("stop", G_DISCARD | G_VOID); + } + + ev_set_priority (w, new_priority); + + if (active) + { + PUSHMARK (SP); + XPUSHs (ST (0)); + call_method ("start", G_DISCARD | G_VOID); + } + } } + OUTPUT: + RETVAL + +MODULE = EV PACKAGE = EV::IO PREFIX = ev_io_ -SV *fh (struct ev_io *w, SV *new_fh = 0) +void ev_io_start (ev_io *w) + CODE: + START (io, w); + +void ev_io_stop (ev_io *w) + CODE: + STOP (io, w); + +void DESTROY (ev_io *w) + CODE: + STOP (io, w); + e_destroy (w); + +void set (ev_io *w, SV *fh, int events) CODE: { - RETVAL = newSVsv (w->fh); + int fd = sv_fileno (fh); + CHECK_FD (fh, fd); + + sv_setsv (w->fh, fh); + RESET (io, w, (w, fd, events)); +} +SV *fh (ev_io *w, SV *new_fh = 0) + CODE: +{ if (items > 1) { - int active = w->active; - if (active) evio_stop (w); + int fd = sv_fileno (new_fh); + CHECK_FD (new_fh, fd); - sv_setsv (w->fh, new_fh); - evio_set (w, sv_fileno (w->fh), w->events); + RETVAL = w->fh; + w->fh = newSVsv (new_fh); - if (active) evio_start (w); + RESET (io, w, (w, fd, w->events)); } + else + RETVAL = newSVsv (w->fh); } OUTPUT: RETVAL -short events (struct ev_io *w, short new_events = EV_UNDEF) +int events (ev_io *w, int new_events = EV_UNDEF) CODE: { RETVAL = w->events; if (items > 1) - { - int active = w->active; - if (active) evio_stop (w); + RESET (io, w, (w, w->fd, new_events)); +} + OUTPUT: + RETVAL - evio_set (w, w->fd, new_events); +MODULE = EV PACKAGE = EV::Signal PREFIX = ev_signal_ + +void ev_signal_start (ev_signal *w) + CODE: + START (signal, w); - if (active) evio_start (w); +void ev_signal_stop (ev_signal *w) + CODE: + STOP (signal, w); + +void DESTROY (ev_signal *w) + CODE: + STOP (signal, w); + e_destroy (w); + +void set (ev_signal *w, SV *signal) + CODE: +{ + Signal signum = sv_signum (signal); + CHECK_SIG (signal, signum); + + RESET (signal, w, (w, signum)); +} + +int signal (ev_signal *w, SV *new_signal = 0) + CODE: +{ + RETVAL = w->signum; + + if (items > 1) + { + Signal signum = sv_signum (new_signal); + CHECK_SIG (new_signal, signum); + + RESET (signal, w, (w, signum)); } } OUTPUT: RETVAL -MODULE = EV PACKAGE = EV::Signal PREFIX = evsignal_ +MODULE = EV PACKAGE = EV::Timer PREFIX = ev_timer_ + +void ev_timer_start (ev_timer *w) + INIT: + CHECK_REPEAT (w->repeat); + CODE: + START (timer, w); -void evsignal_start (struct ev_signal *w) +void ev_timer_stop (ev_timer *w) + CODE: + STOP (timer, w); -void evsignal_stop (struct ev_signal *w) +void ev_timer_again (ev_timer *w) + INIT: + CHECK_REPEAT (w->repeat); + CODE: + REF (w); + ev_timer_again (w); + UNREF (w); -void set (struct ev_signal *w, SV *signal = 0) +void DESTROY (ev_timer *w) CODE: -{ - Signal signum = sv_signum (signal); /* may croak here */ - int active = w->active; + STOP (timer, w); + e_destroy (w); - if (active) evsignal_stop (w); - evsignal_set (w, signum); - if (active) evsignal_start (w); -} +void set (ev_timer *w, NV after, NV repeat = 0.) + INIT: + CHECK_REPEAT (repeat); + CODE: + RESET (timer, w, (w, after, repeat)); -MODULE = EV PACKAGE = EV::Time +MODULE = EV PACKAGE = EV::Periodic PREFIX = ev_periodic_ -MODULE = EV PACKAGE = EV::Timer PREFIX = evtimer_ +void ev_periodic_start (ev_periodic *w) + INIT: + CHECK_REPEAT (w->interval); + CODE: + START (periodic, w); -void evtimer_start (struct ev_timer *w) +void ev_periodic_stop (ev_periodic *w) + CODE: + STOP (periodic, w); -void evtimer_stop (struct ev_timer *w) +void ev_periodic_again (ev_periodic *w) + CODE: + REF (w); + ev_periodic_again (w); + UNREF (w); -void evtimer_again (struct ev_timer *w) +void DESTROY (ev_periodic *w) + CODE: + STOP (periodic, w); + e_destroy (w); -void set (struct ev_timer *w, NV after, NV repeat = 0.) +void set (ev_periodic *w, NV at, NV interval = 0., SV *reschedule_cb = &PL_sv_undef) + INIT: + CHECK_REPEAT (interval); CODE: { - int active = w->active; - if (active) evtimer_stop (w); - evtimer_set (w, after, repeat); - if (active) evtimer_start (w); + SvREFCNT_dec (w->fh); + w->fh = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0; + + RESET (periodic, w, (w, at, interval, w->fh ? e_periodic_cb : 0)); } -MODULE = EV PACKAGE = EV::Periodic PREFIX = evperiodic_ +MODULE = EV PACKAGE = EV::Idle PREFIX = ev_idle_ + +void ev_idle_start (ev_idle *w) + CODE: + START (idle, w); + +void ev_idle_stop (ev_idle *w) + CODE: + STOP (idle, w); + +void DESTROY (ev_idle *w) + CODE: + STOP (idle, w); + e_destroy (w); -void evperiodic_start (struct ev_periodic *w) +MODULE = EV PACKAGE = EV::Prepare PREFIX = ev_check_ -void evperiodic_stop (struct ev_periodic *w) +void ev_prepare_start (ev_prepare *w) + CODE: + START (prepare, w); + +void ev_prepare_stop (ev_prepare *w) + CODE: + STOP (prepare, w); + +void DESTROY (ev_prepare *w) + CODE: + STOP (prepare, w); + e_destroy (w); + +MODULE = EV PACKAGE = EV::Check PREFIX = ev_check_ + +void ev_check_start (ev_check *w) + CODE: + START (check, w); -void set (struct ev_periodic *w, NV at, NV interval = 0.) +void ev_check_stop (ev_check *w) + CODE: + STOP (check, w); + +void DESTROY (ev_check *w) + CODE: + STOP (check, w); + e_destroy (w); + +MODULE = EV PACKAGE = EV::Child PREFIX = ev_child_ + +void ev_child_start (ev_child *w) + CODE: + START (child, w); + +void ev_child_stop (ev_child *w) + CODE: + STOP (child, w); + +void DESTROY (ev_child *w) + CODE: + STOP (child, w); + e_destroy (w); + +void set (ev_child *w, int pid) + CODE: + RESET (child, w, (w, pid)); + +int pid (ev_child *w, int new_pid = 0) CODE: { - int active = w->active; - if (active) evperiodic_stop (w); - evperiodic_set (w, at, interval); - if (active) evperiodic_start (w); + RETVAL = w->pid; + + if (items > 1) + RESET (child, w, (w, new_pid)); } + OUTPUT: + RETVAL -MODULE = EV PACKAGE = EV::Idle PREFIX = evidle_ -void evidle_start (struct ev_idle *w) +int rstatus (ev_child *w) + ALIAS: + rpid = 1 + CODE: + RETVAL = ix ? w->rpid : w->rstatus; + OUTPUT: + RETVAL -void evidle_stop (struct ev_idle *w) +MODULE = EV PACKAGE = EV::Stat PREFIX = ev_stat_ -MODULE = EV PACKAGE = EV::Check PREFIX = evcheck_ +void ev_stat_start (ev_stat *w) + CODE: + START (stat, w); -void evcheck_start (struct ev_check *w) +void ev_stat_stop (ev_stat *w) + CODE: + STOP (stat, w); -void evcheck_stop (struct ev_check *w) +void DESTROY (ev_stat *w) + CODE: + STOP (stat, w); + e_destroy (w); -#if 0 +void set (ev_stat *w, SV *path, NV interval) + CODE: +{ + sv_setsv (w->fh, path); + RESET (stat, w, (w, SvPVbyte_nolen (w->fh), interval)); +} + +SV *path (ev_stat *w, SV *new_path = 0) + CODE: +{ + RETVAL = SvREFCNT_inc (w->fh); + + if (items > 1) + { + SvREFCNT_dec (w->fh); + w->fh = newSVsv (new_path); + RESET (stat, w, (w, SvPVbyte_nolen (w->fh), w->interval)); + } +} + OUTPUT: + RETVAL + +NV interval (ev_stat *w, NV new_interval = 0.) + CODE: +{ + RETVAL = w->interval; + + if (items > 1) + RESET (stat, w, (w, SvPVbyte_nolen (w->fh), new_interval)); +} + OUTPUT: + RETVAL + +#ifndef _WIN32 MODULE = EV PACKAGE = EV::DNS PREFIX = evdns_ @@ -590,7 +1067,7 @@ int evdns_resolv_conf_parse (int flags, const char *filename) -#ifdef MS_WINDOWS +#ifdef _WIN32 int evdns_config_windows_nameservers () @@ -602,6 +1079,7 @@ void evdns_search_ndots_set (int ndots) +#if 0 MODULE = EV PACKAGE = EV::HTTP PREFIX = evhttp_ @@ -643,6 +1121,7 @@ #endif +#endif