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

Comparing EV/EV.xs (file contents):
Revision 1.90 by root, Mon Dec 17 07:24:12 2007 UTC vs.
Revision 1.102 by root, Sat Dec 22 16:37:08 2007 UTC

3#include "XSUB.h" 3#include "XSUB.h"
4 4
5/*#include <netinet/in.h>*/ 5/*#include <netinet/in.h>*/
6 6
7#define EV_PROTOTYPES 1 7#define EV_PROTOTYPES 1
8#define EV_USE_NANOSLEEP EV_USE_MONOTONIC
9#define EV_H <ev.h>
8#include "EV/EVAPI.h" 10#include "EV/EVAPI.h"
9 11
10/* fix perl api breakage */ 12/* fix perl api breakage */
11#undef signal 13#undef signal
12#undef sigaction 14#undef sigaction
17# define NFDBITS PERL_NFDBITS 19# define NFDBITS PERL_NFDBITS
18# define fd_mask Perl_fd_mask 20# define fd_mask Perl_fd_mask
19#endif 21#endif
20/* due to bugs in OS X we have to use libev/ explicitly here */ 22/* due to bugs in OS X we have to use libev/ explicitly here */
21#include "libev/ev.c" 23#include "libev/ev.c"
22#include "event.c"
23 24
24#ifndef _WIN32 25#ifndef _WIN32
25# include <pthread.h> 26# include <pthread.h>
26#endif 27#endif
27 28
29#define e_loop(w) INT2PTR (struct ev_loop *, SvIVX ((w)->loop))
30
28#define WFLAG_KEEPALIVE 1 31#define WFLAG_KEEPALIVE 1
29 32
30#define UNREF(w) \ 33#define UNREF(w) \
31 if (!((w)->flags & WFLAG_KEEPALIVE) \ 34 if (!((w)->flags & WFLAG_KEEPALIVE) \
32 && !ev_is_active (w)) \ 35 && !ev_is_active (w)) \
33 ev_unref (); 36 ev_unref (e_loop (w));
34 37
35#define REF(w) \ 38#define REF(w) \
36 if (!((w)->flags & WFLAG_KEEPALIVE) \ 39 if (!((w)->flags & WFLAG_KEEPALIVE) \
37 && ev_is_active (w)) \ 40 && ev_is_active (w)) \
38 ev_ref (); 41 ev_ref (e_loop (w));
39 42
40#define START(type,w) \ 43#define START(type,w) \
41 do { \ 44 do { \
42 UNREF (w); \ 45 UNREF (w); \
43 ev_ ## type ## _start (w); \ 46 ev_ ## type ## _start (e_loop (w), w); \
44 } while (0) 47 } while (0)
45 48
46#define STOP(type,w) \ 49#define STOP(type,w) \
47 do { \ 50 do { \
48 REF (w); \ 51 REF (w); \
49 ev_ ## type ## _stop (w); \ 52 ev_ ## type ## _stop (e_loop (w), w); \
50 } while (0) 53 } while (0)
51 54
52#define RESET(type,w,seta) \ 55#define RESET(type,w,seta) \
53 do { \ 56 do { \
54 int active = ev_is_active (w); \ 57 int active = ev_is_active (w); \
57 if (active) START (type, w); \ 60 if (active) START (type, w); \
58 } while (0) 61 } while (0)
59 62
60typedef int Signal; 63typedef int Signal;
61 64
65static SV *default_loop_sv;
66
62static struct EVAPI evapi; 67static struct EVAPI evapi;
63 68
64static HV 69static HV
70 *stash_loop,
65 *stash_watcher, 71 *stash_watcher,
66 *stash_io, 72 *stash_io,
67 *stash_timer, 73 *stash_timer,
68 *stash_periodic, 74 *stash_periodic,
69 *stash_signal, 75 *stash_signal,
101} 107}
102 108
103///////////////////////////////////////////////////////////////////////////// 109/////////////////////////////////////////////////////////////////////////////
104// Event 110// Event
105 111
106static void e_cb (ev_watcher *w, int revents); 112static void e_cb (EV_P_ ev_watcher *w, int revents);
107 113
108static int 114static int
109sv_fileno (SV *fh) 115sv_fileno (SV *fh)
110{ 116{
111 SvGETMAGIC (fh); 117 SvGETMAGIC (fh);
121 127
122 return -1; 128 return -1;
123} 129}
124 130
125static void * 131static void *
126e_new (int size, SV *cb_sv) 132e_new (int size, SV *cb_sv, SV *loop)
127{ 133{
128 ev_watcher *w; 134 ev_watcher *w;
129 SV *self = NEWSV (0, size); 135 SV *self = NEWSV (0, size);
130 SvPOK_only (self); 136 SvPOK_only (self);
131 SvCUR_set (self, size); 137 SvCUR_set (self, size);
132 138
133 w = (ev_watcher *)SvPVX (self); 139 w = (ev_watcher *)SvPVX (self);
134 140
135 ev_init (w, e_cb); 141 ev_init (w, e_cb);
136 142
143 w->loop = SvREFCNT_inc (SvRV (loop));
137 w->flags = WFLAG_KEEPALIVE; 144 w->flags = WFLAG_KEEPALIVE;
138 w->data = 0; 145 w->data = 0;
139 w->fh = 0; 146 w->fh = 0;
140 w->cb_sv = newSVsv (cb_sv); 147 w->cb_sv = SvTEMP (cb_sv) && SvREFCNT (cb_sv) == 1 ? SvREFCNT_inc (cb_sv) : newSVsv (cb_sv);
141 w->self = self; 148 w->self = self;
142 149
143 return (void *)w; 150 return (void *)w;
144} 151}
145 152
146static void 153static void
147e_destroy (void *w_) 154e_destroy (void *w_)
148{ 155{
149 ev_watcher *w = (ev_watcher *)w_; 156 ev_watcher *w = (ev_watcher *)w_;
150 157
158 SvREFCNT_dec (w->loop ); w->loop = 0;
151 SvREFCNT_dec (w->fh ); w->fh = 0; 159 SvREFCNT_dec (w->fh ); w->fh = 0;
152 SvREFCNT_dec (w->cb_sv); w->cb_sv = 0; 160 SvREFCNT_dec (w->cb_sv); w->cb_sv = 0;
153 SvREFCNT_dec (w->data ); w->data = 0; 161 SvREFCNT_dec (w->data ); w->data = 0;
154} 162}
155 163
171} 179}
172 180
173static SV *sv_events_cache; 181static SV *sv_events_cache;
174 182
175static void 183static void
176e_cb (ev_watcher *w, int revents) 184e_cb (EV_P_ ev_watcher *w, int revents)
177{ 185{
178 dSP; 186 dSP;
179 I32 mark = SP - PL_stack_base; 187 I32 mark = SP - PL_stack_base;
180 SV *sv_self, *sv_events; 188 SV *sv_self, *sv_events;
181 189
354 }; 362 };
355 363
356 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 364 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
357 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 365 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
358 366
367 stash_loop = gv_stashpv ("EV::Loop" , 1);
359 stash_watcher = gv_stashpv ("EV::Watcher" , 1); 368 stash_watcher = gv_stashpv ("EV::Watcher" , 1);
360 stash_io = gv_stashpv ("EV::IO" , 1); 369 stash_io = gv_stashpv ("EV::IO" , 1);
361 stash_timer = gv_stashpv ("EV::Timer" , 1); 370 stash_timer = gv_stashpv ("EV::Timer" , 1);
362 stash_periodic = gv_stashpv ("EV::Periodic", 1); 371 stash_periodic = gv_stashpv ("EV::Periodic", 1);
363 stash_signal = gv_stashpv ("EV::Signal" , 1); 372 stash_signal = gv_stashpv ("EV::Signal" , 1);
365 stash_prepare = gv_stashpv ("EV::Prepare" , 1); 374 stash_prepare = gv_stashpv ("EV::Prepare" , 1);
366 stash_check = gv_stashpv ("EV::Check" , 1); 375 stash_check = gv_stashpv ("EV::Check" , 1);
367 stash_child = gv_stashpv ("EV::Child" , 1); 376 stash_child = gv_stashpv ("EV::Child" , 1);
368 stash_embed = gv_stashpv ("EV::Embed" , 1); 377 stash_embed = gv_stashpv ("EV::Embed" , 1);
369 stash_stat = gv_stashpv ("EV::Stat" , 1); 378 stash_stat = gv_stashpv ("EV::Stat" , 1);
379 stash_fork = gv_stashpv ("EV::Fork" , 1);
370 380
371 { 381 {
372 SV *sv = perl_get_sv ("EV::API", TRUE); 382 SV *sv = perl_get_sv ("EV::API", TRUE);
373 perl_get_sv ("EV::API", TRUE); /* silence 5.10 warning */ 383 perl_get_sv ("EV::API", TRUE); /* silence 5.10 warning */
374 384
375 /* the poor man's shared library emulator */ 385 /* the poor man's shared library emulator */
376 evapi.ver = EV_API_VERSION; 386 evapi.ver = EV_API_VERSION;
377 evapi.rev = EV_API_REVISION; 387 evapi.rev = EV_API_REVISION;
378 evapi.sv_fileno = sv_fileno; 388 evapi.sv_fileno = sv_fileno;
379 evapi.sv_signum = sv_signum; 389 evapi.sv_signum = sv_signum;
390 evapi.supported_backends = ev_supported_backends ();
391 evapi.recommended_backends = ev_recommended_backends ();
392 evapi.embeddable_backends = ev_embeddable_backends ();
393 evapi.time = ev_time;
394 evapi.sleep = ev_sleep;
395 evapi.loop_new = ev_loop_new;
396 evapi.loop_destroy = ev_loop_destroy;
397 evapi.loop_fork = ev_loop_fork;
398 evapi.loop_count = ev_loop_count;
380 evapi.now = ev_now; 399 evapi.now = ev_now;
381 evapi.backend = ev_backend; 400 evapi.backend = ev_backend;
382 evapi.unloop = ev_unloop; 401 evapi.unloop = ev_unloop;
383 evapi.ref = ev_ref; 402 evapi.ref = ev_ref;
384 evapi.unref = ev_unref; 403 evapi.unref = ev_unref;
385 evapi.time = ev_time;
386 evapi.loop = ev_loop; 404 evapi.loop = ev_loop;
387 evapi.once = ev_once; 405 evapi.once = ev_once;
388 evapi.io_start = ev_io_start; 406 evapi.io_start = ev_io_start;
389 evapi.io_stop = ev_io_stop; 407 evapi.io_stop = ev_io_stop;
390 evapi.timer_start = ev_timer_start; 408 evapi.timer_start = ev_timer_start;
391 evapi.timer_stop = ev_timer_stop; 409 evapi.timer_stop = ev_timer_stop;
392 evapi.timer_again = ev_timer_again; 410 evapi.timer_again = ev_timer_again;
393 evapi.periodic_start = ev_periodic_start; 411 evapi.periodic_start = ev_periodic_start;
394 evapi.periodic_stop = ev_periodic_stop; 412 evapi.periodic_stop = ev_periodic_stop;
395 evapi.signal_start = ev_signal_start; 413 evapi.signal_start = ev_signal_start;
396 evapi.signal_stop = ev_signal_stop; 414 evapi.signal_stop = ev_signal_stop;
397 evapi.idle_start = ev_idle_start; 415 evapi.idle_start = ev_idle_start;
398 evapi.idle_stop = ev_idle_stop; 416 evapi.idle_stop = ev_idle_stop;
399 evapi.prepare_start = ev_prepare_start; 417 evapi.prepare_start = ev_prepare_start;
400 evapi.prepare_stop = ev_prepare_stop; 418 evapi.prepare_stop = ev_prepare_stop;
401 evapi.check_start = ev_check_start; 419 evapi.check_start = ev_check_start;
402 evapi.check_stop = ev_check_stop; 420 evapi.check_stop = ev_check_stop;
403 evapi.child_start = ev_child_start; 421 evapi.child_start = ev_child_start;
404 evapi.child_stop = ev_child_stop; 422 evapi.child_stop = ev_child_stop;
405 evapi.stat_start = ev_stat_start; 423 evapi.stat_start = ev_stat_start;
406 evapi.stat_stop = ev_stat_stop; 424 evapi.stat_stop = ev_stat_stop;
407 evapi.stat_stat = ev_stat_stat; 425 evapi.stat_stat = ev_stat_stat;
426 evapi.embed_start = ev_embed_start;
427 evapi.embed_stop = ev_embed_stop;
428 evapi.embed_sweep = ev_embed_sweep;
429 evapi.fork_start = ev_fork_start;
430 evapi.fork_stop = ev_fork_stop;
408 evapi.clear_pending = ev_clear_pending; 431 evapi.clear_pending = ev_clear_pending;
409 evapi.invoke = ev_invoke; 432 evapi.invoke = ev_invoke;
410 433
411 sv_setiv (sv, (IV)&evapi); 434 sv_setiv (sv, (IV)&evapi);
412 SvREADONLY_on (sv); 435 SvREADONLY_on (sv);
413 } 436 }
414#ifndef _WIN32 437#ifndef _WIN32
415 pthread_atfork (0, 0, ev_default_fork); 438 pthread_atfork (0, 0, ev_default_fork);
416#endif 439#endif
417} 440}
418 441
442SV *ev_default_loop (unsigned int flags = 0)
443 CODE:
444{
445 if (!default_loop_sv)
446 {
447 evapi.default_loop = ev_default_loop (flags);
448
449 if (!evapi.default_loop)
450 XSRETURN_UNDEF;
451
452 default_loop_sv = sv_bless (newRV_noinc (newSViv (PTR2IV (evapi.default_loop))), stash_loop);
453 }
454
455 RETVAL = newSVsv (default_loop_sv);
456}
457 OUTPUT:
458 RETVAL
459
460void ev_default_destroy ()
461 CODE:
462 ev_default_destroy ();
463 SvREFCNT_dec (default_loop_sv);
464 default_loop_sv = 0;
465
466unsigned int ev_supported_backends ()
467
468unsigned int ev_recommended_backends ()
469
470unsigned int ev_embeddable_backends ()
471
472NV ev_time ()
473
419NV ev_now () 474NV ev_now ()
475 C_ARGS: evapi.default_loop
420 476
421unsigned int ev_backend () 477unsigned int ev_backend ()
422 478 C_ARGS: evapi.default_loop
423NV ev_time ()
424
425unsigned int ev_default_loop (unsigned int flags = ev_supported_backends ())
426 479
427unsigned int ev_loop_count () 480unsigned int ev_loop_count ()
481 C_ARGS: evapi.default_loop
482
483void ev_set_io_collect_interval (NV interval)
484 C_ARGS: evapi.default_loop, interval
485
486void ev_set_timeout_collect_interval (NV interval)
487 C_ARGS: evapi.default_loop, interval
428 488
429void ev_loop (int flags = 0) 489void ev_loop (int flags = 0)
490 C_ARGS: evapi.default_loop, flags
430 491
431void ev_unloop (int how = 1) 492void ev_unloop (int how = 1)
493 C_ARGS: evapi.default_loop, how
432 494
433void ev_feed_fd_event (int fd, int revents = EV_NONE) 495void ev_feed_fd_event (int fd, int revents = EV_NONE)
496 C_ARGS: evapi.default_loop, fd, revents
434 497
435void ev_feed_signal_event (SV *signal) 498void ev_feed_signal_event (SV *signal)
436 CODE: 499 CODE:
437{ 500{
438 Signal signum = sv_signum (signal); 501 Signal signum = sv_signum (signal);
439 CHECK_SIG (signal, signum); 502 CHECK_SIG (signal, signum);
440 503
441 ev_feed_signal_event (EV_DEFAULT_ signum); 504 ev_feed_signal_event (evapi.default_loop, signum);
442} 505}
443 506
444ev_io *io (SV *fh, int events, SV *cb) 507ev_io *io (SV *fh, int events, SV *cb)
445 ALIAS: 508 ALIAS:
446 io_ns = 1 509 io_ns = 1
447 CODE: 510 CODE:
448{ 511{
449 int fd = sv_fileno (fh); 512 int fd = sv_fileno (fh);
450 CHECK_FD (fh, fd); 513 CHECK_FD (fh, fd);
451 514
452 RETVAL = e_new (sizeof (ev_io), cb); 515 RETVAL = e_new (sizeof (ev_io), cb, default_loop_sv);
453 RETVAL->fh = newSVsv (fh); 516 RETVAL->fh = newSVsv (fh);
454 ev_io_set (RETVAL, fd, events); 517 ev_io_set (RETVAL, fd, events);
455 if (!ix) START (io, RETVAL); 518 if (!ix) START (io, RETVAL);
456} 519}
457 OUTPUT: 520 OUTPUT:
461 ALIAS: 524 ALIAS:
462 timer_ns = 1 525 timer_ns = 1
463 INIT: 526 INIT:
464 CHECK_REPEAT (repeat); 527 CHECK_REPEAT (repeat);
465 CODE: 528 CODE:
466 RETVAL = e_new (sizeof (ev_timer), cb); 529 RETVAL = e_new (sizeof (ev_timer), cb, default_loop_sv);
467 ev_timer_set (RETVAL, after, repeat); 530 ev_timer_set (RETVAL, after, repeat);
468 if (!ix) START (timer, RETVAL); 531 if (!ix) START (timer, RETVAL);
469 OUTPUT: 532 OUTPUT:
470 RETVAL 533 RETVAL
471 534
475 INIT: 538 INIT:
476 CHECK_REPEAT (interval); 539 CHECK_REPEAT (interval);
477 CODE: 540 CODE:
478{ 541{
479 ev_periodic *w; 542 ev_periodic *w;
480 w = e_new (sizeof (ev_periodic), cb); 543 w = e_new (sizeof (ev_periodic), cb, default_loop_sv);
481 w->fh = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0; 544 w->fh = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0;
482 ev_periodic_set (w, at, interval, w->fh ? e_periodic_cb : 0); 545 ev_periodic_set (w, at, interval, w->fh ? e_periodic_cb : 0);
483 RETVAL = e_bless ((ev_watcher *)w, stash_periodic); 546 RETVAL = e_bless ((ev_watcher *)w, stash_periodic);
484 if (!ix) START (periodic, w); 547 if (!ix) START (periodic, w);
485} 548}
492 CODE: 555 CODE:
493{ 556{
494 Signal signum = sv_signum (signal); 557 Signal signum = sv_signum (signal);
495 CHECK_SIG (signal, signum); 558 CHECK_SIG (signal, signum);
496 559
497 RETVAL = e_new (sizeof (ev_signal), cb); 560 RETVAL = e_new (sizeof (ev_signal), cb, default_loop_sv);
498 ev_signal_set (RETVAL, signum); 561 ev_signal_set (RETVAL, signum);
499 if (!ix) START (signal, RETVAL); 562 if (!ix) START (signal, RETVAL);
500} 563}
501 OUTPUT: 564 OUTPUT:
502 RETVAL 565 RETVAL
503 566
504ev_idle *idle (SV *cb) 567ev_idle *idle (SV *cb)
505 ALIAS: 568 ALIAS:
506 idle_ns = 1 569 idle_ns = 1
507 CODE: 570 CODE:
508 RETVAL = e_new (sizeof (ev_idle), cb); 571 RETVAL = e_new (sizeof (ev_idle), cb, default_loop_sv);
509 ev_idle_set (RETVAL); 572 ev_idle_set (RETVAL);
510 if (!ix) START (idle, RETVAL); 573 if (!ix) START (idle, RETVAL);
511 OUTPUT: 574 OUTPUT:
512 RETVAL 575 RETVAL
513 576
514ev_prepare *prepare (SV *cb) 577ev_prepare *prepare (SV *cb)
515 ALIAS: 578 ALIAS:
516 prepare_ns = 1 579 prepare_ns = 1
517 CODE: 580 CODE:
518 RETVAL = e_new (sizeof (ev_prepare), cb); 581 RETVAL = e_new (sizeof (ev_prepare), cb, default_loop_sv);
519 ev_prepare_set (RETVAL); 582 ev_prepare_set (RETVAL);
520 if (!ix) START (prepare, RETVAL); 583 if (!ix) START (prepare, RETVAL);
521 OUTPUT: 584 OUTPUT:
522 RETVAL 585 RETVAL
523 586
524ev_check *check (SV *cb) 587ev_check *check (SV *cb)
525 ALIAS: 588 ALIAS:
526 check_ns = 1 589 check_ns = 1
527 CODE: 590 CODE:
528 RETVAL = e_new (sizeof (ev_check), cb); 591 RETVAL = e_new (sizeof (ev_check), cb, default_loop_sv);
529 ev_check_set (RETVAL); 592 ev_check_set (RETVAL);
530 if (!ix) START (check, RETVAL); 593 if (!ix) START (check, RETVAL);
531 OUTPUT: 594 OUTPUT:
532 RETVAL 595 RETVAL
533 596
597ev_fork *fork (SV *cb)
598 ALIAS:
599 fork_ns = 1
600 CODE:
601 RETVAL = e_new (sizeof (ev_fork), cb, default_loop_sv);
602 ev_fork_set (RETVAL);
603 if (!ix) START (fork, RETVAL);
604 OUTPUT:
605 RETVAL
606
534ev_child *child (int pid, SV *cb) 607ev_child *child (int pid, SV *cb)
535 ALIAS: 608 ALIAS:
536 child_ns = 1 609 child_ns = 1
537 CODE: 610 CODE:
538 RETVAL = e_new (sizeof (ev_child), cb); 611 RETVAL = e_new (sizeof (ev_child), cb, default_loop_sv);
539 ev_child_set (RETVAL, pid); 612 ev_child_set (RETVAL, pid);
540 if (!ix) START (child, RETVAL); 613 if (!ix) START (child, RETVAL);
541 OUTPUT: 614 OUTPUT:
542 RETVAL 615 RETVAL
543 616
544ev_stat *stat (SV *path, NV interval, SV *cb) 617ev_stat *stat (SV *path, NV interval, SV *cb)
545 ALIAS: 618 ALIAS:
546 stat_ns = 1 619 stat_ns = 1
547 CODE: 620 CODE:
548 RETVAL = e_new (sizeof (ev_stat), cb); 621 RETVAL = e_new (sizeof (ev_stat), cb, default_loop_sv);
549 RETVAL->fh = newSVsv (path); 622 RETVAL->fh = newSVsv (path);
550 ev_stat_set (RETVAL, SvPVbyte_nolen (RETVAL->fh), interval); 623 ev_stat_set (RETVAL, SvPVbyte_nolen (RETVAL->fh), interval);
551 if (!ix) START (stat, RETVAL); 624 if (!ix) START (stat, RETVAL);
552 OUTPUT: 625 OUTPUT:
553 RETVAL 626 RETVAL
554 627
628ev_embed *embed (struct ev_loop *loop, SV *cb = &PL_sv_undef)
629 ALIAS:
630 embed_ns = 1
631 CODE:
632{
633 if (!(ev_backend (loop) & ev_embeddable_backends ()))
634 croak ("passed loop is not embeddable via EV::embed,");
635
636 RETVAL = e_new (sizeof (ev_embed), cb, default_loop_sv);
637 RETVAL->fh = newSVsv (ST (0));
638 ev_embed_set (RETVAL, loop);
639
640 if (!SvOK (cb)) ev_set_cb (RETVAL, 0);
641
642 if (!ix) START (embed, RETVAL);
643}
644 OUTPUT:
645 RETVAL
646
555void once (SV *fh, int events, SV *timeout, SV *cb) 647void once (SV *fh, int events, SV *timeout, SV *cb)
556 CODE: 648 CODE:
557 ev_once ( 649 ev_once (
650 evapi.default_loop,
558 sv_fileno (fh), events, 651 sv_fileno (fh), events,
559 SvOK (timeout) ? SvNV (timeout) : -1., 652 SvOK (timeout) ? SvNV (timeout) : -1.,
560 e_once_cb, 653 e_once_cb,
561 newSVsv (cb) 654 newSVsv (cb)
562 ); 655 );
568int ev_is_active (ev_watcher *w) 661int ev_is_active (ev_watcher *w)
569 662
570int ev_is_pending (ev_watcher *w) 663int ev_is_pending (ev_watcher *w)
571 664
572void ev_invoke (ev_watcher *w, int revents = EV_NONE) 665void ev_invoke (ev_watcher *w, int revents = EV_NONE)
666 C_ARGS: e_loop (w), w, revents
573 667
574int ev_clear_pending (ev_watcher *w) 668int ev_clear_pending (ev_watcher *w)
669 C_ARGS: e_loop (w), w
575 670
576void ev_feed_event (ev_watcher *w, int revents = EV_NONE) 671void ev_feed_event (ev_watcher *w, int revents = EV_NONE)
672 C_ARGS: e_loop (w), w, revents
577 673
578int keepalive (ev_watcher *w, int new_value = 0) 674int keepalive (ev_watcher *w, int new_value = 0)
579 CODE: 675 CODE:
580{ 676{
581 RETVAL = w->flags & WFLAG_KEEPALIVE; 677 RETVAL = w->flags & WFLAG_KEEPALIVE;
611 { 707 {
612 SvREFCNT_dec (w->data); 708 SvREFCNT_dec (w->data);
613 w->data = newSVsv (new_data); 709 w->data = newSVsv (new_data);
614 } 710 }
615} 711}
712 OUTPUT:
713 RETVAL
714
715SV *loop (ev_watcher *w)
716 CODE:
717 RETVAL = newRV_inc (w->loop);
616 OUTPUT: 718 OUTPUT:
617 RETVAL 719 RETVAL
618 720
619int priority (ev_watcher *w, int new_priority = 0) 721int priority (ev_watcher *w, int new_priority = 0)
620 CODE: 722 CODE:
758void ev_timer_again (ev_timer *w) 860void ev_timer_again (ev_timer *w)
759 INIT: 861 INIT:
760 CHECK_REPEAT (w->repeat); 862 CHECK_REPEAT (w->repeat);
761 CODE: 863 CODE:
762 REF (w); 864 REF (w);
763 ev_timer_again (w); 865 ev_timer_again (e_loop (w), w);
764 UNREF (w); 866 UNREF (w);
765 867
766void DESTROY (ev_timer *w) 868void DESTROY (ev_timer *w)
767 CODE: 869 CODE:
768 STOP (timer, w); 870 STOP (timer, w);
793 STOP (periodic, w); 895 STOP (periodic, w);
794 896
795void ev_periodic_again (ev_periodic *w) 897void ev_periodic_again (ev_periodic *w)
796 CODE: 898 CODE:
797 REF (w); 899 REF (w);
798 ev_periodic_again (w); 900 ev_periodic_again (e_loop (w), w);
799 UNREF (w); 901 UNREF (w);
800 902
801void DESTROY (ev_periodic *w) 903void DESTROY (ev_periodic *w)
802 CODE: 904 CODE:
803 STOP (periodic, w); 905 STOP (periodic, w);
833void DESTROY (ev_idle *w) 935void DESTROY (ev_idle *w)
834 CODE: 936 CODE:
835 STOP (idle, w); 937 STOP (idle, w);
836 e_destroy (w); 938 e_destroy (w);
837 939
838MODULE = EV PACKAGE = EV::Prepare PREFIX = ev_check_ 940MODULE = EV PACKAGE = EV::Prepare PREFIX = ev_prepare_
839 941
840void ev_prepare_start (ev_prepare *w) 942void ev_prepare_start (ev_prepare *w)
841 CODE: 943 CODE:
842 START (prepare, w); 944 START (prepare, w);
843 945
861 STOP (check, w); 963 STOP (check, w);
862 964
863void DESTROY (ev_check *w) 965void DESTROY (ev_check *w)
864 CODE: 966 CODE:
865 STOP (check, w); 967 STOP (check, w);
968 e_destroy (w);
969
970MODULE = EV PACKAGE = EV::Fork PREFIX = ev_fork_
971
972void ev_fork_start (ev_fork *w)
973 CODE:
974 START (fork, w);
975
976void ev_fork_stop (ev_fork *w)
977 CODE:
978 STOP (fork, w);
979
980void DESTROY (ev_fork *w)
981 CODE:
982 STOP (fork, w);
866 e_destroy (w); 983 e_destroy (w);
867 984
868MODULE = EV PACKAGE = EV::Child PREFIX = ev_child_ 985MODULE = EV PACKAGE = EV::Child PREFIX = ev_child_
869 986
870void ev_child_start (ev_child *w) 987void ev_child_start (ev_child *w)
959 PPCODE: 1076 PPCODE:
960{ 1077{
961 ev_statdata *s = ix ? &w->attr : &w->prev; 1078 ev_statdata *s = ix ? &w->attr : &w->prev;
962 1079
963 if (ix == 1) 1080 if (ix == 1)
964 ev_stat_stat (w); 1081 ev_stat_stat (e_loop (w), w);
965 else if (!s->st_nlink) 1082 else if (!s->st_nlink)
966 errno = ENOENT; 1083 errno = ENOENT;
967 1084
968 PL_statcache.st_dev = s->st_nlink; 1085 PL_statcache.st_dev = s->st_nlink;
969 PL_statcache.st_ino = s->st_ino; 1086 PL_statcache.st_ino = s->st_ino;
996 PUSHs (sv_2mortal (newSVuv (4096))); 1113 PUSHs (sv_2mortal (newSVuv (4096)));
997 PUSHs (sv_2mortal (newSVnv ((NV)((s->st_size + 4095) / 4096)))); 1114 PUSHs (sv_2mortal (newSVnv ((NV)((s->st_size + 4095) / 4096))));
998 } 1115 }
999} 1116}
1000 1117
1118MODULE = EV PACKAGE = EV::Embed PREFIX = ev_embed_
1119
1120void ev_embed_start (ev_embed *w)
1121 CODE:
1122 START (embed, w);
1123
1124void ev_embed_stop (ev_embed *w)
1125 CODE:
1126 STOP (embed, w);
1127
1128void DESTROY (ev_embed *w)
1129 CODE:
1130 STOP (embed, w);
1131 e_destroy (w);
1132
1133void set (ev_embed *w, struct ev_loop *loop)
1134 CODE:
1135{
1136 sv_setsv (w->fh, ST (1));
1137 RESET (embed, w, (w, loop));
1138}
1139
1140SV *other (ev_embed *w)
1141 CODE:
1142 RETVAL = newSVsv (w->fh);
1143 OUTPUT:
1144 RETVAL
1145
1146MODULE = EV PACKAGE = EV::Loop PREFIX = ev_
1147
1148SV *new (SV *klass, unsigned int flags = 0)
1149 CODE:
1150{
1151 struct ev_loop *loop = ev_loop_new (flags);
1152
1153 if (!loop)
1154 XSRETURN_UNDEF;
1155
1156 RETVAL = sv_bless (newRV_noinc (newSViv (PTR2IV (loop))), stash_loop);
1157}
1158 OUTPUT:
1159 RETVAL
1160
1161void DESTROY (struct ev_loop *loop)
1162 CODE:
1163 if (loop != evapi.default_loop) /* global destruction sucks */
1164 ev_loop_destroy (loop);
1165
1166void ev_loop_fork (struct ev_loop *loop)
1167
1168NV ev_now (struct ev_loop *loop)
1169
1170void ev_set_io_collect_interval (struct ev_loop *loop, NV interval)
1171
1172void ev_set_timeout_collect_interval (struct ev_loop *loop, NV interval)
1173
1174unsigned int ev_backend (struct ev_loop *loop)
1175
1176unsigned int ev_loop_count (struct ev_loop *loop)
1177
1178void ev_loop (struct ev_loop *loop, int flags = 0)
1179
1180void ev_unloop (struct ev_loop *loop, int how = 1)
1181
1182void ev_feed_fd_event (struct ev_loop *loop, int fd, int revents = EV_NONE)
1183
1001#if 0 1184#if 0
1002 1185
1003MODULE = EV PACKAGE = EV::HTTP PREFIX = evhttp_ 1186void ev_feed_signal_event (struct ev_loop *loop, SV *signal)
1004 1187 CODE:
1005BOOT:
1006{ 1188{
1007 HV *stash = gv_stashpv ("EV::HTTP", 1); 1189 Signal signum = sv_signum (signal);
1190 CHECK_SIG (signal, signum);
1008 1191
1009 static const struct { 1192 ev_feed_signal_event (loop, signum);
1010 const char *name;
1011 IV iv;
1012 } *civ, const_iv[] = {
1013# define const_iv(pfx, name) { # name, (IV) pfx ## name },
1014 const_iv (HTTP_, OK)
1015 const_iv (HTTP_, NOCONTENT)
1016 const_iv (HTTP_, MOVEPERM)
1017 const_iv (HTTP_, MOVETEMP)
1018 const_iv (HTTP_, NOTMODIFIED)
1019 const_iv (HTTP_, BADREQUEST)
1020 const_iv (HTTP_, NOTFOUND)
1021 const_iv (HTTP_, SERVUNAVAIL)
1022 const_iv (EVHTTP_, REQ_OWN_CONNECTION)
1023 const_iv (EVHTTP_, PROXY_REQUEST)
1024 const_iv (EVHTTP_, REQ_GET)
1025 const_iv (EVHTTP_, REQ_POST)
1026 const_iv (EVHTTP_, REQ_HEAD)
1027 const_iv (EVHTTP_, REQUEST)
1028 const_iv (EVHTTP_, RESPONSE)
1029 };
1030
1031 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1032 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
1033} 1193}
1034
1035MODULE = EV PACKAGE = EV::HTTP::Request PREFIX = evhttp_request_
1036
1037#HttpRequest new (SV *klass, SV *cb)
1038
1039#void DESTROY (struct evhttp_request *req);
1040 1194
1041#endif 1195#endif
1042 1196
1197ev_io *io (struct ev_loop *loop, SV *fh, int events, SV *cb)
1198 ALIAS:
1199 io_ns = 1
1200 CODE:
1201{
1202 int fd = sv_fileno (fh);
1203 CHECK_FD (fh, fd);
1043 1204
1205 RETVAL = e_new (sizeof (ev_io), cb, ST (0));
1206 RETVAL->fh = newSVsv (fh);
1207 ev_io_set (RETVAL, fd, events);
1208 if (!ix) START (io, RETVAL);
1209}
1210 OUTPUT:
1211 RETVAL
1044 1212
1213ev_timer *timer (struct ev_loop *loop, NV after, NV repeat, SV *cb)
1214 ALIAS:
1215 timer_ns = 1
1216 INIT:
1217 CHECK_REPEAT (repeat);
1218 CODE:
1219 RETVAL = e_new (sizeof (ev_timer), cb, ST (0));
1220 ev_timer_set (RETVAL, after, repeat);
1221 if (!ix) START (timer, RETVAL);
1222 OUTPUT:
1223 RETVAL
1045 1224
1225SV *periodic (struct ev_loop *loop, NV at, NV interval, SV *reschedule_cb, SV *cb)
1226 ALIAS:
1227 periodic_ns = 1
1228 INIT:
1229 CHECK_REPEAT (interval);
1230 CODE:
1231{
1232 ev_periodic *w;
1233 w = e_new (sizeof (ev_periodic), cb, ST (0));
1234 w->fh = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0;
1235 ev_periodic_set (w, at, interval, w->fh ? e_periodic_cb : 0);
1236 RETVAL = e_bless ((ev_watcher *)w, stash_periodic);
1237 if (!ix) START (periodic, w);
1238}
1239 OUTPUT:
1240 RETVAL
1046 1241
1242#if 0
1047 1243
1244ev_signal *signal (struct ev_loop *loop, SV *signal, SV *cb)
1245 ALIAS:
1246 signal_ns = 1
1247 CODE:
1248{
1249 Signal signum = sv_signum (signal);
1250 CHECK_SIG (signal, signum);
1048 1251
1252 RETVAL = e_new (sizeof (ev_signal), cb, ST (0));
1253 ev_signal_set (RETVAL, signum);
1254 if (!ix) START (signal, RETVAL);
1255}
1256 OUTPUT:
1257 RETVAL
1049 1258
1259#endif
1260
1261ev_idle *idle (struct ev_loop *loop, SV *cb)
1262 ALIAS:
1263 idle_ns = 1
1264 CODE:
1265 RETVAL = e_new (sizeof (ev_idle), cb, ST (0));
1266 ev_idle_set (RETVAL);
1267 if (!ix) START (idle, RETVAL);
1268 OUTPUT:
1269 RETVAL
1270
1271ev_prepare *prepare (struct ev_loop *loop, SV *cb)
1272 ALIAS:
1273 prepare_ns = 1
1274 CODE:
1275 RETVAL = e_new (sizeof (ev_prepare), cb, ST (0));
1276 ev_prepare_set (RETVAL);
1277 if (!ix) START (prepare, RETVAL);
1278 OUTPUT:
1279 RETVAL
1280
1281ev_check *check (struct ev_loop *loop, SV *cb)
1282 ALIAS:
1283 check_ns = 1
1284 CODE:
1285 RETVAL = e_new (sizeof (ev_check), cb, ST (0));
1286 ev_check_set (RETVAL);
1287 if (!ix) START (check, RETVAL);
1288 OUTPUT:
1289 RETVAL
1290
1291ev_fork *fork (struct ev_loop *loop, SV *cb)
1292 ALIAS:
1293 fork_ns = 1
1294 CODE:
1295 RETVAL = e_new (sizeof (ev_fork), cb, ST (0));
1296 ev_fork_set (RETVAL);
1297 if (!ix) START (fork, RETVAL);
1298 OUTPUT:
1299 RETVAL
1300
1301ev_child *child (struct ev_loop *loop, int pid, SV *cb)
1302 ALIAS:
1303 child_ns = 1
1304 CODE:
1305 RETVAL = e_new (sizeof (ev_child), cb, ST (0));
1306 ev_child_set (RETVAL, pid);
1307 if (!ix) START (child, RETVAL);
1308 OUTPUT:
1309 RETVAL
1310
1311ev_stat *stat (struct ev_loop *loop, SV *path, NV interval, SV *cb)
1312 ALIAS:
1313 stat_ns = 1
1314 CODE:
1315 RETVAL = e_new (sizeof (ev_stat), cb, ST (0));
1316 RETVAL->fh = newSVsv (path);
1317 ev_stat_set (RETVAL, SvPVbyte_nolen (RETVAL->fh), interval);
1318 if (!ix) START (stat, RETVAL);
1319 OUTPUT:
1320 RETVAL
1321
1322ev_embed *embed (struct ev_loop *loop, struct ev_loop *other, SV *cb = &PL_sv_undef)
1323 ALIAS:
1324 embed_ns = 1
1325 CODE:
1326{
1327 if (!(ev_backend (other) & ev_embeddable_backends ()))
1328 croak ("passed loop is not embeddable via EV::embed,");
1329
1330 RETVAL = e_new (sizeof (ev_embed), cb, ST (0));
1331 RETVAL->fh = newSVsv (ST (1));
1332 ev_embed_set (RETVAL, other);
1333
1334 if (!SvOK (cb)) ev_set_cb (RETVAL, 0);
1335
1336 if (!ix) START (embed, RETVAL);
1337}
1338 OUTPUT:
1339 RETVAL
1340
1341void once (struct ev_loop *loop, SV *fh, int events, SV *timeout, SV *cb)
1342 CODE:
1343 ev_once (
1344 loop,
1345 sv_fileno (fh), events,
1346 SvOK (timeout) ? SvNV (timeout) : -1.,
1347 e_once_cb,
1348 newSVsv (cb)
1349 );
1350

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines