ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/EV/EV.xs
Revision: 1.129
Committed: Tue Jul 14 20:34:58 2009 UTC (14 years, 10 months ago) by root
Branch: MAIN
Changes since 1.128: +10 -0 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.pending_count = ev_pending_count;
423 evapi.set_loop_release_cb = ev_set_loop_release_cb;
424 evapi.set_invoke_pending_cb= ev_set_invoke_pending_cb;
425 evapi.ref = ev_ref;
426 evapi.unref = ev_unref;
427 evapi.loop = ev_loop;
428 evapi.once = ev_once;
429 evapi.io_start = ev_io_start;
430 evapi.io_stop = ev_io_stop;
431 evapi.timer_start = ev_timer_start;
432 evapi.timer_stop = ev_timer_stop;
433 evapi.timer_again = ev_timer_again;
434 evapi.periodic_start = ev_periodic_start;
435 evapi.periodic_stop = ev_periodic_stop;
436 evapi.signal_start = ev_signal_start;
437 evapi.signal_stop = ev_signal_stop;
438 evapi.idle_start = ev_idle_start;
439 evapi.idle_stop = ev_idle_stop;
440 evapi.prepare_start = ev_prepare_start;
441 evapi.prepare_stop = ev_prepare_stop;
442 evapi.check_start = ev_check_start;
443 evapi.check_stop = ev_check_stop;
444 evapi.child_start = ev_child_start;
445 evapi.child_stop = ev_child_stop;
446 evapi.stat_start = ev_stat_start;
447 evapi.stat_stop = ev_stat_stop;
448 evapi.stat_stat = ev_stat_stat;
449 evapi.embed_start = ev_embed_start;
450 evapi.embed_stop = ev_embed_stop;
451 evapi.embed_sweep = ev_embed_sweep;
452 evapi.fork_start = ev_fork_start;
453 evapi.fork_stop = ev_fork_stop;
454 evapi.async_start = ev_async_start;
455 evapi.async_stop = ev_async_stop;
456 evapi.async_send = ev_async_send;
457 evapi.clear_pending = ev_clear_pending;
458 evapi.invoke = ev_invoke;
459
460 sv_setiv (sv, (IV)&evapi);
461 SvREADONLY_on (sv);
462 }
463 #ifndef _WIN32
464 pthread_atfork (0, 0, ev_default_fork);
465 #endif
466 }
467
468 SV *ev_default_loop (unsigned int flags = 0)
469 CODE:
470 {
471 if (!default_loop_sv)
472 {
473 evapi.default_loop = ev_default_loop (flags);
474
475 if (!evapi.default_loop)
476 XSRETURN_UNDEF;
477
478 default_loop_sv = sv_bless (newRV_noinc (newSViv (PTR2IV (evapi.default_loop))), stash_loop);
479 }
480
481 RETVAL = newSVsv (default_loop_sv);
482 }
483 OUTPUT:
484 RETVAL
485
486 void ev_default_destroy ()
487 CODE:
488 ev_default_destroy ();
489 SvREFCNT_dec (default_loop_sv);
490 default_loop_sv = 0;
491
492 unsigned int ev_supported_backends ()
493
494 unsigned int ev_recommended_backends ()
495
496 unsigned int ev_embeddable_backends ()
497
498 void ev_sleep (NV interval)
499
500 NV ev_time ()
501
502 NV ev_now ()
503 C_ARGS: evapi.default_loop
504
505 void ev_now_update ()
506 C_ARGS: evapi.default_loop
507
508 void ev_suspend ()
509 C_ARGS: evapi.default_loop
510
511 void ev_resume ()
512 C_ARGS: evapi.default_loop
513
514 unsigned int ev_backend ()
515 C_ARGS: evapi.default_loop
516
517 void ev_loop_verify ()
518 C_ARGS: evapi.default_loop
519
520 unsigned int ev_loop_count ()
521 C_ARGS: evapi.default_loop
522
523 unsigned int ev_loop_depth ()
524 C_ARGS: evapi.default_loop
525
526 void ev_set_io_collect_interval (NV interval)
527 C_ARGS: evapi.default_loop, interval
528
529 void ev_set_timeout_collect_interval (NV interval)
530 C_ARGS: evapi.default_loop, interval
531
532 void ev_loop (int flags = 0)
533 C_ARGS: evapi.default_loop, flags
534
535 void ev_unloop (int how = EVUNLOOP_ONE)
536 C_ARGS: evapi.default_loop, how
537
538 void ev_feed_fd_event (int fd, int revents = EV_NONE)
539 C_ARGS: evapi.default_loop, fd, revents
540
541 void ev_feed_signal_event (SV *signal)
542 CODE:
543 {
544 Signal signum = s_signum (signal);
545 CHECK_SIG (signal, signum);
546
547 ev_feed_signal_event (evapi.default_loop, signum);
548 }
549
550 unsigned int ev_pending_count ()
551 C_ARGS: evapi.default_loop
552
553 void ev_invoke_pending ()
554 C_ARGS: evapi.default_loop
555
556 ev_io *io (SV *fh, int events, SV *cb)
557 ALIAS:
558 io_ns = 1
559 CODE:
560 {
561 int fd = s_fileno (fh, events & EV_WRITE);
562 CHECK_FD (fh, fd);
563
564 RETVAL = e_new (sizeof (ev_io), cb, default_loop_sv);
565 RETVAL->fh = newSVsv (fh);
566 ev_io_set (RETVAL, fd, events);
567 if (!ix) START (io, RETVAL);
568 }
569 OUTPUT:
570 RETVAL
571
572 ev_timer *timer (NV after, NV repeat, SV *cb)
573 ALIAS:
574 timer_ns = 1
575 INIT:
576 CHECK_REPEAT (repeat);
577 CODE:
578 RETVAL = e_new (sizeof (ev_timer), cb, default_loop_sv);
579 ev_timer_set (RETVAL, after, repeat);
580 if (!ix) START (timer, RETVAL);
581 OUTPUT:
582 RETVAL
583
584 SV *periodic (NV at, NV interval, SV *reschedule_cb, SV *cb)
585 ALIAS:
586 periodic_ns = 1
587 INIT:
588 CHECK_REPEAT (interval);
589 CODE:
590 {
591 ev_periodic *w;
592 w = e_new (sizeof (ev_periodic), cb, default_loop_sv);
593 w->fh = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0;
594 ev_periodic_set (w, at, interval, w->fh ? e_periodic_cb : 0);
595 RETVAL = e_bless ((ev_watcher *)w, stash_periodic);
596 if (!ix) START (periodic, w);
597 }
598 OUTPUT:
599 RETVAL
600
601 ev_signal *signal (SV *signal, SV *cb)
602 ALIAS:
603 signal_ns = 1
604 CODE:
605 {
606 Signal signum = s_signum (signal);
607 CHECK_SIG (signal, signum);
608
609 RETVAL = e_new (sizeof (ev_signal), cb, default_loop_sv);
610 ev_signal_set (RETVAL, signum);
611 if (!ix) START (signal, RETVAL);
612 }
613 OUTPUT:
614 RETVAL
615
616 ev_idle *idle (SV *cb)
617 ALIAS:
618 idle_ns = 1
619 CODE:
620 RETVAL = e_new (sizeof (ev_idle), cb, default_loop_sv);
621 ev_idle_set (RETVAL);
622 if (!ix) START (idle, RETVAL);
623 OUTPUT:
624 RETVAL
625
626 ev_prepare *prepare (SV *cb)
627 ALIAS:
628 prepare_ns = 1
629 CODE:
630 RETVAL = e_new (sizeof (ev_prepare), cb, default_loop_sv);
631 ev_prepare_set (RETVAL);
632 if (!ix) START (prepare, RETVAL);
633 OUTPUT:
634 RETVAL
635
636 ev_check *check (SV *cb)
637 ALIAS:
638 check_ns = 1
639 CODE:
640 RETVAL = e_new (sizeof (ev_check), cb, default_loop_sv);
641 ev_check_set (RETVAL);
642 if (!ix) START (check, RETVAL);
643 OUTPUT:
644 RETVAL
645
646 ev_fork *fork (SV *cb)
647 ALIAS:
648 fork_ns = 1
649 CODE:
650 RETVAL = e_new (sizeof (ev_fork), cb, default_loop_sv);
651 ev_fork_set (RETVAL);
652 if (!ix) START (fork, RETVAL);
653 OUTPUT:
654 RETVAL
655
656 ev_child *child (int pid, int trace, SV *cb)
657 ALIAS:
658 child_ns = 1
659 CODE:
660 RETVAL = e_new (sizeof (ev_child), cb, default_loop_sv);
661 ev_child_set (RETVAL, pid, trace);
662 if (!ix) START (child, RETVAL);
663 OUTPUT:
664 RETVAL
665
666 ev_stat *stat (SV *path, NV interval, SV *cb)
667 ALIAS:
668 stat_ns = 1
669 CODE:
670 RETVAL = e_new (sizeof (ev_stat), cb, default_loop_sv);
671 RETVAL->fh = newSVsv (path);
672 ev_stat_set (RETVAL, SvPVbyte_nolen (RETVAL->fh), interval);
673 if (!ix) START (stat, RETVAL);
674 OUTPUT:
675 RETVAL
676
677 ev_embed *embed (struct ev_loop *loop, SV *cb = 0)
678 ALIAS:
679 embed_ns = 1
680 CODE:
681 {
682 if (!(ev_backend (loop) & ev_embeddable_backends ()))
683 croak ("passed loop is not embeddable via EV::embed,");
684
685 RETVAL = e_new (sizeof (ev_embed), cb, default_loop_sv);
686 RETVAL->fh = newSVsv (ST (0));
687 ev_embed_set (RETVAL, loop);
688 if (!ix) START (embed, RETVAL);
689 }
690 OUTPUT:
691 RETVAL
692
693 ev_async *async (SV *cb)
694 ALIAS:
695 async_ns = 1
696 CODE:
697 RETVAL = e_new (sizeof (ev_async), cb, default_loop_sv);
698 ev_async_set (RETVAL);
699 if (!ix) START (async, RETVAL);
700 OUTPUT:
701 RETVAL
702
703 void once (SV *fh, int events, SV *timeout, SV *cb)
704 CODE:
705 ev_once (
706 evapi.default_loop,
707 s_fileno (fh, events & EV_WRITE), events,
708 SvOK (timeout) ? SvNV (timeout) : -1.,
709 e_once_cb,
710 newSVsv (cb)
711 );
712
713 PROTOTYPES: DISABLE
714
715 MODULE = EV PACKAGE = EV::Watcher PREFIX = ev_
716
717 int ev_is_active (ev_watcher *w)
718
719 int ev_is_pending (ev_watcher *w)
720
721 void ev_invoke (ev_watcher *w, int revents = EV_NONE)
722 C_ARGS: e_loop (w), w, revents
723
724 int ev_clear_pending (ev_watcher *w)
725 C_ARGS: e_loop (w), w
726
727 void ev_feed_event (ev_watcher *w, int revents = EV_NONE)
728 C_ARGS: e_loop (w), w, revents
729
730 int keepalive (ev_watcher *w, int new_value = 0)
731 CODE:
732 {
733 RETVAL = w->e_flags & WFLAG_KEEPALIVE;
734 new_value = new_value ? WFLAG_KEEPALIVE : 0;
735
736 if (items > 1 && ((new_value ^ w->e_flags) & WFLAG_KEEPALIVE))
737 {
738 w->e_flags = (w->e_flags & ~WFLAG_KEEPALIVE) | new_value;
739 REF (w);
740 UNREF (w);
741 }
742 }
743 OUTPUT:
744 RETVAL
745
746 SV *cb (ev_watcher *w, SV *new_cb = 0)
747 CODE:
748 {
749 if (items > 1)
750 {
751 new_cb = s_get_cv_croak (new_cb);
752 RETVAL = newRV_noinc (w->cb_sv);
753 w->cb_sv = SvREFCNT_inc (new_cb);
754 }
755 else
756 RETVAL = newRV_inc (w->cb_sv);
757 }
758 OUTPUT:
759 RETVAL
760
761 SV *data (ev_watcher *w, SV *new_data = 0)
762 CODE:
763 {
764 RETVAL = w->data ? newSVsv (w->data) : &PL_sv_undef;
765
766 if (items > 1)
767 {
768 SvREFCNT_dec (w->data);
769 w->data = newSVsv (new_data);
770 }
771 }
772 OUTPUT:
773 RETVAL
774
775 SV *loop (ev_watcher *w)
776 CODE:
777 RETVAL = newRV_inc (w->loop);
778 OUTPUT:
779 RETVAL
780
781 int priority (ev_watcher *w, int new_priority = 0)
782 CODE:
783 {
784 RETVAL = w->priority;
785
786 if (items > 1)
787 {
788 int active = ev_is_active (w);
789
790 if (active)
791 {
792 /* grrr. */
793 PUSHMARK (SP);
794 XPUSHs (ST (0));
795 PUTBACK;
796 call_method ("stop", G_DISCARD | G_VOID);
797 }
798
799 ev_set_priority (w, new_priority);
800
801 if (active)
802 {
803 PUSHMARK (SP);
804 XPUSHs (ST (0));
805 PUTBACK;
806 call_method ("start", G_DISCARD | G_VOID);
807 }
808 }
809 }
810 OUTPUT:
811 RETVAL
812
813 MODULE = EV PACKAGE = EV::IO PREFIX = ev_io_
814
815 void ev_io_start (ev_io *w)
816 CODE:
817 START (io, w);
818
819 void ev_io_stop (ev_io *w)
820 CODE:
821 STOP (io, w);
822
823 void DESTROY (ev_io *w)
824 CODE:
825 STOP (io, w);
826 e_destroy (w);
827
828 void set (ev_io *w, SV *fh, int events)
829 CODE:
830 {
831 int fd = s_fileno (fh, events & EV_WRITE);
832 CHECK_FD (fh, fd);
833
834 sv_setsv (w->fh, fh);
835 RESET (io, w, (w, fd, events));
836 }
837
838 SV *fh (ev_io *w, SV *new_fh = 0)
839 CODE:
840 {
841 if (items > 1)
842 {
843 int fd = s_fileno (new_fh, w->events & EV_WRITE);
844 CHECK_FD (new_fh, fd);
845
846 RETVAL = w->fh;
847 w->fh = newSVsv (new_fh);
848
849 RESET (io, w, (w, fd, w->events));
850 }
851 else
852 RETVAL = newSVsv (w->fh);
853 }
854 OUTPUT:
855 RETVAL
856
857 int events (ev_io *w, int new_events = EV_UNDEF)
858 CODE:
859 {
860 RETVAL = w->events;
861
862 if (items > 1)
863 RESET (io, w, (w, w->fd, new_events));
864 }
865 OUTPUT:
866 RETVAL
867
868 MODULE = EV PACKAGE = EV::Signal PREFIX = ev_signal_
869
870 void ev_signal_start (ev_signal *w)
871 CODE:
872 START (signal, w);
873
874 void ev_signal_stop (ev_signal *w)
875 CODE:
876 STOP (signal, w);
877
878 void DESTROY (ev_signal *w)
879 CODE:
880 STOP (signal, w);
881 e_destroy (w);
882
883 void set (ev_signal *w, SV *signal)
884 CODE:
885 {
886 Signal signum = s_signum (signal);
887 CHECK_SIG (signal, signum);
888
889 RESET (signal, w, (w, signum));
890 }
891
892 int signal (ev_signal *w, SV *new_signal = 0)
893 CODE:
894 {
895 RETVAL = w->signum;
896
897 if (items > 1)
898 {
899 Signal signum = s_signum (new_signal);
900 CHECK_SIG (new_signal, signum);
901
902 RESET (signal, w, (w, signum));
903 }
904 }
905 OUTPUT:
906 RETVAL
907
908 MODULE = EV PACKAGE = EV::Timer PREFIX = ev_timer_
909
910 void ev_timer_start (ev_timer *w)
911 INIT:
912 CHECK_REPEAT (w->repeat);
913 CODE:
914 START (timer, w);
915
916 void ev_timer_stop (ev_timer *w)
917 CODE:
918 STOP (timer, w);
919
920 void ev_timer_again (ev_timer *w)
921 INIT:
922 CHECK_REPEAT (w->repeat);
923 CODE:
924 ev_timer_again (e_loop (w), w);
925 UNREF (w);
926
927 void DESTROY (ev_timer *w)
928 CODE:
929 STOP (timer, w);
930 e_destroy (w);
931
932 void set (ev_timer *w, NV after, NV repeat = 0.)
933 INIT:
934 CHECK_REPEAT (repeat);
935 CODE:
936 RESET (timer, w, (w, after, repeat));
937
938 MODULE = EV PACKAGE = EV::Periodic PREFIX = ev_periodic_
939
940 void ev_periodic_start (ev_periodic *w)
941 INIT:
942 CHECK_REPEAT (w->interval);
943 CODE:
944 START (periodic, w);
945
946 void ev_periodic_stop (ev_periodic *w)
947 CODE:
948 STOP (periodic, w);
949
950 void ev_periodic_again (ev_periodic *w)
951 CODE:
952 ev_periodic_again (e_loop (w), w);
953 UNREF (w);
954
955 void DESTROY (ev_periodic *w)
956 CODE:
957 STOP (periodic, w);
958 e_destroy (w);
959
960 void set (ev_periodic *w, NV at, NV interval = 0., SV *reschedule_cb = &PL_sv_undef)
961 INIT:
962 CHECK_REPEAT (interval);
963 CODE:
964 {
965 SvREFCNT_dec (w->fh);
966 w->fh = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0;
967
968 RESET (periodic, w, (w, at, interval, w->fh ? e_periodic_cb : 0));
969 }
970
971 NV at (ev_periodic *w)
972 CODE:
973 RETVAL = ev_periodic_at (w);
974 OUTPUT:
975 RETVAL
976
977 MODULE = EV PACKAGE = EV::Idle PREFIX = ev_idle_
978
979 void ev_idle_start (ev_idle *w)
980 CODE:
981 START (idle, w);
982
983 void ev_idle_stop (ev_idle *w)
984 CODE:
985 STOP (idle, w);
986
987 void DESTROY (ev_idle *w)
988 CODE:
989 STOP (idle, w);
990 e_destroy (w);
991
992 MODULE = EV PACKAGE = EV::Prepare PREFIX = ev_prepare_
993
994 void ev_prepare_start (ev_prepare *w)
995 CODE:
996 START (prepare, w);
997
998 void ev_prepare_stop (ev_prepare *w)
999 CODE:
1000 STOP (prepare, w);
1001
1002 void DESTROY (ev_prepare *w)
1003 CODE:
1004 STOP (prepare, w);
1005 e_destroy (w);
1006
1007 MODULE = EV PACKAGE = EV::Check PREFIX = ev_check_
1008
1009 void ev_check_start (ev_check *w)
1010 CODE:
1011 START (check, w);
1012
1013 void ev_check_stop (ev_check *w)
1014 CODE:
1015 STOP (check, w);
1016
1017 void DESTROY (ev_check *w)
1018 CODE:
1019 STOP (check, w);
1020 e_destroy (w);
1021
1022 MODULE = EV PACKAGE = EV::Fork PREFIX = ev_fork_
1023
1024 void ev_fork_start (ev_fork *w)
1025 CODE:
1026 START (fork, w);
1027
1028 void ev_fork_stop (ev_fork *w)
1029 CODE:
1030 STOP (fork, w);
1031
1032 void DESTROY (ev_fork *w)
1033 CODE:
1034 STOP (fork, w);
1035 e_destroy (w);
1036
1037 MODULE = EV PACKAGE = EV::Child PREFIX = ev_child_
1038
1039 void ev_child_start (ev_child *w)
1040 CODE:
1041 START (child, w);
1042
1043 void ev_child_stop (ev_child *w)
1044 CODE:
1045 STOP (child, w);
1046
1047 void DESTROY (ev_child *w)
1048 CODE:
1049 STOP (child, w);
1050 e_destroy (w);
1051
1052 void set (ev_child *w, int pid, int trace)
1053 CODE:
1054 RESET (child, w, (w, pid, trace));
1055
1056 int pid (ev_child *w)
1057 ALIAS:
1058 rpid = 1
1059 rstatus = 2
1060 CODE:
1061 RETVAL = ix == 0 ? w->pid
1062 : ix == 1 ? w->rpid
1063 : w->rstatus;
1064 OUTPUT:
1065 RETVAL
1066
1067 MODULE = EV PACKAGE = EV::Stat PREFIX = ev_stat_
1068
1069 void ev_stat_start (ev_stat *w)
1070 CODE:
1071 START (stat, w);
1072
1073 void ev_stat_stop (ev_stat *w)
1074 CODE:
1075 STOP (stat, w);
1076
1077 void DESTROY (ev_stat *w)
1078 CODE:
1079 STOP (stat, w);
1080 e_destroy (w);
1081
1082 void set (ev_stat *w, SV *path, NV interval)
1083 CODE:
1084 {
1085 sv_setsv (w->fh, path);
1086 RESET (stat, w, (w, SvPVbyte_nolen (w->fh), interval));
1087 }
1088
1089 SV *path (ev_stat *w, SV *new_path = 0)
1090 CODE:
1091 {
1092 RETVAL = SvREFCNT_inc (w->fh);
1093
1094 if (items > 1)
1095 {
1096 SvREFCNT_dec (w->fh);
1097 w->fh = newSVsv (new_path);
1098 RESET (stat, w, (w, SvPVbyte_nolen (w->fh), w->interval));
1099 }
1100 }
1101 OUTPUT:
1102 RETVAL
1103
1104 NV interval (ev_stat *w, NV new_interval = 0.)
1105 CODE:
1106 {
1107 RETVAL = w->interval;
1108
1109 if (items > 1)
1110 RESET (stat, w, (w, SvPVbyte_nolen (w->fh), new_interval));
1111 }
1112 OUTPUT:
1113 RETVAL
1114
1115 void prev (ev_stat *w)
1116 ALIAS:
1117 stat = 1
1118 attr = 2
1119 PPCODE:
1120 {
1121 ev_statdata *s = ix ? &w->attr : &w->prev;
1122
1123 if (ix == 1)
1124 ev_stat_stat (e_loop (w), w);
1125 else if (!s->st_nlink)
1126 errno = ENOENT;
1127
1128 PL_statcache.st_dev = s->st_nlink;
1129 PL_statcache.st_ino = s->st_ino;
1130 PL_statcache.st_mode = s->st_mode;
1131 PL_statcache.st_nlink = s->st_nlink;
1132 PL_statcache.st_uid = s->st_uid;
1133 PL_statcache.st_gid = s->st_gid;
1134 PL_statcache.st_rdev = s->st_rdev;
1135 PL_statcache.st_size = s->st_size;
1136 PL_statcache.st_atime = s->st_atime;
1137 PL_statcache.st_mtime = s->st_mtime;
1138 PL_statcache.st_ctime = s->st_ctime;
1139
1140 if (GIMME_V == G_SCALAR)
1141 XPUSHs (boolSV (s->st_nlink));
1142 else if (GIMME_V == G_ARRAY && s->st_nlink)
1143 {
1144 EXTEND (SP, 13);
1145 PUSHs (sv_2mortal (newSViv (s->st_dev)));
1146 PUSHs (sv_2mortal (newSViv (s->st_ino)));
1147 PUSHs (sv_2mortal (newSVuv (s->st_mode)));
1148 PUSHs (sv_2mortal (newSVuv (s->st_nlink)));
1149 PUSHs (sv_2mortal (newSViv (s->st_uid)));
1150 PUSHs (sv_2mortal (newSViv (s->st_gid)));
1151 PUSHs (sv_2mortal (newSViv (s->st_rdev)));
1152 PUSHs (sv_2mortal (newSVnv ((NV)s->st_size)));
1153 PUSHs (sv_2mortal (newSVnv (s->st_atime)));
1154 PUSHs (sv_2mortal (newSVnv (s->st_mtime)));
1155 PUSHs (sv_2mortal (newSVnv (s->st_ctime)));
1156 PUSHs (sv_2mortal (newSVuv (4096)));
1157 PUSHs (sv_2mortal (newSVnv ((NV)((s->st_size + 4095) / 4096))));
1158 }
1159 }
1160
1161 MODULE = EV PACKAGE = EV::Embed PREFIX = ev_embed_
1162
1163 void ev_embed_start (ev_embed *w)
1164 CODE:
1165 START (embed, w);
1166
1167 void ev_embed_stop (ev_embed *w)
1168 CODE:
1169 STOP (embed, w);
1170
1171 void DESTROY (ev_embed *w)
1172 CODE:
1173 STOP (embed, w);
1174 e_destroy (w);
1175
1176 void set (ev_embed *w, struct ev_loop *loop)
1177 CODE:
1178 {
1179 sv_setsv (w->fh, ST (1));
1180 RESET (embed, w, (w, loop));
1181 }
1182
1183 SV *other (ev_embed *w)
1184 CODE:
1185 RETVAL = newSVsv (w->fh);
1186 OUTPUT:
1187 RETVAL
1188
1189 void ev_embed_sweep (ev_embed *w)
1190 C_ARGS: e_loop (w), w
1191
1192 MODULE = EV PACKAGE = EV::Async PREFIX = ev_async_
1193
1194 void ev_async_start (ev_async *w)
1195 CODE:
1196 START (async, w);
1197
1198 void ev_async_stop (ev_async *w)
1199 CODE:
1200 STOP (async, w);
1201
1202 void DESTROY (ev_async *w)
1203 CODE:
1204 STOP (async, w);
1205 e_destroy (w);
1206
1207 void ev_async_send (ev_async *w)
1208 C_ARGS: e_loop (w), w
1209
1210 SV *ev_async_async_pending (ev_async *w)
1211 CODE:
1212 RETVAL = boolSV (ev_async_pending (w));
1213 OUTPUT:
1214 RETVAL
1215
1216 MODULE = EV PACKAGE = EV::Loop PREFIX = ev_
1217
1218 SV *new (SV *klass, unsigned int flags = 0)
1219 CODE:
1220 {
1221 struct ev_loop *loop = ev_loop_new (flags);
1222
1223 if (!loop)
1224 XSRETURN_UNDEF;
1225
1226 RETVAL = sv_bless (newRV_noinc (newSViv (PTR2IV (loop))), stash_loop);
1227 }
1228 OUTPUT:
1229 RETVAL
1230
1231 void DESTROY (struct ev_loop *loop)
1232 CODE:
1233 if (loop != evapi.default_loop) /* global destruction sucks */
1234 ev_loop_destroy (loop);
1235
1236 void ev_loop_fork (struct ev_loop *loop)
1237
1238 void ev_loop_verify (struct ev_loop *loop)
1239
1240 NV ev_now (struct ev_loop *loop)
1241
1242 void ev_now_update (struct ev_loop *loop)
1243
1244 void ev_suspend (struct ev_loop *loop)
1245
1246 void ev_resume (struct ev_loop *loop)
1247
1248 void ev_set_io_collect_interval (struct ev_loop *loop, NV interval)
1249
1250 void ev_set_timeout_collect_interval (struct ev_loop *loop, NV interval)
1251
1252 unsigned int ev_backend (struct ev_loop *loop)
1253
1254 unsigned int ev_loop_count (struct ev_loop *loop)
1255
1256 unsigned int ev_loop_depth (struct ev_loop *loop)
1257
1258 void ev_loop (struct ev_loop *loop, int flags = 0)
1259
1260 void ev_unloop (struct ev_loop *loop, int how = 1)
1261
1262 void ev_feed_fd_event (struct ev_loop *loop, int fd, int revents = EV_NONE)
1263
1264 unsigned int ev_pending_count (struct ev_loop *loop)
1265
1266 void ev_invoke_pending (struct ev_loop *loop)
1267
1268 #if 0
1269
1270 void ev_feed_signal_event (struct ev_loop *loop, SV *signal)
1271 CODE:
1272 {
1273 Signal signum = s_signum (signal);
1274 CHECK_SIG (signal, signum);
1275
1276 ev_feed_signal_event (loop, signum);
1277 }
1278
1279 #endif
1280
1281 ev_io *io (struct ev_loop *loop, SV *fh, int events, SV *cb)
1282 ALIAS:
1283 io_ns = 1
1284 CODE:
1285 {
1286 int fd = s_fileno (fh, events & EV_WRITE);
1287 CHECK_FD (fh, fd);
1288
1289 RETVAL = e_new (sizeof (ev_io), cb, ST (0));
1290 RETVAL->fh = newSVsv (fh);
1291 ev_io_set (RETVAL, fd, events);
1292 if (!ix) START (io, RETVAL);
1293 }
1294 OUTPUT:
1295 RETVAL
1296
1297 ev_timer *timer (struct ev_loop *loop, NV after, NV repeat, SV *cb)
1298 ALIAS:
1299 timer_ns = 1
1300 INIT:
1301 CHECK_REPEAT (repeat);
1302 CODE:
1303 RETVAL = e_new (sizeof (ev_timer), cb, ST (0));
1304 ev_timer_set (RETVAL, after, repeat);
1305 if (!ix) START (timer, RETVAL);
1306 OUTPUT:
1307 RETVAL
1308
1309 SV *periodic (struct ev_loop *loop, NV at, NV interval, SV *reschedule_cb, SV *cb)
1310 ALIAS:
1311 periodic_ns = 1
1312 INIT:
1313 CHECK_REPEAT (interval);
1314 CODE:
1315 {
1316 ev_periodic *w;
1317 w = e_new (sizeof (ev_periodic), cb, ST (0));
1318 w->fh = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0;
1319 ev_periodic_set (w, at, interval, w->fh ? e_periodic_cb : 0);
1320 RETVAL = e_bless ((ev_watcher *)w, stash_periodic);
1321 if (!ix) START (periodic, w);
1322 }
1323 OUTPUT:
1324 RETVAL
1325
1326 #if 0
1327
1328 ev_signal *signal (struct ev_loop *loop, SV *signal, SV *cb)
1329 ALIAS:
1330 signal_ns = 1
1331 CODE:
1332 {
1333 Signal signum = s_signum (signal);
1334 CHECK_SIG (signal, signum);
1335
1336 RETVAL = e_new (sizeof (ev_signal), cb, ST (0));
1337 ev_signal_set (RETVAL, signum);
1338 if (!ix) START (signal, RETVAL);
1339 }
1340 OUTPUT:
1341 RETVAL
1342
1343 #endif
1344
1345 ev_idle *idle (struct ev_loop *loop, SV *cb)
1346 ALIAS:
1347 idle_ns = 1
1348 CODE:
1349 RETVAL = e_new (sizeof (ev_idle), cb, ST (0));
1350 ev_idle_set (RETVAL);
1351 if (!ix) START (idle, RETVAL);
1352 OUTPUT:
1353 RETVAL
1354
1355 ev_prepare *prepare (struct ev_loop *loop, SV *cb)
1356 ALIAS:
1357 prepare_ns = 1
1358 CODE:
1359 RETVAL = e_new (sizeof (ev_prepare), cb, ST (0));
1360 ev_prepare_set (RETVAL);
1361 if (!ix) START (prepare, RETVAL);
1362 OUTPUT:
1363 RETVAL
1364
1365 ev_check *check (struct ev_loop *loop, SV *cb)
1366 ALIAS:
1367 check_ns = 1
1368 CODE:
1369 RETVAL = e_new (sizeof (ev_check), cb, ST (0));
1370 ev_check_set (RETVAL);
1371 if (!ix) START (check, RETVAL);
1372 OUTPUT:
1373 RETVAL
1374
1375 ev_fork *fork (struct ev_loop *loop, SV *cb)
1376 ALIAS:
1377 fork_ns = 1
1378 CODE:
1379 RETVAL = e_new (sizeof (ev_fork), cb, ST (0));
1380 ev_fork_set (RETVAL);
1381 if (!ix) START (fork, RETVAL);
1382 OUTPUT:
1383 RETVAL
1384
1385 ev_child *child (struct ev_loop *loop, int pid, int trace, SV *cb)
1386 ALIAS:
1387 child_ns = 1
1388 CODE:
1389 RETVAL = e_new (sizeof (ev_child), cb, ST (0));
1390 ev_child_set (RETVAL, pid, trace);
1391 if (!ix) START (child, RETVAL);
1392 OUTPUT:
1393 RETVAL
1394
1395 ev_stat *stat (struct ev_loop *loop, SV *path, NV interval, SV *cb)
1396 ALIAS:
1397 stat_ns = 1
1398 CODE:
1399 RETVAL = e_new (sizeof (ev_stat), cb, ST (0));
1400 RETVAL->fh = newSVsv (path);
1401 ev_stat_set (RETVAL, SvPVbyte_nolen (RETVAL->fh), interval);
1402 if (!ix) START (stat, RETVAL);
1403 OUTPUT:
1404 RETVAL
1405
1406 ev_embed *embed (struct ev_loop *loop, struct ev_loop *other, SV *cb = 0)
1407 ALIAS:
1408 embed_ns = 1
1409 CODE:
1410 {
1411 if (!(ev_backend (other) & ev_embeddable_backends ()))
1412 croak ("passed loop is not embeddable via EV::embed,");
1413
1414 RETVAL = e_new (sizeof (ev_embed), cb, ST (0));
1415 RETVAL->fh = newSVsv (ST (1));
1416 ev_embed_set (RETVAL, other);
1417 if (!ix) START (embed, RETVAL);
1418 }
1419 OUTPUT:
1420 RETVAL
1421
1422 ev_async *async (struct ev_loop *loop, SV *cb)
1423 ALIAS:
1424 async_ns = 1
1425 CODE:
1426 RETVAL = e_new (sizeof (ev_async), cb, ST (0));
1427 ev_async_set (RETVAL);
1428 if (!ix) START (async, RETVAL);
1429 OUTPUT:
1430 RETVAL
1431
1432 void once (struct ev_loop *loop, SV *fh, int events, SV *timeout, SV *cb)
1433 CODE:
1434 ev_once (
1435 loop,
1436 s_fileno (fh, events & EV_WRITE), events,
1437 SvOK (timeout) ? SvNV (timeout) : -1.,
1438 e_once_cb,
1439 newSVsv (cb)
1440 );
1441