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

Comparing EV/EV.xs (file contents):
Revision 1.92 by root, Thu Dec 20 08:18:54 2007 UTC vs.
Revision 1.93 by root, Thu Dec 20 09:26:40 2007 UTC

… …
23 23
24#ifndef _WIN32 24#ifndef _WIN32
25# include <pthread.h> 25# include <pthread.h>
26#endif 26#endif
27 27
28#define e_loop(w) INT2PTR (struct ev_loop *, SvIVX ((w)->loop))
29
28#define WFLAG_KEEPALIVE 1 30#define WFLAG_KEEPALIVE 1
29 31
30#define UNREF(w) \ 32#define UNREF(w) \
31 if (!((w)->flags & WFLAG_KEEPALIVE) \ 33 if (!((w)->flags & WFLAG_KEEPALIVE) \
32 && !ev_is_active (w)) \ 34 && !ev_is_active (w)) \
33 ev_unref (w->loop); 35 ev_unref (e_loop (w));
34 36
35#define REF(w) \ 37#define REF(w) \
36 if (!((w)->flags & WFLAG_KEEPALIVE) \ 38 if (!((w)->flags & WFLAG_KEEPALIVE) \
37 && ev_is_active (w)) \ 39 && ev_is_active (w)) \
38 ev_ref (w->loop); 40 ev_ref (e_loop (w));
39 41
40#define START(type,w) \ 42#define START(type,w) \
41 do { \ 43 do { \
42 UNREF (w); \ 44 UNREF (w); \
43 ev_ ## type ## _start (w->loop, w); \ 45 ev_ ## type ## _start (e_loop (w), w); \
44 } while (0) 46 } while (0)
45 47
46#define STOP(type,w) \ 48#define STOP(type,w) \
47 do { \ 49 do { \
48 REF (w); \ 50 REF (w); \
49 ev_ ## type ## _stop (w->loop, w); \ 51 ev_ ## type ## _stop (e_loop (w), w); \
50 } while (0) 52 } while (0)
51 53
52#define RESET(type,w,seta) \ 54#define RESET(type,w,seta) \
53 do { \ 55 do { \
54 int active = ev_is_active (w); \ 56 int active = ev_is_active (w); \
… …
57 if (active) START (type, w); \ 59 if (active) START (type, w); \
58 } while (0) 60 } while (0)
59 61
60typedef int Signal; 62typedef int Signal;
61 63
64static SV *default_loop_sv;
65
62static struct EVAPI evapi; 66static struct EVAPI evapi;
63 67
64static HV 68static HV
69 *stash_loop,
65 *stash_watcher, 70 *stash_watcher,
66 *stash_io, 71 *stash_io,
67 *stash_timer, 72 *stash_timer,
68 *stash_periodic, 73 *stash_periodic,
69 *stash_signal, 74 *stash_signal,
… …
121 126
122 return -1; 127 return -1;
123} 128}
124 129
125static void * 130static void *
126e_new (int size, SV *cb_sv) 131e_new (int size, SV *cb_sv, SV *loop)
127{ 132{
128 ev_watcher *w; 133 ev_watcher *w;
129 SV *self = NEWSV (0, size); 134 SV *self = NEWSV (0, size);
130 SvPOK_only (self); 135 SvPOK_only (self);
131 SvCUR_set (self, size); 136 SvCUR_set (self, size);
132 137
133 w = (ev_watcher *)SvPVX (self); 138 w = (ev_watcher *)SvPVX (self);
134 139
135 ev_init (w, e_cb); 140 ev_init (w, e_cb);
136 141
137 w->loop = EV_DEFAULT; 142 w->loop = SvREFCNT_inc (SvRV (loop));
138 w->flags = WFLAG_KEEPALIVE; 143 w->flags = WFLAG_KEEPALIVE;
139 w->data = 0; 144 w->data = 0;
140 w->fh = 0; 145 w->fh = 0;
141 w->cb_sv = newSVsv (cb_sv); 146 w->cb_sv = SvTEMP (cb_sv) && SvREFCNT (cb_sv) == 1 ? SvREFCNT_inc (cb_sv) : newSVsv (cb_sv);
142 w->self = self; 147 w->self = self;
143 148
144 return (void *)w; 149 return (void *)w;
145} 150}
146 151
147static void 152static void
148e_destroy (void *w_) 153e_destroy (void *w_)
149{ 154{
150 ev_watcher *w = (ev_watcher *)w_; 155 ev_watcher *w = (ev_watcher *)w_;
151 156
157 SvREFCNT_dec (w->loop ); w->loop = 0;
152 SvREFCNT_dec (w->fh ); w->fh = 0; 158 SvREFCNT_dec (w->fh ); w->fh = 0;
153 SvREFCNT_dec (w->cb_sv); w->cb_sv = 0; 159 SvREFCNT_dec (w->cb_sv); w->cb_sv = 0;
154 SvREFCNT_dec (w->data ); w->data = 0; 160 SvREFCNT_dec (w->data ); w->data = 0;
155} 161}
156 162
… …
355 }; 361 };
356 362
357 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 363 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
358 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 364 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
359 365
366 stash_loop = gv_stashpv ("EV::Loop" , 1);
360 stash_watcher = gv_stashpv ("EV::Watcher" , 1); 367 stash_watcher = gv_stashpv ("EV::Watcher" , 1);
361 stash_io = gv_stashpv ("EV::IO" , 1); 368 stash_io = gv_stashpv ("EV::IO" , 1);
362 stash_timer = gv_stashpv ("EV::Timer" , 1); 369 stash_timer = gv_stashpv ("EV::Timer" , 1);
363 stash_periodic = gv_stashpv ("EV::Periodic", 1); 370 stash_periodic = gv_stashpv ("EV::Periodic", 1);
364 stash_signal = gv_stashpv ("EV::Signal" , 1); 371 stash_signal = gv_stashpv ("EV::Signal" , 1);
… …
431} 438}
432 439
433SV *ev_default_loop (unsigned int flags = ev_supported_backends ()) 440SV *ev_default_loop (unsigned int flags = ev_supported_backends ())
434 CODE: 441 CODE:
435{ 442{
443 if (!default_loop_sv)
444 {
436 evapi.default_loop = ev_default_loop (flags); 445 evapi.default_loop = ev_default_loop (flags);
446
437 if (!evapi.default_loop) 447 if (!evapi.default_loop)
438 XSRETURN_UNDEF; 448 XSRETURN_UNDEF;
439 449
440 RETVAL = sv_bless (newRV_noinc (newSViv (PTR2IV (ev_default_loop (flags)))), 450 default_loop_sv = sv_bless (newRV_noinc (newSViv (PTR2IV (evapi.default_loop))), stash_loop);
441 gv_stashpv ("EV::Loop::Default", 1)); 451 }
452
453 RETVAL = newSVsv (default_loop_sv);
442} 454}
443 OUTPUT: 455 OUTPUT:
444 RETVAL 456 RETVAL
445 457
446NV ev_time () 458NV ev_time ()
… …
478 CODE: 490 CODE:
479{ 491{
480 int fd = sv_fileno (fh); 492 int fd = sv_fileno (fh);
481 CHECK_FD (fh, fd); 493 CHECK_FD (fh, fd);
482 494
483 RETVAL = e_new (sizeof (ev_io), cb); 495 RETVAL = e_new (sizeof (ev_io), cb, default_loop_sv);
484 RETVAL->fh = newSVsv (fh); 496 RETVAL->fh = newSVsv (fh);
485 ev_io_set (RETVAL, fd, events); 497 ev_io_set (RETVAL, fd, events);
486 if (!ix) START (io, RETVAL); 498 if (!ix) START (io, RETVAL);
487} 499}
488 OUTPUT: 500 OUTPUT:
… …
492 ALIAS: 504 ALIAS:
493 timer_ns = 1 505 timer_ns = 1
494 INIT: 506 INIT:
495 CHECK_REPEAT (repeat); 507 CHECK_REPEAT (repeat);
496 CODE: 508 CODE:
497 RETVAL = e_new (sizeof (ev_timer), cb); 509 RETVAL = e_new (sizeof (ev_timer), cb, default_loop_sv);
498 ev_timer_set (RETVAL, after, repeat); 510 ev_timer_set (RETVAL, after, repeat);
499 if (!ix) START (timer, RETVAL); 511 if (!ix) START (timer, RETVAL);
500 OUTPUT: 512 OUTPUT:
501 RETVAL 513 RETVAL
502 514
… …
506 INIT: 518 INIT:
507 CHECK_REPEAT (interval); 519 CHECK_REPEAT (interval);
508 CODE: 520 CODE:
509{ 521{
510 ev_periodic *w; 522 ev_periodic *w;
511 w = e_new (sizeof (ev_periodic), cb); 523 w = e_new (sizeof (ev_periodic), cb, default_loop_sv);
512 w->fh = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0; 524 w->fh = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0;
513 ev_periodic_set (w, at, interval, w->fh ? e_periodic_cb : 0); 525 ev_periodic_set (w, at, interval, w->fh ? e_periodic_cb : 0);
514 RETVAL = e_bless ((ev_watcher *)w, stash_periodic); 526 RETVAL = e_bless ((ev_watcher *)w, stash_periodic);
515 if (!ix) START (periodic, w); 527 if (!ix) START (periodic, w);
516} 528}
… …
523 CODE: 535 CODE:
524{ 536{
525 Signal signum = sv_signum (signal); 537 Signal signum = sv_signum (signal);
526 CHECK_SIG (signal, signum); 538 CHECK_SIG (signal, signum);
527 539
528 RETVAL = e_new (sizeof (ev_signal), cb); 540 RETVAL = e_new (sizeof (ev_signal), cb, default_loop_sv);
529 ev_signal_set (RETVAL, signum); 541 ev_signal_set (RETVAL, signum);
530 if (!ix) START (signal, RETVAL); 542 if (!ix) START (signal, RETVAL);
531} 543}
532 OUTPUT: 544 OUTPUT:
533 RETVAL 545 RETVAL
534 546
535ev_idle *idle (SV *cb) 547ev_idle *idle (SV *cb)
536 ALIAS: 548 ALIAS:
537 idle_ns = 1 549 idle_ns = 1
538 CODE: 550 CODE:
539 RETVAL = e_new (sizeof (ev_idle), cb); 551 RETVAL = e_new (sizeof (ev_idle), cb, default_loop_sv);
540 ev_idle_set (RETVAL); 552 ev_idle_set (RETVAL);
541 if (!ix) START (idle, RETVAL); 553 if (!ix) START (idle, RETVAL);
542 OUTPUT: 554 OUTPUT:
543 RETVAL 555 RETVAL
544 556
545ev_prepare *prepare (SV *cb) 557ev_prepare *prepare (SV *cb)
546 ALIAS: 558 ALIAS:
547 prepare_ns = 1 559 prepare_ns = 1
548 CODE: 560 CODE:
549 RETVAL = e_new (sizeof (ev_prepare), cb); 561 RETVAL = e_new (sizeof (ev_prepare), cb, default_loop_sv);
550 ev_prepare_set (RETVAL); 562 ev_prepare_set (RETVAL);
551 if (!ix) START (prepare, RETVAL); 563 if (!ix) START (prepare, RETVAL);
552 OUTPUT: 564 OUTPUT:
553 RETVAL 565 RETVAL
554 566
555ev_check *check (SV *cb) 567ev_check *check (SV *cb)
556 ALIAS: 568 ALIAS:
557 check_ns = 1 569 check_ns = 1
558 CODE: 570 CODE:
559 RETVAL = e_new (sizeof (ev_check), cb); 571 RETVAL = e_new (sizeof (ev_check), cb, default_loop_sv);
560 ev_check_set (RETVAL); 572 ev_check_set (RETVAL);
561 if (!ix) START (check, RETVAL); 573 if (!ix) START (check, RETVAL);
562 OUTPUT: 574 OUTPUT:
563 RETVAL 575 RETVAL
564 576
565ev_fork *fork (SV *cb) 577ev_fork *fork (SV *cb)
566 ALIAS: 578 ALIAS:
567 fork_ns = 1 579 fork_ns = 1
568 CODE: 580 CODE:
569 RETVAL = e_new (sizeof (ev_fork), cb); 581 RETVAL = e_new (sizeof (ev_fork), cb, default_loop_sv);
570 ev_fork_set (RETVAL); 582 ev_fork_set (RETVAL);
571 if (!ix) START (fork, RETVAL); 583 if (!ix) START (fork, RETVAL);
572 OUTPUT: 584 OUTPUT:
573 RETVAL 585 RETVAL
574 586
575ev_child *child (int pid, SV *cb) 587ev_child *child (int pid, SV *cb)
576 ALIAS: 588 ALIAS:
577 child_ns = 1 589 child_ns = 1
578 CODE: 590 CODE:
579 RETVAL = e_new (sizeof (ev_child), cb); 591 RETVAL = e_new (sizeof (ev_child), cb, default_loop_sv);
580 ev_child_set (RETVAL, pid); 592 ev_child_set (RETVAL, pid);
581 if (!ix) START (child, RETVAL); 593 if (!ix) START (child, RETVAL);
582 OUTPUT: 594 OUTPUT:
583 RETVAL 595 RETVAL
584 596
585ev_stat *stat (SV *path, NV interval, SV *cb) 597ev_stat *stat (SV *path, NV interval, SV *cb)
586 ALIAS: 598 ALIAS:
587 stat_ns = 1 599 stat_ns = 1
588 CODE: 600 CODE:
589 RETVAL = e_new (sizeof (ev_stat), cb); 601 RETVAL = e_new (sizeof (ev_stat), cb, default_loop_sv);
590 RETVAL->fh = newSVsv (path); 602 RETVAL->fh = newSVsv (path);
591 ev_stat_set (RETVAL, SvPVbyte_nolen (RETVAL->fh), interval); 603 ev_stat_set (RETVAL, SvPVbyte_nolen (RETVAL->fh), interval);
592 if (!ix) START (stat, RETVAL); 604 if (!ix) START (stat, RETVAL);
605 OUTPUT:
606 RETVAL
607
608ev_embed *embed (struct ev_loop *loop, SV *cb)
609 ALIAS:
610 embed_ns = 1
611 CODE:
612 RETVAL = e_new (sizeof (ev_embed), cb, default_loop_sv);
613 RETVAL->fh = newSVsv (ST (0));
614 ev_embed_set (RETVAL, loop);
615 if (!ix) START (embed, RETVAL);
593 OUTPUT: 616 OUTPUT:
594 RETVAL 617 RETVAL
595 618
596void once (SV *fh, int events, SV *timeout, SV *cb) 619void once (SV *fh, int events, SV *timeout, SV *cb)
597 CODE: 620 CODE:
… …
610int ev_is_active (ev_watcher *w) 633int ev_is_active (ev_watcher *w)
611 634
612int ev_is_pending (ev_watcher *w) 635int ev_is_pending (ev_watcher *w)
613 636
614void ev_invoke (ev_watcher *w, int revents = EV_NONE) 637void ev_invoke (ev_watcher *w, int revents = EV_NONE)
615 C_ARGS: w->loop, w, revents 638 C_ARGS: e_loop (w), w, revents
616 639
617int ev_clear_pending (ev_watcher *w) 640int ev_clear_pending (ev_watcher *w)
618 C_ARGS: w->loop, w 641 C_ARGS: e_loop (w), w
619 642
620void ev_feed_event (ev_watcher *w, int revents = EV_NONE) 643void ev_feed_event (ev_watcher *w, int revents = EV_NONE)
621 C_ARGS: w->loop, w, revents 644 C_ARGS: e_loop (w), w, revents
622 645
623int keepalive (ev_watcher *w, int new_value = 0) 646int keepalive (ev_watcher *w, int new_value = 0)
624 CODE: 647 CODE:
625{ 648{
626 RETVAL = w->flags & WFLAG_KEEPALIVE; 649 RETVAL = w->flags & WFLAG_KEEPALIVE;
… …
803void ev_timer_again (ev_timer *w) 826void ev_timer_again (ev_timer *w)
804 INIT: 827 INIT:
805 CHECK_REPEAT (w->repeat); 828 CHECK_REPEAT (w->repeat);
806 CODE: 829 CODE:
807 REF (w); 830 REF (w);
808 ev_timer_again (w->loop, w); 831 ev_timer_again (e_loop (w), w);
809 UNREF (w); 832 UNREF (w);
810 833
811void DESTROY (ev_timer *w) 834void DESTROY (ev_timer *w)
812 CODE: 835 CODE:
813 STOP (timer, w); 836 STOP (timer, w);
… …
838 STOP (periodic, w); 861 STOP (periodic, w);
839 862
840void ev_periodic_again (ev_periodic *w) 863void ev_periodic_again (ev_periodic *w)
841 CODE: 864 CODE:
842 REF (w); 865 REF (w);
843 ev_periodic_again (w->loop, w); 866 ev_periodic_again (e_loop (w), w);
844 UNREF (w); 867 UNREF (w);
845 868
846void DESTROY (ev_periodic *w) 869void DESTROY (ev_periodic *w)
847 CODE: 870 CODE:
848 STOP (periodic, w); 871 STOP (periodic, w);
… …
1019 PPCODE: 1042 PPCODE:
1020{ 1043{
1021 ev_statdata *s = ix ? &w->attr : &w->prev; 1044 ev_statdata *s = ix ? &w->attr : &w->prev;
1022 1045
1023 if (ix == 1) 1046 if (ix == 1)
1024 ev_stat_stat (w->loop, w); 1047 ev_stat_stat (e_loop (w), w);
1025 else if (!s->st_nlink) 1048 else if (!s->st_nlink)
1026 errno = ENOENT; 1049 errno = ENOENT;
1027 1050
1028 PL_statcache.st_dev = s->st_nlink; 1051 PL_statcache.st_dev = s->st_nlink;
1029 PL_statcache.st_ino = s->st_ino; 1052 PL_statcache.st_ino = s->st_ino;
… …
1056 PUSHs (sv_2mortal (newSVuv (4096))); 1079 PUSHs (sv_2mortal (newSVuv (4096)));
1057 PUSHs (sv_2mortal (newSVnv ((NV)((s->st_size + 4095) / 4096)))); 1080 PUSHs (sv_2mortal (newSVnv ((NV)((s->st_size + 4095) / 4096))));
1058 } 1081 }
1059} 1082}
1060 1083
1061#if 0 1084MODULE = EV PACKAGE = EV::Embed PREFIX = ev_embed_
1062 1085
1086void ev_embed_start (ev_embed *w)
1087 CODE:
1088 START (embed, w);
1089
1090void ev_embed_stop (ev_embed *w)
1091 CODE:
1092 STOP (embed, w);
1093
1094void DESTROY (ev_embed *w)
1095 CODE:
1096 STOP (embed, w);
1097 e_destroy (w);
1098
1099void set (ev_embed *w, struct ev_loop *loop)
1100 CODE:
1101{
1102 sv_setsv (w->fh, ST (1));
1103 RESET (embed, w, (w, loop));
1104}
1105
1063MODULE = EV PACKAGE = EV::HTTP PREFIX = evhttp_ 1106MODULE = EV PACKAGE = EV::Loop PREFIX = ev_loop_
1064 1107
1065BOOT: 1108SV *new (SV *klass, unsigned int flags = ev_supported_backends ())
1109 CODE:
1066{ 1110{
1067 HV *stash = gv_stashpv ("EV::HTTP", 1); 1111 struct ev_loop *loop = ev_loop_new (flags);
1068 1112
1069 static const struct { 1113 if (!loop)
1070 const char *name; 1114 XSRETURN_UNDEF;
1071 IV iv;
1072 } *civ, const_iv[] = {
1073# define const_iv(pfx, name) { # name, (IV) pfx ## name },
1074 const_iv (HTTP_, OK)
1075 const_iv (HTTP_, NOCONTENT)
1076 const_iv (HTTP_, MOVEPERM)
1077 const_iv (HTTP_, MOVETEMP)
1078 const_iv (HTTP_, NOTMODIFIED)
1079 const_iv (HTTP_, BADREQUEST)
1080 const_iv (HTTP_, NOTFOUND)
1081 const_iv (HTTP_, SERVUNAVAIL)
1082 const_iv (EVHTTP_, REQ_OWN_CONNECTION)
1083 const_iv (EVHTTP_, PROXY_REQUEST)
1084 const_iv (EVHTTP_, REQ_GET)
1085 const_iv (EVHTTP_, REQ_POST)
1086 const_iv (EVHTTP_, REQ_HEAD)
1087 const_iv (EVHTTP_, REQUEST)
1088 const_iv (EVHTTP_, RESPONSE)
1089 };
1090 1115
1091 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 1116 RETVAL = sv_bless (newRV_noinc (newSViv (PTR2IV (evapi.default_loop))), stash_loop);
1092 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
1093} 1117}
1118 OUTPUT:
1119 RETVAL
1094 1120
1095MODULE = EV PACKAGE = EV::HTTP::Request PREFIX = evhttp_request_ 1121void DESTROY (struct ev_loop *loop)
1122 CODE:
1123 if (loop != evapi.default_loop) /* global destruction sucks */
1124 ev_loop_destroy (loop);
1096 1125
1097#HttpRequest new (SV *klass, SV *cb)
1098
1099#void DESTROY (struct evhttp_request *req);
1100
1101#endif
1102
1103
1104
1105
1106
1107
1108
1109

Diff Legend

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