ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/EV/EV.xs
Revision: 1.100
Committed: Fri Dec 21 09:43:57 2007 UTC (16 years, 4 months ago) by root
Branch: MAIN
Changes since 1.99: +1 -1 lines
Log Message:
*** empty log message ***

File Contents

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