ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/EV/EV.xs
(Generate patch)

Comparing EV/EV.xs (file contents):
Revision 1.1 by root, Fri Oct 26 16:50:05 2007 UTC vs.
Revision 1.153 by root, Mon Jan 10 01:59:41 2011 UTC

1#include "EXTERN.h" 1#include "EXTERN.h"
2#include "perl.h" 2#include "perl.h"
3#include "XSUB.h" 3#include "XSUB.h"
4 4
5#include <math.h> 5/* fix perl api breakage */
6#include <netinet/in.h> 6#undef signal
7#undef sigaction
7 8
8#include <sys/time.h> 9#include "schmorp.h"
9#include <time.h>
10#include <event.h>
11#include <evdns.h>
12/*include <evhttp.h>*/ /* does not compile */
13 10
11/* old API compatibility */
12static int
13sv_fileno (SV *fh)
14{
15 return s_fileno (fh, 0);
16}
17
14#define EV_NONE 0 18#define EV_STANDALONE 1
15#define EV_UNDEF -1 19#define EV_PROTOTYPES 1
20#define EV_USE_CLOCK_SYSCALL 0 /* as long as we need pthreads anyways... */
21#define EV_USE_NANOSLEEP EV_USE_MONOTONIC
22#define EV_H <ev.h>
23#define EV_CONFIG_H error
24#include "EV/EVAPI.h"
16 25
17#define TIMEOUT_NONE HUGE_VAL 26#define EV_SELECT_IS_WINSOCKET 0
27#ifdef _WIN32
28# define EV_SELECT_USE_FD_SET 0
29# define NFDBITS PERL_NFDBITS
30# define fd_mask Perl_fd_mask
31#endif
32/* due to bugs in OS X we have to use libev/ explicitly here */
33#include "libev/ev.c"
18 34
19typedef struct event_base *Base; 35#if !defined(_WIN32) && !defined(_MINIX)
36# include <pthread.h>
37#endif
20 38
21static HV *stash_base, *stash_event; 39#define e_loop(w) INT2PTR (struct ev_loop *, SvIVX (((ev_watcher *)(w))->loop))
40#define e_flags(w) ((ev_watcher *)(w))->e_flags
41#define e_self(w) ((ev_watcher *)(w))->self
42#define e_fh(w) ((ev_watcher *)(w))->fh
43#define e_data(w) ((ev_watcher *)(w))->data
22 44
23static double tv_get (struct timeval *tv) 45#define WFLAG_KEEPALIVE 1
24{ 46#define WFLAG_UNREFED 2 /* has been unref'ed */
25 return tv->tv_sec + tv->tv_usec * 1e-6;
26}
27 47
28static void tv_set (struct timeval *tv, double val) 48#define UNREF(w) \
29{ 49 if (!(e_flags (w) & (WFLAG_KEEPALIVE | WFLAG_UNREFED)) \
30 tv->tv_sec = (long)val; 50 && ev_is_active (w)) \
31 tv->tv_usec = (long)((val - (double)tv->tv_sec) * 1e6); 51 { \
52 ev_unref (e_loop (w)); \
53 e_flags (w) |= WFLAG_UNREFED; \
54 }
32 55
33} 56#define REF(w) \
57 if (e_flags (w) & WFLAG_UNREFED) \
58 { \
59 e_flags (w) &= ~WFLAG_UNREFED; \
60 ev_ref (e_loop (w)); \
61 }
62
63#define START(type,w) \
64 do { \
65 ev_ ## type ## _start (e_loop (w), w); \
66 UNREF (w); \
67 } while (0)
68
69#define STOP(type,w) \
70 do { \
71 REF (w); \
72 ev_ ## type ## _stop (e_loop (w), w); \
73 } while (0)
74
75#define RESET(type,w,seta) \
76 do { \
77 int active = ev_is_active (w); \
78 if (active) STOP (type, w); \
79 ev_ ## type ## _set seta; \
80 if (active) START (type, w); \
81 } while (0)
82
83typedef int Signal;
84
85/* horrible... */
86#define CHECK_SIGNAL_CAN_START(w) \
87 do { \
88 /* dive into the internals of libev to avoid aborting in libev */ \
89 if (signals [(w)->signum - 1].loop \
90 && signals [(w)->signum - 1].loop != e_loop (w)) \
91 croak ("unable to start signal watcher, signal %d already registered in another loop", w->signum); \
92 } while (0)
93
94#define START_SIGNAL(w) \
95 do { \
96 CHECK_SIGNAL_CAN_START (w); \
97 START (signal, w); \
98 } while (0) \
99
100#define RESET_SIGNAL(w,seta) \
101 do { \
102 int active = ev_is_active (w); \
103 if (active) STOP (signal, w); \
104 ev_ ## signal ## _set seta; \
105 if (active) START_SIGNAL (w); \
106 } while (0)
107
108static SV *default_loop_sv;
109
110static struct EVAPI evapi;
111
112static HV
113 *stash_loop,
114 *stash_watcher,
115 *stash_io,
116 *stash_timer,
117 *stash_periodic,
118 *stash_signal,
119 *stash_child,
120 *stash_stat,
121 *stash_idle,
122 *stash_prepare,
123 *stash_check,
124 *stash_embed,
125 *stash_fork,
126 *stash_cleanup,
127 *stash_async;
34 128
35///////////////////////////////////////////////////////////////////////////// 129/////////////////////////////////////////////////////////////////////////////
36// Event 130// Event
37 131
38typedef struct ev { 132static void e_cb (EV_P_ ev_watcher *w, int revents);
39 struct event ev;
40 SV *cb, *fh;
41 SV *self; /* contains this struct */
42 double timeout;
43 double interval;
44 unsigned char active;
45 unsigned char abstime;
46} *Event;
47 133
48static double 134void *
49e_now () 135e_new (int size, SV *cb_sv, SV *loop)
50{ 136{
51 struct timeval tv; 137 SV *cv = cb_sv ? s_get_cv_croak (cb_sv) : 0;
52 gettimeofday (&tv, 0); 138 ev_watcher *w;
53
54 return tv_get (&tv);
55}
56
57static void e_cb (int fd, short events, void *arg);
58
59static int sv_fileno (SV *fh)
60{
61 if (fh)
62 {
63 SvGETMAGIC (fh);
64
65 if (SvROK (fh))
66 fh = SvRV (fh);
67
68 if (SvTYPE (fh) == SVt_PVGV)
69 return PerlIO_fileno (IoIFP (sv_2io (fh)));
70
71 if (SvIOK (fh))
72 return SvIV (fh);
73 }
74
75 return -1;
76}
77
78static Event
79e_new (SV *fh, short events, SV *cb)
80{
81 int fd = sv_fileno (fh);
82 Event ev;
83 SV *self = NEWSV (0, sizeof (struct ev)); 139 SV *self = NEWSV (0, size);
84 SvPOK_only (self); 140 SvPOK_only (self);
85 SvCUR_set (self, sizeof (struct ev)); 141 SvCUR_set (self, size);
86 142
87 ev = (Event)SvPVX (self); 143 w = (ev_watcher *)SvPVX (self);
88 144
89 ev->fh = newSVsv (fh); 145 ev_init (w, cv ? e_cb : 0);
90 ev->cb = newSVsv (cb); 146
147 w->loop = SvREFCNT_inc (SvRV (loop));
148 w->e_flags = WFLAG_KEEPALIVE;
149 w->data = 0;
150 w->fh = 0;
151 w->cb_sv = SvREFCNT_inc (cv);
91 ev->self = self; 152 w->self = self;
92 ev->timeout = TIMEOUT_NONE;
93 ev->interval = 0.;
94 ev->abstime = 0;
95 ev->active = 0;
96 153
97 event_set (&ev->ev, fd, events, e_cb, (void *)ev); 154 return (void *)w;
98
99 return ev;
100} 155}
101 156
102static struct timeval * 157static void
103e_tv (Event ev) 158e_destroy (void *w_)
104{ 159{
105 static struct timeval tv; 160 ev_watcher *w = (ev_watcher *)w_;
106 double to = ev->timeout;
107 161
108 if (to == TIMEOUT_NONE) 162 SvREFCNT_dec (w->loop ); w->loop = 0;
109 return 0; 163 SvREFCNT_dec (w->fh ); w->fh = 0;
110 164 SvREFCNT_dec (w->cb_sv); w->cb_sv = 0;
111 if (ev->abstime) 165 SvREFCNT_dec (w->data ); w->data = 0;
112 {
113 double now = e_now ();
114
115 if (now > to && ev->interval)
116 ev->timeout = (to += ceil ((now - to) / ev->interval) * ev->interval);
117
118 to -= now;
119 }
120 else if (to < 0.)
121 to = 0.;
122
123 tv_set (&tv, to);
124
125 return &tv;
126} 166}
127 167
128static SV *e_self (Event ev) 168static SV *
169e_bless (ev_watcher *w, HV *stash)
129{ 170{
130 SV *rv; 171 SV *rv;
131 172
132 if (SvOBJECT (ev->self)) 173 if (SvOBJECT (w->self))
133 rv = newRV_inc (ev->self); 174 rv = newRV_inc (w->self);
134 else 175 else
135 { 176 {
136 rv = newRV_noinc (ev->self); 177 rv = newRV_noinc (w->self);
137 sv_bless (rv, stash_event); 178 sv_bless (rv, stash);
138 SvREADONLY_on (ev->self); 179 SvREADONLY_on (w->self);
139 } 180 }
140 181
141 return rv; 182 return rv;
142} 183}
143 184
144static int 185static SV *sv_self_cache, *sv_events_cache;
145e_start (Event ev)
146{
147 if (ev->active) event_del (&ev->ev);
148 ev->active = 1;
149 return event_add (&ev->ev, e_tv (ev));
150}
151
152static int e_stop (Event ev)
153{
154 return ev->active
155 ? (ev->active = 0), event_del (&ev->ev)
156 : 0;
157}
158 186
159static void 187static void
188e_cb (EV_P_ ev_watcher *w, int revents)
189{
190 dSP;
191 I32 mark = SP - PL_stack_base;
192 SV *sv_self, *sv_events;
193
194 /* libev might have stopped the watcher */
195 if (expect_false (w->e_flags & WFLAG_UNREFED)
196 && !ev_is_active (w))
197 REF (w);
198
199 if (expect_true (sv_self_cache))
200 {
201 sv_self = sv_self_cache; sv_self_cache = 0;
202 SvRV_set (sv_self, SvREFCNT_inc_NN (w->self));
203 }
204 else
205 {
206 sv_self = newRV_inc (w->self); /* e_self (w) MUST be blessed by now */
207 SvREADONLY_on (sv_self);
208 }
209
210 if (expect_true (sv_events_cache))
211 {
212 sv_events = sv_events_cache; sv_events_cache = 0;
213 SvIV_set (sv_events, revents);
214 SvIOK_only (sv_events);
215 }
216 else
217 {
218 sv_events = newSViv (revents);
219 SvREADONLY_on (sv_events);
220 }
221
222 PUSHMARK (SP);
223 EXTEND (SP, 2);
224 PUSHs (sv_self);
225 PUSHs (sv_events);
226
227 PUTBACK;
228 call_sv (w->cb_sv, G_DISCARD | G_VOID | G_EVAL);
229
230 if (expect_false (SvREFCNT (sv_self) != 1 || sv_self_cache))
231 SvREFCNT_dec (sv_self);
232 else
233 {
234 SvREFCNT_dec (SvRV (sv_self));
235 SvRV_set (sv_self, &PL_sv_undef);
236 sv_self_cache = sv_self;
237 }
238
239 if (expect_false (SvREFCNT (sv_events) != 1 || sv_events_cache))
240 SvREFCNT_dec (sv_events);
241 else
242 sv_events_cache = sv_events;
243
244 if (expect_false (SvTRUE (ERRSV)))
245 {
246 SPAGAIN;
247 PUSHMARK (SP);
248 PUTBACK;
249 call_sv (get_sv ("EV::DIED", 1), G_DISCARD | G_VOID | G_EVAL | G_KEEPERR);
250 }
251
252 SP = PL_stack_base + mark;
253 PUTBACK;
254}
255
256static void
160e_cb (int fd, short events, void *arg) 257e_once_cb (int revents, void *arg)
161{ 258{
162 struct ev *ev = (struct ev*)arg; 259 dSP;
260 I32 mark = SP - PL_stack_base;
261 SV *sv_events;
262
263 if (sv_events_cache)
264 {
265 sv_events = sv_events_cache; sv_events_cache = 0;
266 SvIV_set (sv_events, revents);
267 }
268 else
269 sv_events = newSViv (revents);
270
271 PUSHMARK (SP);
272 XPUSHs (sv_events);
273
274 PUTBACK;
275 call_sv ((SV *)arg, G_DISCARD | G_VOID | G_EVAL);
276
277 SvREFCNT_dec ((SV *)arg);
278
279 if (sv_events_cache)
280 SvREFCNT_dec (sv_events);
281 else
282 sv_events_cache = sv_events;
283
284 if (SvTRUE (ERRSV))
285 {
286 SPAGAIN;
287 PUSHMARK (SP);
288 PUTBACK;
289 call_sv (get_sv ("EV::DIED", 1), G_DISCARD | G_VOID | G_EVAL | G_KEEPERR);
290 }
291
292 SP = PL_stack_base + mark;
293 PUTBACK;
294}
295
296static ev_tstamp
297e_periodic_cb (ev_periodic *w, ev_tstamp now)
298{
299 ev_tstamp retval;
300 int count;
163 dSP; 301 dSP;
164 302
165 ENTER; 303 ENTER;
166 SAVETMPS; 304 SAVETMPS;
167 305
168 if (!(ev->ev.ev_events & EV_PERSIST))
169 ev->active = 0;
170
171 PUSHMARK (SP); 306 PUSHMARK (SP);
172 EXTEND (SP, 2); 307 EXTEND (SP, 2);
173 PUSHs (sv_2mortal (e_self (ev))); 308 PUSHs (newRV_inc (e_self (w))); /* e_self (w) MUST be blessed by now */
174 PUSHs (sv_2mortal (newSViv (events))); 309 PUSHs (newSVnv (now));
310
175 PUTBACK; 311 PUTBACK;
176 call_sv (ev->cb, G_DISCARD | G_VOID | G_EVAL); 312 count = call_sv (w->fh, G_SCALAR | G_EVAL);
177 /*TODO: if err, call some logging function */ 313 SPAGAIN;
178 314
179 if (ev->interval && !ev->active) 315 if (SvTRUE (ERRSV))
180 e_start (ev); 316 {
317 PUSHMARK (SP);
318 PUTBACK;
319 call_sv (get_sv ("EV::DIED", 1), G_DISCARD | G_VOID | G_EVAL | G_KEEPERR);
320 SPAGAIN;
321 }
322
323 if (count > 0)
324 {
325 retval = SvNV (TOPs);
326
327 if (retval < now)
328 retval = now;
329 }
330 else
331 retval = now;
181 332
182 FREETMPS; 333 FREETMPS;
183 LEAVE; 334 LEAVE;
184}
185 335
186///////////////////////////////////////////////////////////////////////////// 336 return retval;
187// DNS 337}
338
339#define CHECK_REPEAT(repeat) if (repeat < 0.) \
340 croak (# repeat " value must be >= 0");
341
342#define CHECK_FD(fh,fd) if ((fd) < 0) \
343 croak ("illegal file descriptor or filehandle (either no attached file descriptor or illegal value): %s", SvPV_nolen (fh));
344
345#define CHECK_SIG(sv,num) if ((num) < 0) \
346 croak ("illegal signal number or name: %s", SvPV_nolen (sv));
188 347
189static void 348static void
190dns_cb (int result, char type, int count, int ttl, void *addresses, void *arg) 349default_fork (void)
191{ 350{
192 dSP; 351 ev_loop_fork (EV_DEFAULT_UC);
193 SV *cb = (SV *)arg;
194
195 ENTER;
196 SAVETMPS;
197 PUSHMARK (SP);
198 EXTEND (SP, count + 3);
199 PUSHs (sv_2mortal (newSViv (result)));
200
201 if (result == DNS_ERR_NONE && ttl >= 0)
202 {
203 int i;
204
205 PUSHs (sv_2mortal (newSViv (type)));
206 PUSHs (sv_2mortal (newSViv (ttl)));
207
208 for (i = 0; i < count; ++i)
209 switch (type)
210 {
211 case DNS_IPv6_AAAA:
212 PUSHs (sv_2mortal (newSVpvn (i * 16 + (char *)addresses, 16)));
213 break;
214 case DNS_IPv4_A:
215 PUSHs (sv_2mortal (newSVpvn (i * 4 + (char *)addresses, 4)));
216 break;
217 case DNS_PTR:
218 PUSHs (sv_2mortal (newSVpv (*(char **)addresses, 0)));
219 break;
220 }
221 }
222
223 PUTBACK;
224 call_sv (sv_2mortal (cb), G_DISCARD | G_VOID | G_EVAL);
225
226 FREETMPS;
227 LEAVE;
228} 352}
229 353
230///////////////////////////////////////////////////////////////////////////// 354/////////////////////////////////////////////////////////////////////////////
231// XS interface functions 355// XS interface functions
232 356
233MODULE = EV PACKAGE = EV PREFIX = event_ 357MODULE = EV PACKAGE = EV PREFIX = ev_
358
359PROTOTYPES: ENABLE
234 360
235BOOT: 361BOOT:
236{ 362{
237 HV *stash = gv_stashpv ("EV", 1); 363 HV *stash = gv_stashpv ("EV", 1);
238 364
239 static const struct { 365 static const struct {
240 const char *name; 366 const char *name;
241 IV iv; 367 IV iv;
242 } *civ, const_iv[] = { 368 } *civ, const_iv[] = {
243# define const_iv(pfx, name) { # name, (IV) pfx ## name }, 369# define const_iv(pfx, name) { # name, (IV) pfx ## name },
370 const_iv (EV_, MINPRI)
371 const_iv (EV_, MAXPRI)
372
373 const_iv (EV_, UNDEF)
244 const_iv (EV_, NONE) 374 const_iv (EV_, NONE)
245 const_iv (EV_, TIMEOUT)
246 const_iv (EV_, READ) 375 const_iv (EV_, READ)
247 const_iv (EV_, WRITE) 376 const_iv (EV_, WRITE)
377 const_iv (EV_, IO)
378 const_iv (EV_, TIMER)
379 const_iv (EV_, PERIODIC)
248 const_iv (EV_, SIGNAL) 380 const_iv (EV_, SIGNAL)
381 const_iv (EV_, CHILD)
249 const_iv (EV_, PERSIST) 382 const_iv (EV_, STAT)
383 const_iv (EV_, IDLE)
384 const_iv (EV_, PREPARE)
385 const_iv (EV_, CHECK)
386 const_iv (EV_, EMBED)
387 const_iv (EV_, FORK)
388 const_iv (EV_, CLEANUP)
389 const_iv (EV_, ASYNC)
390 const_iv (EV_, CUSTOM)
391 const_iv (EV_, ERROR)
392
393 const_iv (EV, RUN_NOWAIT)
250 const_iv (EV, LOOP_ONCE) 394 const_iv (EV, RUN_ONCE)
395
396 const_iv (EV, BREAK_CANCEL)
397 const_iv (EV, BREAK_ONE)
398 const_iv (EV, BREAK_ALL)
399 const_iv (EV, BACKEND_SELECT)
400 const_iv (EV, BACKEND_POLL)
401 const_iv (EV, BACKEND_EPOLL)
402 const_iv (EV, BACKEND_KQUEUE)
403 const_iv (EV, BACKEND_DEVPOLL)
404 const_iv (EV, BACKEND_PORT)
405 const_iv (EV, BACKEND_ALL)
406 const_iv (EV, BACKEND_MASK)
407 const_iv (EV, FLAG_AUTO)
408 const_iv (EV, FLAG_FORKCHECK)
409 const_iv (EV, FLAG_SIGNALFD)
410 const_iv (EV, FLAG_NOSIGMASK)
411 const_iv (EV, FLAG_NOENV)
412 const_iv (EV, FLAG_NOINOTIFY)
413
414 const_iv (EV_, VERSION_MAJOR)
415 const_iv (EV_, VERSION_MINOR)
416#if EV_COMPAT3
417 const_iv (EV, FLAG_NOSIGFD) /* compatibility, always 0 */
418 const_iv (EV_, TIMEOUT)
251 const_iv (EV, LOOP_NONBLOCK) 419 const_iv (EV, LOOP_NONBLOCK)
252 const_iv (EV, BUFFER_READ) 420 const_iv (EV, LOOP_ONESHOT)
253 const_iv (EV, BUFFER_WRITE) 421 const_iv (EV, UNLOOP_CANCEL)
254 const_iv (EV, BUFFER_EOF) 422 const_iv (EV, UNLOOP_ONE)
255 const_iv (EV, BUFFER_ERROR) 423 const_iv (EV, UNLOOP_ALL)
256 const_iv (EV, BUFFER_TIMEOUT) 424#endif
257 }; 425 };
258 426
259 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 427 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
260 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 428 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
261 429
430 stash_loop = gv_stashpv ("EV::Loop" , 1);
262 stash_base = gv_stashpv ("EV::Base" , 1); 431 stash_watcher = gv_stashpv ("EV::Watcher" , 1);
432 stash_io = gv_stashpv ("EV::IO" , 1);
433 stash_timer = gv_stashpv ("EV::Timer" , 1);
434 stash_periodic = gv_stashpv ("EV::Periodic", 1);
435 stash_signal = gv_stashpv ("EV::Signal" , 1);
436 stash_idle = gv_stashpv ("EV::Idle" , 1);
437 stash_prepare = gv_stashpv ("EV::Prepare" , 1);
438 stash_check = gv_stashpv ("EV::Check" , 1);
439 stash_child = gv_stashpv ("EV::Child" , 1);
263 stash_event = gv_stashpv ("EV::Event", 1); 440 stash_embed = gv_stashpv ("EV::Embed" , 1);
264} 441 stash_stat = gv_stashpv ("EV::Stat" , 1);
442 stash_fork = gv_stashpv ("EV::Fork" , 1);
443 stash_cleanup = gv_stashpv ("EV::Cleanup" , 1);
444 stash_async = gv_stashpv ("EV::Async" , 1);
265 445
266double now () 446 {
267 CODE: 447 SV *sv = perl_get_sv ("EV::API", TRUE);
268 RETVAL = e_now (); 448 perl_get_sv ("EV::API", TRUE); /* silence 5.10 warning */
269 OUTPUT:
270 RETVAL
271 449
272const char *version () 450 /* the poor man's shared library emulator */
451 evapi.ver = EV_API_VERSION;
452 evapi.rev = EV_API_REVISION;
453 evapi.sv_fileno = sv_fileno;
454 evapi.sv_signum = s_signum;
455 evapi.supported_backends = ev_supported_backends ();
456 evapi.recommended_backends = ev_recommended_backends ();
457 evapi.embeddable_backends = ev_embeddable_backends ();
458 evapi.time_ = ev_time;
459 evapi.sleep_ = ev_sleep;
460 evapi.loop_new = ev_loop_new;
461 evapi.loop_destroy = ev_loop_destroy;
462 evapi.loop_fork = ev_loop_fork;
463 evapi.iteration = ev_iteration;
464 evapi.depth = ev_depth;
465 evapi.set_userdata = ev_set_userdata;
466 evapi.userdata = ev_userdata;
467 evapi.now = ev_now;
468 evapi.now_update = ev_now_update;
469 evapi.suspend = ev_suspend;
470 evapi.resume = ev_resume;
471 evapi.backend = ev_backend;
472 evapi.break_ = ev_break;
473 evapi.invoke_pending = ev_invoke_pending;
474 evapi.pending_count = ev_pending_count;
475 evapi.verify = ev_verify;
476 evapi.set_loop_release_cb = ev_set_loop_release_cb;
477 evapi.set_invoke_pending_cb= ev_set_invoke_pending_cb;
478 evapi.ref = ev_ref;
479 evapi.unref = ev_unref;
480 evapi.run = ev_run;
481 evapi.once = ev_once;
482 evapi.io_start = ev_io_start;
483 evapi.io_stop = ev_io_stop;
484 evapi.timer_start = ev_timer_start;
485 evapi.timer_stop = ev_timer_stop;
486 evapi.timer_again = ev_timer_again;
487 evapi.timer_remaining = ev_timer_remaining;
488 evapi.periodic_start = ev_periodic_start;
489 evapi.periodic_stop = ev_periodic_stop;
490 evapi.signal_start = ev_signal_start;
491 evapi.signal_stop = ev_signal_stop;
492 evapi.idle_start = ev_idle_start;
493 evapi.idle_stop = ev_idle_stop;
494 evapi.prepare_start = ev_prepare_start;
495 evapi.prepare_stop = ev_prepare_stop;
496 evapi.check_start = ev_check_start;
497 evapi.check_stop = ev_check_stop;
498#if EV_CHILD_ENABLE
499 evapi.child_start = ev_child_start;
500 evapi.child_stop = ev_child_stop;
501#endif
502 evapi.stat_start = ev_stat_start;
503 evapi.stat_stop = ev_stat_stop;
504 evapi.stat_stat = ev_stat_stat;
505 evapi.embed_start = ev_embed_start;
506 evapi.embed_stop = ev_embed_stop;
507 evapi.embed_sweep = ev_embed_sweep;
508 evapi.fork_start = ev_fork_start;
509 evapi.fork_stop = ev_fork_stop;
510 evapi.cleanup_start = ev_cleanup_start;
511 evapi.cleanup_stop = ev_cleanup_stop;
512 evapi.async_start = ev_async_start;
513 evapi.async_stop = ev_async_stop;
514 evapi.async_send = ev_async_send;
515 evapi.clear_pending = ev_clear_pending;
516 evapi.invoke = ev_invoke;
517
518 sv_setiv (sv, (IV)&evapi);
519 SvREADONLY_on (sv);
520 }
521#if !defined(_WIN32) && !defined(_MINIX)
522 pthread_atfork (0, 0, default_fork);
523#endif
524}
525
526SV *ev_default_loop (unsigned int flags = 0)
527 CODE:
528{
529 if (!default_loop_sv)
530 {
531 evapi.default_loop = ev_default_loop (flags);
532
533 if (!evapi.default_loop)
534 XSRETURN_UNDEF;
535
536 default_loop_sv = sv_bless (newRV_noinc (newSViv (PTR2IV (evapi.default_loop))), stash_loop);
537 }
538
539 RETVAL = newSVsv (default_loop_sv);
540}
541 OUTPUT:
542 RETVAL
543
544void ev_default_destroy ()
545 CODE:
546 ev_loop_destroy (EV_DEFAULT_UC);
547 SvREFCNT_dec (default_loop_sv);
548 default_loop_sv = 0;
549
550unsigned int ev_supported_backends ()
551
552unsigned int ev_recommended_backends ()
553
554unsigned int ev_embeddable_backends ()
555
556void ev_sleep (NV interval)
557
558NV ev_time ()
559
560NV ev_now ()
561 C_ARGS: evapi.default_loop
562
563void ev_now_update ()
564 C_ARGS: evapi.default_loop
565
566void ev_suspend ()
567 C_ARGS: evapi.default_loop
568
569void ev_resume ()
570 C_ARGS: evapi.default_loop
571
572unsigned int ev_backend ()
573 C_ARGS: evapi.default_loop
574
575void ev_verify ()
273 ALIAS: 576 ALIAS:
577 loop_verify = 1
578 C_ARGS: evapi.default_loop
579
580unsigned int ev_iteration ()
581 ALIAS:
582 loop_count = 1
583 C_ARGS: evapi.default_loop
584
585unsigned int ev_depth ()
586 ALIAS:
587 loop_depth = 1
588 C_ARGS: evapi.default_loop
589
590void ev_set_io_collect_interval (NV interval)
591 C_ARGS: evapi.default_loop, interval
592
593void ev_set_timeout_collect_interval (NV interval)
594 C_ARGS: evapi.default_loop, interval
595
596void ev_run (int flags = 0)
597 ALIAS:
274 method = 1 598 loop = 1
275 CODE: 599 C_ARGS: evapi.default_loop, flags
276 RETVAL = ix ? event_get_method () : event_get_version ();
277 OUTPUT:
278 RETVAL
279 600
280Base event_init () 601void ev_break (int how = EVBREAK_ONE)
602 ALIAS:
603 unloop = 1
604 C_ARGS: evapi.default_loop, how
281 605
282int event_priority_init (int npri) 606void ev_feed_fd_event (int fd, int revents = EV_NONE)
607 C_ARGS: evapi.default_loop, fd, revents
283 608
284int event_dispatch () 609void ev_feed_signal_event (SV *signal)
285
286int event_loop (int flags = 0)
287
288int event_loopexit (double after)
289 CODE: 610 CODE:
290{ 611{
291 struct timeval tv; 612 Signal signum = s_signum (signal);
292 tv_set (&tv, after); 613 CHECK_SIG (signal, signum);
293 event_loopexit (&tv);
294}
295 614
296Event event (SV *cb) 615 ev_feed_signal_event (evapi.default_loop, signum);
297 CODE: 616}
298 RETVAL = e_new (0, 0, cb);
299 OUTPUT:
300 RETVAL
301 617
618unsigned int ev_pending_count ()
619 C_ARGS: evapi.default_loop
620
621void ev_invoke_pending ()
622 C_ARGS: evapi.default_loop
623
302Event io (SV *fh, short events, SV *cb) 624ev_io *io (SV *fh, int events, SV *cb)
303 ALIAS: 625 ALIAS:
304 io_ns = 1 626 io_ns = 1
627 _ae_io = 2
305 CODE: 628 CODE:
306 RETVAL = e_new (fh, events, cb); 629{
630 int fd = s_fileno (fh, events & EV_WRITE);
631 CHECK_FD (fh, fd);
632
633 if (ix == 2)
634 {
635 ix = 0;
636 events = events ? EV_WRITE : EV_READ;
637 }
638
639 RETVAL = e_new (sizeof (ev_io), cb, default_loop_sv);
640 e_fh (RETVAL) = newSVsv (fh);
641 ev_io_set (RETVAL, fd, events);
307 if (!ix) e_start (RETVAL); 642 if (!ix) START (io, RETVAL);
643}
308 OUTPUT: 644 OUTPUT:
309 RETVAL 645 RETVAL
310 646
311Event timer (double after, int repeat, SV *cb) 647ev_timer *timer (NV after, NV repeat, SV *cb)
312 ALIAS: 648 ALIAS:
313 timer_ns = 1 649 timer_ns = 1
650 INIT:
651 CHECK_REPEAT (repeat);
314 CODE: 652 CODE:
315 RETVAL = e_new (0, 0, cb); 653 RETVAL = e_new (sizeof (ev_timer), cb, default_loop_sv);
316 RETVAL->timeout = after; 654 ev_timer_set (RETVAL, after, repeat);
317 RETVAL->interval = repeat; 655 if (!ix) START (timer, RETVAL);
318 if (!ix) e_start (RETVAL);
319 OUTPUT: 656 OUTPUT:
320 RETVAL 657 RETVAL
321 658
322Event timer_abs (double at, double interval, SV *cb) 659SV *periodic (NV at, NV interval, SV *reschedule_cb, SV *cb)
323 ALIAS: 660 ALIAS:
324 timer_abs_ns = 1 661 periodic_ns = 1
662 INIT:
663 CHECK_REPEAT (interval);
325 CODE: 664 CODE:
326 RETVAL = e_new (0, 0, cb); 665{
327 RETVAL->timeout = at; 666 ev_periodic *w;
328 RETVAL->interval = interval; 667 w = e_new (sizeof (ev_periodic), cb, default_loop_sv);
329 RETVAL->abstime = 1; 668 e_fh (w) = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0;
330 if (!ix) e_start (RETVAL); 669 ev_periodic_set (w, at, interval, e_fh (w) ? e_periodic_cb : 0);
670 RETVAL = e_bless ((ev_watcher *)w, stash_periodic);
671 if (!ix) START (periodic, w);
672}
331 OUTPUT: 673 OUTPUT:
332 RETVAL 674 RETVAL
333 675
334Event signal (SV *signal, SV *cb) 676ev_signal *signal (SV *signal, SV *cb)
335 ALIAS: 677 ALIAS:
336 signal_ns = 1 678 signal_ns = 1
337 CODE: 679 CODE:
338 RETVAL = e_new (signal, EV_SIGNAL | EV_PERSIST, cb); 680{
681 Signal signum = s_signum (signal);
682 CHECK_SIG (signal, signum);
683
684 RETVAL = e_new (sizeof (ev_signal), cb, default_loop_sv);
685 ev_signal_set (RETVAL, signum);
686 if (!ix) START_SIGNAL (RETVAL);
687}
688 OUTPUT:
689 RETVAL
690
691ev_idle *idle (SV *cb)
692 ALIAS:
693 idle_ns = 1
694 CODE:
695 RETVAL = e_new (sizeof (ev_idle), cb, default_loop_sv);
696 ev_idle_set (RETVAL);
697 if (!ix) START (idle, RETVAL);
698 OUTPUT:
699 RETVAL
700
701ev_prepare *prepare (SV *cb)
702 ALIAS:
703 prepare_ns = 1
704 CODE:
705 RETVAL = e_new (sizeof (ev_prepare), cb, default_loop_sv);
706 ev_prepare_set (RETVAL);
707 if (!ix) START (prepare, RETVAL);
708 OUTPUT:
709 RETVAL
710
711ev_check *check (SV *cb)
712 ALIAS:
713 check_ns = 1
714 CODE:
715 RETVAL = e_new (sizeof (ev_check), cb, default_loop_sv);
716 ev_check_set (RETVAL);
717 if (!ix) START (check, RETVAL);
718 OUTPUT:
719 RETVAL
720
721ev_fork *fork (SV *cb)
722 ALIAS:
723 fork_ns = 1
724 CODE:
725 RETVAL = e_new (sizeof (ev_fork), cb, default_loop_sv);
726 ev_fork_set (RETVAL);
727 if (!ix) START (fork, RETVAL);
728 OUTPUT:
729 RETVAL
730
731ev_cleanup *cleanup (SV *cb)
732 ALIAS:
733 cleanup_ns = 1
734 CODE:
735 RETVAL = e_new (sizeof (ev_cleanup), cb, default_loop_sv);
736 ev_cleanup_set (RETVAL);
737 if (!ix) START (cleanup, RETVAL);
738 OUTPUT:
739 RETVAL
740
741ev_child *child (int pid, int trace, SV *cb)
742 ALIAS:
743 child_ns = 1
744 CODE:
745#if EV_CHILD_ENABLE
746 RETVAL = e_new (sizeof (ev_child), cb, default_loop_sv);
747 ev_child_set (RETVAL, pid, trace);
748 if (!ix) START (child, RETVAL);
749#else
750 croak ("EV::child watchers not supported on this platform");
751#endif
752 OUTPUT:
753 RETVAL
754
755
756ev_stat *stat (SV *path, NV interval, SV *cb)
757 ALIAS:
758 stat_ns = 1
759 CODE:
760 RETVAL = e_new (sizeof (ev_stat), cb, default_loop_sv);
761 e_fh (RETVAL) = newSVsv (path);
762 ev_stat_set (RETVAL, SvPVbyte_nolen (e_fh (RETVAL)), interval);
339 if (!ix) e_start (RETVAL); 763 if (!ix) START (stat, RETVAL);
340 OUTPUT: 764 OUTPUT:
341 RETVAL 765 RETVAL
766
767#ifndef EV_NO_LOOPS
768
769ev_embed *embed (struct ev_loop *loop, SV *cb = 0)
770 ALIAS:
771 embed_ns = 1
772 CODE:
773{
774 if (!(ev_backend (loop) & ev_embeddable_backends ()))
775 croak ("passed loop is not embeddable via EV::embed,");
776
777 RETVAL = e_new (sizeof (ev_embed), cb, default_loop_sv);
778 e_fh (RETVAL) = newSVsv (ST (0));
779 ev_embed_set (RETVAL, loop);
780 if (!ix) START (embed, RETVAL);
781}
782 OUTPUT:
783 RETVAL
784
785#endif
786
787ev_async *async (SV *cb)
788 ALIAS:
789 async_ns = 1
790 CODE:
791 RETVAL = e_new (sizeof (ev_async), cb, default_loop_sv);
792 ev_async_set (RETVAL);
793 if (!ix) START (async, RETVAL);
794 OUTPUT:
795 RETVAL
796
797void once (SV *fh, int events, SV *timeout, SV *cb)
798 CODE:
799 ev_once (
800 evapi.default_loop,
801 s_fileno (fh, events & EV_WRITE), events,
802 SvOK (timeout) ? SvNV (timeout) : -1.,
803 e_once_cb,
804 newSVsv (cb)
805 );
342 806
343PROTOTYPES: DISABLE 807PROTOTYPES: DISABLE
344 808
345
346MODULE = EV PACKAGE = EV::Base PREFIX = event_base_
347
348Base new ()
349 CODE:
350 RETVAL = event_init ();
351 OUTPUT:
352 RETVAL
353
354int event_base_dispatch (Base base)
355
356int event_base_loop (Base base, int flags = 0)
357
358int event_base_loopexit (Base base, double after)
359 CODE:
360{
361 struct timeval tv;
362 tv.tv_sec = (long)after;
363 tv.tv_usec = (long)(after - tv.tv_sec) * 1e6;
364 event_base_loopexit (base, &tv);
365}
366
367int event_base_priority_init (Base base, int npri)
368
369void event_base_set (Base base, Event ev)
370 C_ARGS: base, &ev->ev
371
372void DESTROY (Base base)
373 CODE:
374 /*event_base_free (base);*/ /* causes too many problems */
375
376
377MODULE = EV PACKAGE = EV::Event PREFIX = event_ 809MODULE = EV PACKAGE = EV::Watcher PREFIX = ev_
378 810
379int event_priority_set (Event ev, int pri) 811int ev_is_active (ev_watcher *w)
380 C_ARGS: &ev->ev, pri
381 812
382int event_add (Event ev, double timeout = TIMEOUT_NONE) 813int ev_is_pending (ev_watcher *w)
383 CODE:
384 ev->timeout = timeout;
385 ev->abstime = 0;
386 RETVAL = e_start (ev);
387 OUTPUT:
388 RETVAL
389 814
390int event_start (Event ev) 815void ev_invoke (ev_watcher *w, int revents = EV_NONE)
391 CODE: 816 C_ARGS: e_loop (w), w, revents
392 RETVAL = e_start (ev);
393 OUTPUT:
394 RETVAL
395 817
396int event_del (Event ev) 818int ev_clear_pending (ev_watcher *w)
397 ALIAS: 819 C_ARGS: e_loop (w), w
398 stop = 0
399 CODE:
400 RETVAL = e_stop (ev);
401 OUTPUT:
402 RETVAL
403 820
404void DESTROY (Event ev) 821void ev_feed_event (ev_watcher *w, int revents = EV_NONE)
405 CODE: 822 C_ARGS: e_loop (w), w, revents
406 e_stop (ev);
407 SvREFCNT_dec (ev->cb);
408 SvREFCNT_dec (ev->fh);
409 823
410void cb (Event ev, SV *new_cb) 824int keepalive (ev_watcher *w, int new_value = 0)
411 CODE: 825 CODE:
412 sv_setsv (ev->cb, new_cb); 826{
827 RETVAL = w->e_flags & WFLAG_KEEPALIVE;
828 new_value = new_value ? WFLAG_KEEPALIVE : 0;
413 829
414SV *fh (Event ev, SV *new_fh = 0) 830 if (items > 1 && ((new_value ^ w->e_flags) & WFLAG_KEEPALIVE))
415 ALIAS: 831 {
416 signal = 0 832 w->e_flags = (w->e_flags & ~WFLAG_KEEPALIVE) | new_value;
833 REF (w);
834 UNREF (w);
835 }
836}
837 OUTPUT:
838 RETVAL
839
840SV *cb (ev_watcher *w, SV *new_cb = 0)
417 CODE: 841 CODE:
418 RETVAL = newSVsv (ev->fh); 842{
419 if (items > 1) 843 if (items > 1)
420 { 844 {
421 if (ev->active) event_del (&ev->ev); 845 new_cb = s_get_cv_croak (new_cb);
422 sv_setsv (ev->fh, new_fh); 846 RETVAL = newRV_noinc (w->cb_sv);
423 ev->ev.ev_fd = e_fd (ev); 847 w->cb_sv = SvREFCNT_inc (new_cb);
424 if (ev->active) event_add (&ev->ev, e_tv (ev));
425 } 848 }
849 else
850 RETVAL = newRV_inc (w->cb_sv);
851}
426 OUTPUT: 852 OUTPUT:
427 RETVAL 853 RETVAL
428 854
429short events (Event ev, short new_events = EV_UNDEF) 855SV *data (ev_watcher *w, SV *new_data = 0)
430 CODE: 856 CODE:
431 RETVAL = ev->ev.ev_events; 857{
858 RETVAL = w->data ? newSVsv (w->data) : &PL_sv_undef;
859
432 if (items > 1) 860 if (items > 1)
433 { 861 {
434 if (ev->active) event_del (&ev->ev); 862 SvREFCNT_dec (w->data);
435 ev->ev.ev_events = new_events; 863 w->data = newSVsv (new_data);
436 if (ev->active) event_add (&ev->ev, e_tv (ev));
437 } 864 }
865}
438 OUTPUT: 866 OUTPUT:
439 RETVAL 867 RETVAL
440 868
441double timeout (Event ev, double new_timeout = 0., int repeat = 0) 869SV *loop (ev_watcher *w)
442 CODE: 870 CODE:
443 RETVAL = ev->timeout; 871 RETVAL = newRV_inc (w->loop);
872 OUTPUT:
873 RETVAL
874
875int priority (ev_watcher *w, int new_priority = 0)
876 CODE:
877{
878 RETVAL = w->priority;
879
444 if (items > 1) 880 if (items > 1)
445 { 881 {
446 if (ev->active) event_del (&ev->ev); 882 int active = ev_is_active (w);
447 ev->timeout = new_timeout; 883
448 ev->interval = repeat; 884 if (active)
449 ev->abstime = 0; 885 {
450 if (ev->active) event_add (&ev->ev, e_tv (ev)); 886 /* grrr. */
887 PUSHMARK (SP);
888 XPUSHs (ST (0));
889 PUTBACK;
890 call_method ("stop", G_DISCARD | G_VOID);
891 }
892
893 ev_set_priority (w, new_priority);
894
895 if (active)
896 {
897 PUSHMARK (SP);
898 XPUSHs (ST (0));
899 PUTBACK;
900 call_method ("start", G_DISCARD | G_VOID);
901 }
451 } 902 }
903}
452 OUTPUT: 904 OUTPUT:
453 RETVAL 905 RETVAL
454 906
455void timeout_abs (Event ev, double at, double interval = 0.)
456 CODE:
457 if (ev->active) event_del (&ev->ev);
458 ev->timeout = at;
459 ev->interval = interval;
460 ev->abstime = 1;
461 if (ev->active) event_add (&ev->ev, e_tv (ev));
462
463
464MODULE = EV PACKAGE = EV::DNS PREFIX = evdns_ 907MODULE = EV PACKAGE = EV::IO PREFIX = ev_io_
465 908
466BOOT: 909void ev_io_start (ev_io *w)
467{ 910 CODE:
468 HV *stash = gv_stashpv ("EV::DNS", 1); 911 START (io, w);
469 912
470 static const struct { 913void ev_io_stop (ev_io *w)
471 const char *name; 914 CODE:
472 IV iv; 915 STOP (io, w);
473 } *civ, const_iv[] = {
474# define const_iv(pfx, name) { # name, (IV) pfx ## name },
475 916
476 const_iv (DNS_, ERR_NONE) 917void DESTROY (ev_io *w)
477 const_iv (DNS_, ERR_FORMAT) 918 CODE:
478 const_iv (DNS_, ERR_SERVERFAILED) 919 STOP (io, w);
479 const_iv (DNS_, ERR_NOTEXIST) 920 e_destroy (w);
480 const_iv (DNS_, ERR_NOTIMPL)
481 const_iv (DNS_, ERR_REFUSED)
482 const_iv (DNS_, ERR_TRUNCATED)
483 const_iv (DNS_, ERR_UNKNOWN)
484 const_iv (DNS_, ERR_TIMEOUT)
485 const_iv (DNS_, ERR_SHUTDOWN)
486 const_iv (DNS_, IPv4_A)
487 const_iv (DNS_, PTR)
488 const_iv (DNS_, IPv6_AAAA)
489 const_iv (DNS_, QUERY_NO_SEARCH)
490 const_iv (DNS_, OPTION_SEARCH)
491 const_iv (DNS_, OPTION_NAMESERVERS)
492 const_iv (DNS_, OPTION_MISC)
493 const_iv (DNS_, OPTIONS_ALL)
494 const_iv (DNS_, NO_SEARCH)
495 };
496 921
497 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 922void set (ev_io *w, SV *fh, int events)
498 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 923 CODE:
499} 924{
925 int fd = s_fileno (fh, events & EV_WRITE);
926 CHECK_FD (fh, fd);
500 927
501int evdns_init () 928 sv_setsv (e_fh (w), fh);
929 RESET (io, w, (w, fd, events));
930}
502 931
503void evdns_shutdown (int fail_requests = 1) 932SV *fh (ev_io *w, SV *new_fh = 0)
933 CODE:
934{
935 if (items > 1)
936 {
937 int fd = s_fileno (new_fh, w->events & EV_WRITE);
938 CHECK_FD (new_fh, fd);
504 939
505const char *evdns_err_to_string (int err) 940 RETVAL = e_fh (w);
941 e_fh (w) = newSVsv (new_fh);
506 942
507int evdns_nameserver_add (U32 address) 943 RESET (io, w, (w, fd, w->events));
944 }
945 else
946 RETVAL = newSVsv (e_fh (w));
947}
948 OUTPUT:
949 RETVAL
508 950
509int evdns_count_nameservers () 951int events (ev_io *w, int new_events = EV_UNDEF)
952 CODE:
953{
954 RETVAL = w->events;
510 955
511int evdns_clear_nameservers_and_suspend () 956 if (items > 1)
957 RESET (io, w, (w, w->fd, new_events));
958}
959 OUTPUT:
960 RETVAL
512 961
513int evdns_resume () 962MODULE = EV PACKAGE = EV::Signal PREFIX = ev_signal_
514 963
515int evdns_nameserver_ip_add (char *ip_as_string) 964void ev_signal_start (ev_signal *w)
965 CODE:
966 START_SIGNAL (w);
516 967
517int evdns_resolve_ipv4 (const char *name, int flags, SV *cb) 968void ev_signal_stop (ev_signal *w)
518 C_ARGS: name, flags, dns_cb, (void *)SvREFCNT_inc (cb) 969 CODE:
970 STOP (signal, w);
519 971
520int evdns_resolve_ipv6 (const char *name, int flags, SV *cb) 972void DESTROY (ev_signal *w)
521 C_ARGS: name, flags, dns_cb, (void *)SvREFCNT_inc (cb) 973 CODE:
974 STOP (signal, w);
975 e_destroy (w);
522 976
523int evdns_resolve_reverse (SV *addr, int flags, SV *cb) 977void set (ev_signal *w, SV *signal)
524 ALIAS: 978 CODE:
525 evdns_resolve_reverse_ipv6 = 1 979{
980 Signal signum = s_signum (signal);
981 CHECK_SIG (signal, signum);
982
983 RESET_SIGNAL (w, (w, signum));
984}
985
986int signal (ev_signal *w, SV *new_signal = 0)
987 CODE:
988{
989 RETVAL = w->signum;
990
991 if (items > 1)
992 {
993 Signal signum = s_signum (new_signal);
994 CHECK_SIG (new_signal, signum);
995
996 RESET_SIGNAL (w, (w, signum));
997 }
998}
999 OUTPUT:
1000 RETVAL
1001
1002MODULE = EV PACKAGE = EV::Timer PREFIX = ev_timer_
1003
1004void ev_timer_start (ev_timer *w)
1005 INIT:
1006 CHECK_REPEAT (w->repeat);
1007 CODE:
1008 START (timer, w);
1009
1010void ev_timer_stop (ev_timer *w)
1011 CODE:
1012 STOP (timer, w);
1013
1014void ev_timer_again (ev_timer *w)
1015 INIT:
1016 CHECK_REPEAT (w->repeat);
526 CODE: 1017 CODE:
527{ 1018 ev_timer_again (e_loop (w), w);
528 STRLEN len; 1019 UNREF (w);
529 char *data = SvPVbyte (addr, len);
530 if (len != (ix ? 16 : 4))
531 croak ("ipv4/ipv6 address to resolve must be given as 4/16 byte octet string");
532 1020
1021NV ev_timer_remaining (ev_timer *w)
1022 C_ARGS: e_loop (w), w
1023
1024void DESTROY (ev_timer *w)
1025 CODE:
1026 STOP (timer, w);
1027 e_destroy (w);
1028
1029void set (ev_timer *w, NV after, NV repeat = 0.)
1030 INIT:
1031 CHECK_REPEAT (repeat);
1032 CODE:
1033 RESET (timer, w, (w, after, repeat));
1034
1035MODULE = EV PACKAGE = EV::Periodic PREFIX = ev_periodic_
1036
1037void ev_periodic_start (ev_periodic *w)
1038 INIT:
1039 CHECK_REPEAT (w->interval);
1040 CODE:
1041 START (periodic, w);
1042
1043void ev_periodic_stop (ev_periodic *w)
1044 CODE:
1045 STOP (periodic, w);
1046
1047void ev_periodic_again (ev_periodic *w)
1048 CODE:
1049 ev_periodic_again (e_loop (w), w);
1050 UNREF (w);
1051
1052void DESTROY (ev_periodic *w)
1053 CODE:
1054 STOP (periodic, w);
1055 e_destroy (w);
1056
1057void set (ev_periodic *w, NV at, NV interval = 0., SV *reschedule_cb = &PL_sv_undef)
1058 INIT:
1059 CHECK_REPEAT (interval);
1060 CODE:
1061{
1062 SvREFCNT_dec (e_fh (w));
1063 e_fh (w) = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0;
1064
1065 RESET (periodic, w, (w, at, interval, e_fh (w) ? e_periodic_cb : 0));
1066}
1067
1068NV at (ev_periodic *w)
1069 CODE:
1070 RETVAL = ev_periodic_at (w);
1071 OUTPUT:
1072 RETVAL
1073
1074MODULE = EV PACKAGE = EV::Idle PREFIX = ev_idle_
1075
1076void ev_idle_start (ev_idle *w)
1077 CODE:
1078 START (idle, w);
1079
1080void ev_idle_stop (ev_idle *w)
1081 CODE:
1082 STOP (idle, w);
1083
1084void DESTROY (ev_idle *w)
1085 CODE:
1086 STOP (idle, w);
1087 e_destroy (w);
1088
1089MODULE = EV PACKAGE = EV::Prepare PREFIX = ev_prepare_
1090
1091void ev_prepare_start (ev_prepare *w)
1092 CODE:
1093 START (prepare, w);
1094
1095void ev_prepare_stop (ev_prepare *w)
1096 CODE:
1097 STOP (prepare, w);
1098
1099void DESTROY (ev_prepare *w)
1100 CODE:
1101 STOP (prepare, w);
1102 e_destroy (w);
1103
1104MODULE = EV PACKAGE = EV::Check PREFIX = ev_check_
1105
1106void ev_check_start (ev_check *w)
1107 CODE:
1108 START (check, w);
1109
1110void ev_check_stop (ev_check *w)
1111 CODE:
1112 STOP (check, w);
1113
1114void DESTROY (ev_check *w)
1115 CODE:
1116 STOP (check, w);
1117 e_destroy (w);
1118
1119MODULE = EV PACKAGE = EV::Fork PREFIX = ev_fork_
1120
1121void ev_fork_start (ev_fork *w)
1122 CODE:
1123 START (fork, w);
1124
1125void ev_fork_stop (ev_fork *w)
1126 CODE:
1127 STOP (fork, w);
1128
1129void DESTROY (ev_fork *w)
1130 CODE:
1131 STOP (fork, w);
1132 e_destroy (w);
1133
1134MODULE = EV PACKAGE = EV::Cleanup PREFIX = ev_cleanup_
1135
1136void ev_cleanup_start (ev_cleanup *w)
1137 CODE:
1138 START (cleanup, w);
1139
1140void ev_cleanup_stop (ev_cleanup *w)
1141 CODE:
1142 STOP (cleanup, w);
1143
1144void DESTROY (ev_cleanup *w)
1145 CODE:
1146 STOP (cleanup, w);
1147 e_destroy (w);
1148
1149int keepalive (ev_watcher *w, int new_value = 0)
1150 CODE:
533 RETVAL = ix 1151 RETVAL = 0;
534 ? evdns_resolve_reverse_ipv6 ((struct in6_addr *)data, flags, dns_cb, (void *)SvREFCNT_inc (cb))
535 : evdns_resolve_reverse ((struct in_addr *)data, flags, dns_cb, (void *)SvREFCNT_inc (cb));
536}
537 OUTPUT: 1152 OUTPUT:
538 RETVAL 1153 RETVAL
539 1154
540int evdns_set_option (char *option, char *val, int flags) 1155MODULE = EV PACKAGE = EV::Child PREFIX = ev_child_
541 1156
542int evdns_resolv_conf_parse (int flags, const char *filename) 1157#if EV_CHILD_ENABLE
543 1158
544#ifdef MS_WINDOWS 1159void ev_child_start (ev_child *w)
1160 CODE:
1161 START (child, w);
545 1162
546int evdns_config_windows_nameservers () 1163void ev_child_stop (ev_child *w)
1164 CODE:
1165 STOP (child, w);
1166
1167void DESTROY (ev_child *w)
1168 CODE:
1169 STOP (child, w);
1170 e_destroy (w);
1171
1172void set (ev_child *w, int pid, int trace)
1173 CODE:
1174 RESET (child, w, (w, pid, trace));
1175
1176int pid (ev_child *w)
1177 ALIAS:
1178 rpid = 1
1179 rstatus = 2
1180 CODE:
1181 RETVAL = ix == 0 ? w->pid
1182 : ix == 1 ? w->rpid
1183 : w->rstatus;
1184 OUTPUT:
1185 RETVAL
547 1186
548#endif 1187#endif
549 1188
550void evdns_search_clear () 1189MODULE = EV PACKAGE = EV::Stat PREFIX = ev_stat_
551 1190
552void evdns_search_add (char *domain) 1191void ev_stat_start (ev_stat *w)
1192 CODE:
1193 START (stat, w);
553 1194
554void evdns_search_ndots_set (int ndots) 1195void ev_stat_stop (ev_stat *w)
1196 CODE:
1197 STOP (stat, w);
555 1198
1199void DESTROY (ev_stat *w)
1200 CODE:
1201 STOP (stat, w);
1202 e_destroy (w);
1203
1204void set (ev_stat *w, SV *path, NV interval)
1205 CODE:
1206{
1207 sv_setsv (e_fh (w), path);
1208 RESET (stat, w, (w, SvPVbyte_nolen (e_fh (w)), interval));
1209}
1210
1211SV *path (ev_stat *w, SV *new_path = 0)
1212 CODE:
1213{
1214 RETVAL = SvREFCNT_inc (e_fh (w));
1215
1216 if (items > 1)
1217 {
1218 SvREFCNT_dec (e_fh (w));
1219 e_fh (w) = newSVsv (new_path);
1220 RESET (stat, w, (w, SvPVbyte_nolen (e_fh (w)), w->interval));
1221 }
1222}
1223 OUTPUT:
1224 RETVAL
1225
1226NV interval (ev_stat *w, NV new_interval = 0.)
1227 CODE:
1228{
1229 RETVAL = w->interval;
1230
1231 if (items > 1)
1232 RESET (stat, w, (w, SvPVbyte_nolen (e_fh (w)), new_interval));
1233}
1234 OUTPUT:
1235 RETVAL
1236
1237void prev (ev_stat *w)
1238 ALIAS:
1239 stat = 1
1240 attr = 2
1241 PPCODE:
1242{
1243 ev_statdata *s = ix ? &w->attr : &w->prev;
1244
1245 if (ix == 1)
1246 ev_stat_stat (e_loop (w), w);
1247 else if (!s->st_nlink)
1248 errno = ENOENT;
1249
1250 PL_statcache.st_dev = s->st_nlink;
1251 PL_statcache.st_ino = s->st_ino;
1252 PL_statcache.st_mode = s->st_mode;
1253 PL_statcache.st_nlink = s->st_nlink;
1254 PL_statcache.st_uid = s->st_uid;
1255 PL_statcache.st_gid = s->st_gid;
1256 PL_statcache.st_rdev = s->st_rdev;
1257 PL_statcache.st_size = s->st_size;
1258 PL_statcache.st_atime = s->st_atime;
1259 PL_statcache.st_mtime = s->st_mtime;
1260 PL_statcache.st_ctime = s->st_ctime;
1261
1262 if (GIMME_V == G_SCALAR)
1263 XPUSHs (boolSV (s->st_nlink));
1264 else if (GIMME_V == G_ARRAY && s->st_nlink)
1265 {
1266 EXTEND (SP, 13);
1267 PUSHs (sv_2mortal (newSViv (s->st_dev)));
1268 PUSHs (sv_2mortal (newSViv (s->st_ino)));
1269 PUSHs (sv_2mortal (newSVuv (s->st_mode)));
1270 PUSHs (sv_2mortal (newSVuv (s->st_nlink)));
1271 PUSHs (sv_2mortal (newSViv (s->st_uid)));
1272 PUSHs (sv_2mortal (newSViv (s->st_gid)));
1273 PUSHs (sv_2mortal (newSViv (s->st_rdev)));
1274 PUSHs (sv_2mortal (newSVnv ((NV)s->st_size)));
1275 PUSHs (sv_2mortal (newSVnv (s->st_atime)));
1276 PUSHs (sv_2mortal (newSVnv (s->st_mtime)));
1277 PUSHs (sv_2mortal (newSVnv (s->st_ctime)));
1278 PUSHs (sv_2mortal (newSVuv (4096)));
1279 PUSHs (sv_2mortal (newSVnv ((NV)((s->st_size + 4095) / 4096))));
1280 }
1281}
1282
1283MODULE = EV PACKAGE = EV::Embed PREFIX = ev_embed_
1284
1285void ev_embed_start (ev_embed *w)
1286 CODE:
1287 START (embed, w);
1288
1289void ev_embed_stop (ev_embed *w)
1290 CODE:
1291 STOP (embed, w);
1292
1293void DESTROY (ev_embed *w)
1294 CODE:
1295 STOP (embed, w);
1296 e_destroy (w);
1297
1298void set (ev_embed *w, struct ev_loop *loop)
1299 CODE:
1300{
1301 sv_setsv (e_fh (w), ST (1));
1302 RESET (embed, w, (w, loop));
1303}
1304
1305SV *other (ev_embed *w)
1306 CODE:
1307 RETVAL = newSVsv (e_fh (w));
1308 OUTPUT:
1309 RETVAL
1310
1311void ev_embed_sweep (ev_embed *w)
1312 C_ARGS: e_loop (w), w
1313
1314MODULE = EV PACKAGE = EV::Async PREFIX = ev_async_
1315
1316void ev_async_start (ev_async *w)
1317 CODE:
1318 START (async, w);
1319
1320void ev_async_stop (ev_async *w)
1321 CODE:
1322 STOP (async, w);
1323
1324void DESTROY (ev_async *w)
1325 CODE:
1326 STOP (async, w);
1327 e_destroy (w);
1328
1329void ev_async_send (ev_async *w)
1330 C_ARGS: e_loop (w), w
1331
1332SV *ev_async_async_pending (ev_async *w)
1333 CODE:
1334 RETVAL = boolSV (ev_async_pending (w));
1335 OUTPUT:
1336 RETVAL
1337
1338#ifndef EV_NO_LOOPS
1339
1340MODULE = EV PACKAGE = EV::Loop PREFIX = ev_
1341
1342SV *new (SV *klass, unsigned int flags = 0)
1343 CODE:
1344{
1345 struct ev_loop *loop = ev_loop_new (flags);
1346
1347 if (!loop)
1348 XSRETURN_UNDEF;
1349
1350 RETVAL = sv_bless (newRV_noinc (newSViv (PTR2IV (loop))), stash_loop);
1351}
1352 OUTPUT:
1353 RETVAL
1354
1355void DESTROY (struct ev_loop *loop)
1356 CODE:
1357 /* 1. the default loop shouldn't be freed by destroying it'S pelr loop object */
1358 /* 2. not doing so helps avoid many global destruction bugs in perl, too */
1359 if (loop != evapi.default_loop)
1360 ev_loop_destroy (loop);
1361
1362void ev_loop_fork (struct ev_loop *loop)
1363
1364NV ev_now (struct ev_loop *loop)
1365
1366void ev_now_update (struct ev_loop *loop)
1367
1368void ev_suspend (struct ev_loop *loop)
1369
1370void ev_resume (struct ev_loop *loop)
1371
1372void ev_set_io_collect_interval (struct ev_loop *loop, NV interval)
1373
1374void ev_set_timeout_collect_interval (struct ev_loop *loop, NV interval)
1375
1376unsigned int ev_backend (struct ev_loop *loop)
1377
1378void ev_verify (struct ev_loop *loop)
1379 ALIAS:
1380 loop_verify = 1
1381
1382unsigned int ev_iteration (struct ev_loop *loop)
1383 ALIAS:
1384 loop_count = 1
1385
1386unsigned int ev_depth (struct ev_loop *loop)
1387 ALIAS:
1388 loop_depth = 1
1389
1390void ev_run (struct ev_loop *loop, int flags = 0)
1391 ALIAS:
1392 loop = 1
1393
1394void ev_break (struct ev_loop *loop, int how = 1)
1395 ALIAS:
1396 unloop = 1
1397
1398void ev_feed_fd_event (struct ev_loop *loop, int fd, int revents = EV_NONE)
1399
1400unsigned int ev_pending_count (struct ev_loop *loop)
1401
1402void ev_invoke_pending (struct ev_loop *loop)
1403
1404#if 0
1405
1406void ev_feed_signal_event (struct ev_loop *loop, SV *signal)
1407 CODE:
1408{
1409 Signal signum = s_signum (signal);
1410 CHECK_SIG (signal, signum);
1411
1412 ev_feed_signal_event (loop, signum);
1413}
1414
1415#endif
1416
1417ev_io *io (struct ev_loop *loop, SV *fh, int events, SV *cb)
1418 ALIAS:
1419 io_ns = 1
1420 CODE:
1421{
1422 int fd = s_fileno (fh, events & EV_WRITE);
1423 CHECK_FD (fh, fd);
1424
1425 RETVAL = e_new (sizeof (ev_io), cb, ST (0));
1426 e_fh (RETVAL) = newSVsv (fh);
1427 ev_io_set (RETVAL, fd, events);
1428 if (!ix) START (io, RETVAL);
1429}
1430 OUTPUT:
1431 RETVAL
1432
1433ev_timer *timer (struct ev_loop *loop, NV after, NV repeat, SV *cb)
1434 ALIAS:
1435 timer_ns = 1
1436 INIT:
1437 CHECK_REPEAT (repeat);
1438 CODE:
1439 RETVAL = e_new (sizeof (ev_timer), cb, ST (0));
1440 ev_timer_set (RETVAL, after, repeat);
1441 if (!ix) START (timer, RETVAL);
1442 OUTPUT:
1443 RETVAL
1444
1445SV *periodic (struct ev_loop *loop, NV at, NV interval, SV *reschedule_cb, SV *cb)
1446 ALIAS:
1447 periodic_ns = 1
1448 INIT:
1449 CHECK_REPEAT (interval);
1450 CODE:
1451{
1452 ev_periodic *w;
1453 w = e_new (sizeof (ev_periodic), cb, ST (0));
1454 e_fh (w) = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0;
1455 ev_periodic_set (w, at, interval, e_fh (w) ? e_periodic_cb : 0);
1456 RETVAL = e_bless ((ev_watcher *)w, stash_periodic);
1457 if (!ix) START (periodic, w);
1458}
1459 OUTPUT:
1460 RETVAL
1461
1462ev_signal *signal (struct ev_loop *loop, SV *signal, SV *cb)
1463 ALIAS:
1464 signal_ns = 1
1465 CODE:
1466{
1467 Signal signum = s_signum (signal);
1468 CHECK_SIG (signal, signum);
1469
1470 RETVAL = e_new (sizeof (ev_signal), cb, ST (0));
1471 ev_signal_set (RETVAL, signum);
1472 if (!ix) START_SIGNAL (RETVAL);
1473}
1474 OUTPUT:
1475 RETVAL
1476
1477ev_idle *idle (struct ev_loop *loop, SV *cb)
1478 ALIAS:
1479 idle_ns = 1
1480 CODE:
1481 RETVAL = e_new (sizeof (ev_idle), cb, ST (0));
1482 ev_idle_set (RETVAL);
1483 if (!ix) START (idle, RETVAL);
1484 OUTPUT:
1485 RETVAL
1486
1487ev_prepare *prepare (struct ev_loop *loop, SV *cb)
1488 ALIAS:
1489 prepare_ns = 1
1490 CODE:
1491 RETVAL = e_new (sizeof (ev_prepare), cb, ST (0));
1492 ev_prepare_set (RETVAL);
1493 if (!ix) START (prepare, RETVAL);
1494 OUTPUT:
1495 RETVAL
1496
1497ev_check *check (struct ev_loop *loop, SV *cb)
1498 ALIAS:
1499 check_ns = 1
1500 CODE:
1501 RETVAL = e_new (sizeof (ev_check), cb, ST (0));
1502 ev_check_set (RETVAL);
1503 if (!ix) START (check, RETVAL);
1504 OUTPUT:
1505 RETVAL
1506
1507ev_fork *fork (struct ev_loop *loop, SV *cb)
1508 ALIAS:
1509 fork_ns = 1
1510 CODE:
1511 RETVAL = e_new (sizeof (ev_fork), cb, ST (0));
1512 ev_fork_set (RETVAL);
1513 if (!ix) START (fork, RETVAL);
1514 OUTPUT:
1515 RETVAL
1516
1517ev_cleanup *cleanup (struct ev_loop *loop, SV *cb)
1518 ALIAS:
1519 cleanup_ns = 1
1520 CODE:
1521 RETVAL = e_new (sizeof (ev_cleanup), cb, ST (0));
1522 ev_cleanup_set (RETVAL);
1523 if (!ix) START (cleanup, RETVAL);
1524 OUTPUT:
1525 RETVAL
1526
1527ev_child *child (struct ev_loop *loop, int pid, int trace, SV *cb)
1528 ALIAS:
1529 child_ns = 1
1530 CODE:
1531#if EV_CHILD_ENABLE
1532 RETVAL = e_new (sizeof (ev_child), cb, ST (0));
1533 ev_child_set (RETVAL, pid, trace);
1534 if (!ix) START (child, RETVAL);
1535#else
1536 croak ("EV::child watchers not supported on this platform");
1537#endif
1538 OUTPUT:
1539 RETVAL
1540
1541ev_stat *stat (struct ev_loop *loop, SV *path, NV interval, SV *cb)
1542 ALIAS:
1543 stat_ns = 1
1544 CODE:
1545 RETVAL = e_new (sizeof (ev_stat), cb, ST (0));
1546 e_fh (RETVAL) = newSVsv (path);
1547 ev_stat_set (RETVAL, SvPVbyte_nolen (e_fh (RETVAL)), interval);
1548 if (!ix) START (stat, RETVAL);
1549 OUTPUT:
1550 RETVAL
1551
1552ev_embed *embed (struct ev_loop *loop, struct ev_loop *other, SV *cb = 0)
1553 ALIAS:
1554 embed_ns = 1
1555 CODE:
1556{
1557 if (!(ev_backend (other) & ev_embeddable_backends ()))
1558 croak ("passed loop is not embeddable via EV::embed,");
1559
1560 RETVAL = e_new (sizeof (ev_embed), cb, ST (0));
1561 e_fh (RETVAL) = newSVsv (ST (1));
1562 ev_embed_set (RETVAL, other);
1563 if (!ix) START (embed, RETVAL);
1564}
1565 OUTPUT:
1566 RETVAL
1567
1568ev_async *async (struct ev_loop *loop, SV *cb)
1569 ALIAS:
1570 async_ns = 1
1571 CODE:
1572 RETVAL = e_new (sizeof (ev_async), cb, ST (0));
1573 ev_async_set (RETVAL);
1574 if (!ix) START (async, RETVAL);
1575 OUTPUT:
1576 RETVAL
1577
1578void once (struct ev_loop *loop, SV *fh, int events, SV *timeout, SV *cb)
1579 CODE:
1580 ev_once (
1581 loop,
1582 s_fileno (fh, events & EV_WRITE), events,
1583 SvOK (timeout) ? SvNV (timeout) : -1.,
1584 e_once_cb,
1585 newSVsv (cb)
1586 );
1587
1588#endif
1589

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines