ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/EV/EV.xs
Revision: 1.127
Committed: Tue Jul 14 02:33:55 2009 UTC (14 years, 10 months ago) by root
Branch: MAIN
Changes since 1.126: +8 -1 lines
Log Message:
*** empty log message ***

File Contents

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