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

Comparing EV/EV.xs (file contents):
Revision 1.80 by root, Tue Nov 27 07:27:10 2007 UTC vs.
Revision 1.115 by root, Mon Sep 8 17:27:42 2008 UTC

2#include "perl.h" 2#include "perl.h"
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
8#include "EV/EVAPI.h"
9
10/* fix perl api breakage */ 7/* fix perl api breakage */
11#undef signal 8#undef signal
12#undef sigaction 9#undef sigaction
10
11#define EV_PROTOTYPES 1
12#define EV_USE_NANOSLEEP EV_USE_MONOTONIC
13#define EV_H <ev.h>
14#include "EV/EVAPI.h"
13 15
14#define EV_SELECT_IS_WINSOCKET 0 16#define EV_SELECT_IS_WINSOCKET 0
15#ifdef _WIN32 17#ifdef _WIN32
16# define EV_SELECT_USE_FD_SET 0 18# define EV_SELECT_USE_FD_SET 0
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#ifndef _WIN32
25#define DNS_USE_GETTIMEOFDAY_FOR_ID 1
26#if !defined (WIN32) && !defined(__CYGWIN__)
27# define HAVE_STRUCT_IN6_ADDR 1
28#endif
29#undef HAVE_STRTOK_R
30#undef strtok_r
31#define strtok_r fake_strtok_r
32#include "evdns.h"
33#include "evdns.c"
34#endif
35 24
36#ifndef _WIN32 25#ifndef _WIN32
37# include <pthread.h> 26# include <pthread.h>
38#endif 27#endif
39 28
29#define e_loop(w) INT2PTR (struct ev_loop *, SvIVX ((w)->loop))
30
40#define WFLAG_KEEPALIVE 1 31#define WFLAG_KEEPALIVE 1
41 32
42#define UNREF(w) \ 33#define UNREF(w) \
43 if (!((w)->flags & WFLAG_KEEPALIVE) \ 34 if (!((w)->e_flags & WFLAG_KEEPALIVE) \
44 && !ev_is_active (w)) \ 35 && !ev_is_active (w)) \
45 ev_unref (); 36 ev_unref (e_loop (w));
46 37
47#define REF(w) \ 38#define REF(w) \
48 if (!((w)->flags & WFLAG_KEEPALIVE) \ 39 if (!((w)->e_flags & WFLAG_KEEPALIVE) \
49 && ev_is_active (w)) \ 40 && ev_is_active (w)) \
50 ev_ref (); 41 ev_ref (e_loop (w));
51 42
52#define START(type,w) \ 43#define START(type,w) \
53 do { \ 44 do { \
54 UNREF (w); \ 45 UNREF (w); \
55 ev_ ## type ## _start (w); \ 46 ev_ ## type ## _start (e_loop (w), w); \
56 } while (0) 47 } while (0)
57 48
58#define STOP(type,w) \ 49#define STOP(type,w) \
59 do { \ 50 do { \
60 REF (w); \ 51 REF (w); \
61 ev_ ## type ## _stop (w); \ 52 ev_ ## type ## _stop (e_loop (w), w); \
62 } while (0) 53 } while (0)
63 54
64#define RESET(type,w,seta) \ 55#define RESET(type,w,seta) \
65 do { \ 56 do { \
66 int active = ev_is_active (w); \ 57 int active = ev_is_active (w); \
69 if (active) START (type, w); \ 60 if (active) START (type, w); \
70 } while (0) 61 } while (0)
71 62
72typedef int Signal; 63typedef int Signal;
73 64
65static SV *default_loop_sv;
66
74static struct EVAPI evapi; 67static struct EVAPI evapi;
75 68
76static HV 69static HV
70 *stash_loop,
77 *stash_watcher, 71 *stash_watcher,
78 *stash_io, 72 *stash_io,
79 *stash_timer, 73 *stash_timer,
80 *stash_periodic, 74 *stash_periodic,
81 *stash_signal, 75 *stash_signal,
76 *stash_child,
77 *stash_stat,
82 *stash_idle, 78 *stash_idle,
83 *stash_prepare, 79 *stash_prepare,
84 *stash_check, 80 *stash_check,
85 *stash_child,
86 *stash_embed, 81 *stash_embed,
82 *stash_fork,
87 *stash_stat; 83 *stash_async;
88 84
89#ifndef SIG_SIZE 85#ifndef SIG_SIZE
90/* kudos to Slaven Rezic for the idea */ 86/* kudos to Slaven Rezic for the idea */
91static char sig_size [] = { SIG_NUM }; 87static char sig_size [] = { SIG_NUM };
92# define SIG_SIZE (sizeof (sig_size) + 1) 88# define SIG_SIZE (sizeof (sig_size) + 1)
112} 108}
113 109
114///////////////////////////////////////////////////////////////////////////// 110/////////////////////////////////////////////////////////////////////////////
115// Event 111// Event
116 112
117static void e_cb (ev_watcher *w, int revents); 113static void e_cb (EV_P_ ev_watcher *w, int revents);
118 114
119static int 115static int
120sv_fileno (SV *fh) 116sv_fileno (SV *fh)
121{ 117{
122 SvGETMAGIC (fh); 118 SvGETMAGIC (fh);
131 return SvIV (fh); 127 return SvIV (fh);
132 128
133 return -1; 129 return -1;
134} 130}
135 131
132static SV *
133e_get_cv (SV *cb_sv)
134{
135 HV *st;
136 GV *gvp;
137 CV *cv = sv_2cv (cb_sv, &st, &gvp, 0);
138
139 if (!cv)
140 croak ("EV watcher callback must be a CODE reference");
141
142 return (SV *)cv;
143}
144
136static void * 145static void *
137e_new (int size, SV *cb_sv) 146e_new (int size, SV *cb_sv, SV *loop)
138{ 147{
148 SV *cv = cb_sv ? e_get_cv (cb_sv) : 0;
139 ev_watcher *w; 149 ev_watcher *w;
140 SV *self = NEWSV (0, size); 150 SV *self = NEWSV (0, size);
141 SvPOK_only (self); 151 SvPOK_only (self);
142 SvCUR_set (self, size); 152 SvCUR_set (self, size);
143 153
144 w = (ev_watcher *)SvPVX (self); 154 w = (ev_watcher *)SvPVX (self);
145 155
146 ev_init (w, e_cb); 156 ev_init (w, cv ? e_cb : 0);
147 157
158 w->loop = SvREFCNT_inc (SvRV (loop));
148 w->flags = WFLAG_KEEPALIVE; 159 w->e_flags = WFLAG_KEEPALIVE;
149 w->data = 0; 160 w->data = 0;
150 w->fh = 0; 161 w->fh = 0;
151 w->cb_sv = newSVsv (cb_sv); 162 w->cb_sv = SvREFCNT_inc (cv);
152 w->self = self; 163 w->self = self;
153 164
154 return (void *)w; 165 return (void *)w;
155} 166}
156 167
157static void 168static void
158e_destroy (void *w_) 169e_destroy (void *w_)
159{ 170{
160 ev_watcher *w = (ev_watcher *)w_; 171 ev_watcher *w = (ev_watcher *)w_;
161 172
173 SvREFCNT_dec (w->loop ); w->loop = 0;
162 SvREFCNT_dec (w->fh ); w->fh = 0; 174 SvREFCNT_dec (w->fh ); w->fh = 0;
163 SvREFCNT_dec (w->cb_sv); w->cb_sv = 0; 175 SvREFCNT_dec (w->cb_sv); w->cb_sv = 0;
164 SvREFCNT_dec (w->data ); w->data = 0; 176 SvREFCNT_dec (w->data ); w->data = 0;
165} 177}
166 178
182} 194}
183 195
184static SV *sv_events_cache; 196static SV *sv_events_cache;
185 197
186static void 198static void
187e_cb (ev_watcher *w, int revents) 199e_cb (EV_P_ ev_watcher *w, int revents)
188{ 200{
189 dSP; 201 dSP;
190 I32 mark = SP - PL_stack_base; 202 I32 mark = SP - PL_stack_base;
191 SV *sv_self, *sv_events; 203 SV *sv_self, *sv_events;
192 204
215 else 227 else
216 sv_events_cache = sv_events; 228 sv_events_cache = sv_events;
217 229
218 if (SvTRUE (ERRSV)) 230 if (SvTRUE (ERRSV))
219 { 231 {
232 SPAGAIN;
220 PUSHMARK (SP); 233 PUSHMARK (SP);
221 PUTBACK; 234 PUTBACK;
222 call_sv (get_sv ("EV::DIED", 1), G_DISCARD | G_VOID | G_EVAL | G_KEEPERR); 235 call_sv (get_sv ("EV::DIED", 1), G_DISCARD | G_VOID | G_EVAL | G_KEEPERR);
223 } 236 }
224 237
254 else 267 else
255 sv_events_cache = sv_events; 268 sv_events_cache = sv_events;
256 269
257 if (SvTRUE (ERRSV)) 270 if (SvTRUE (ERRSV))
258 { 271 {
272 SPAGAIN;
259 PUSHMARK (SP); 273 PUSHMARK (SP);
260 PUTBACK; 274 PUTBACK;
261 call_sv (get_sv ("EV::DIED", 1), G_DISCARD | G_VOID | G_EVAL | G_KEEPERR); 275 call_sv (get_sv ("EV::DIED", 1), G_DISCARD | G_VOID | G_EVAL | G_KEEPERR);
262 } 276 }
263 277
305 FREETMPS; 319 FREETMPS;
306 LEAVE; 320 LEAVE;
307 321
308 return retval; 322 return retval;
309} 323}
310
311/////////////////////////////////////////////////////////////////////////////
312// DNS
313
314#ifndef _WIN32
315static void
316dns_cb (int result, char type, int count, int ttl, void *addresses, void *arg)
317{
318 dSP;
319 SV *cb = (SV *)arg;
320
321 ENTER;
322 SAVETMPS;
323 PUSHMARK (SP);
324 EXTEND (SP, count + 3);
325 PUSHs (sv_2mortal (newSViv (result)));
326
327 if (result == DNS_ERR_NONE && ttl >= 0)
328 {
329 int i;
330
331 PUSHs (sv_2mortal (newSViv (type)));
332 PUSHs (sv_2mortal (newSViv (ttl)));
333
334 for (i = 0; i < count; ++i)
335 switch (type)
336 {
337 case DNS_IPv6_AAAA:
338 PUSHs (sv_2mortal (newSVpvn (i * 16 + (char *)addresses, 16)));
339 break;
340 case DNS_IPv4_A:
341 PUSHs (sv_2mortal (newSVpvn (i * 4 + (char *)addresses, 4)));
342 break;
343 case DNS_PTR:
344 PUSHs (sv_2mortal (newSVpv (*(char **)addresses, 0)));
345 break;
346 }
347 }
348
349 PUTBACK;
350 call_sv (sv_2mortal (cb), G_DISCARD | G_VOID | G_EVAL);
351
352 FREETMPS;
353
354 if (SvTRUE (ERRSV))
355 {
356 PUSHMARK (SP);
357 PUTBACK;
358 call_sv (get_sv ("EV::DIED", 1), G_DISCARD | G_VOID | G_EVAL | G_KEEPERR);
359 }
360
361 LEAVE;
362}
363#endif
364 324
365#define CHECK_REPEAT(repeat) if (repeat < 0.) \ 325#define CHECK_REPEAT(repeat) if (repeat < 0.) \
366 croak (# repeat " value must be >= 0"); 326 croak (# repeat " value must be >= 0");
367 327
368#define CHECK_FD(fh,fd) if ((fd) < 0) \ 328#define CHECK_FD(fh,fd) if ((fd) < 0) \
411 const_iv (EV, BACKEND_KQUEUE) 371 const_iv (EV, BACKEND_KQUEUE)
412 const_iv (EV, BACKEND_DEVPOLL) 372 const_iv (EV, BACKEND_DEVPOLL)
413 const_iv (EV, BACKEND_PORT) 373 const_iv (EV, BACKEND_PORT)
414 const_iv (EV, FLAG_AUTO) 374 const_iv (EV, FLAG_AUTO)
415 const_iv (EV, FLAG_NOENV) 375 const_iv (EV, FLAG_NOENV)
376 const_iv (EV, FLAG_FORKCHECK)
416 }; 377 };
417 378
418 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 379 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
419 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 380 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
420 381
382 stash_loop = gv_stashpv ("EV::Loop" , 1);
421 stash_watcher = gv_stashpv ("EV::Watcher" , 1); 383 stash_watcher = gv_stashpv ("EV::Watcher" , 1);
422 stash_io = gv_stashpv ("EV::IO" , 1); 384 stash_io = gv_stashpv ("EV::IO" , 1);
423 stash_timer = gv_stashpv ("EV::Timer" , 1); 385 stash_timer = gv_stashpv ("EV::Timer" , 1);
424 stash_periodic = gv_stashpv ("EV::Periodic", 1); 386 stash_periodic = gv_stashpv ("EV::Periodic", 1);
425 stash_signal = gv_stashpv ("EV::Signal" , 1); 387 stash_signal = gv_stashpv ("EV::Signal" , 1);
427 stash_prepare = gv_stashpv ("EV::Prepare" , 1); 389 stash_prepare = gv_stashpv ("EV::Prepare" , 1);
428 stash_check = gv_stashpv ("EV::Check" , 1); 390 stash_check = gv_stashpv ("EV::Check" , 1);
429 stash_child = gv_stashpv ("EV::Child" , 1); 391 stash_child = gv_stashpv ("EV::Child" , 1);
430 stash_embed = gv_stashpv ("EV::Embed" , 1); 392 stash_embed = gv_stashpv ("EV::Embed" , 1);
431 stash_stat = gv_stashpv ("EV::Stat" , 1); 393 stash_stat = gv_stashpv ("EV::Stat" , 1);
394 stash_fork = gv_stashpv ("EV::Fork" , 1);
395 stash_async = gv_stashpv ("EV::Async" , 1);
432 396
433 { 397 {
434 SV *sv = perl_get_sv ("EV::API", TRUE); 398 SV *sv = perl_get_sv ("EV::API", TRUE);
435 perl_get_sv ("EV::API", TRUE); /* silence 5.10 warning */ 399 perl_get_sv ("EV::API", TRUE); /* silence 5.10 warning */
436 400
437 /* the poor man's shared library emulator */ 401 /* the poor man's shared library emulator */
438 evapi.ver = EV_API_VERSION; 402 evapi.ver = EV_API_VERSION;
439 evapi.rev = EV_API_REVISION; 403 evapi.rev = EV_API_REVISION;
440 evapi.sv_fileno = sv_fileno; 404 evapi.sv_fileno = sv_fileno;
441 evapi.sv_signum = sv_signum; 405 evapi.sv_signum = sv_signum;
406 evapi.supported_backends = ev_supported_backends ();
407 evapi.recommended_backends = ev_recommended_backends ();
408 evapi.embeddable_backends = ev_embeddable_backends ();
409 evapi.time_ = ev_time;
410 evapi.sleep_ = ev_sleep;
411 evapi.loop_new = ev_loop_new;
412 evapi.loop_destroy = ev_loop_destroy;
413 evapi.loop_fork = ev_loop_fork;
414 evapi.loop_count = ev_loop_count;
442 evapi.now = ev_now; 415 evapi.now = ev_now;
416 evapi.now_update = ev_now_update;
443 evapi.backend = ev_backend; 417 evapi.backend = ev_backend;
444 evapi.unloop = ev_unloop; 418 evapi.unloop = ev_unloop;
445 evapi.ref = ev_ref; 419 evapi.ref = ev_ref;
446 evapi.unref = ev_unref; 420 evapi.unref = ev_unref;
447 evapi.time = ev_time;
448 evapi.loop = ev_loop; 421 evapi.loop = ev_loop;
449 evapi.once = ev_once; 422 evapi.once = ev_once;
450 evapi.io_start = ev_io_start; 423 evapi.io_start = ev_io_start;
451 evapi.io_stop = ev_io_stop; 424 evapi.io_stop = ev_io_stop;
452 evapi.timer_start = ev_timer_start; 425 evapi.timer_start = ev_timer_start;
453 evapi.timer_stop = ev_timer_stop; 426 evapi.timer_stop = ev_timer_stop;
454 evapi.timer_again = ev_timer_again; 427 evapi.timer_again = ev_timer_again;
455 evapi.periodic_start = ev_periodic_start; 428 evapi.periodic_start = ev_periodic_start;
456 evapi.periodic_stop = ev_periodic_stop; 429 evapi.periodic_stop = ev_periodic_stop;
457 evapi.signal_start = ev_signal_start; 430 evapi.signal_start = ev_signal_start;
458 evapi.signal_stop = ev_signal_stop; 431 evapi.signal_stop = ev_signal_stop;
459 evapi.idle_start = ev_idle_start; 432 evapi.idle_start = ev_idle_start;
460 evapi.idle_stop = ev_idle_stop; 433 evapi.idle_stop = ev_idle_stop;
461 evapi.prepare_start = ev_prepare_start; 434 evapi.prepare_start = ev_prepare_start;
462 evapi.prepare_stop = ev_prepare_stop; 435 evapi.prepare_stop = ev_prepare_stop;
463 evapi.check_start = ev_check_start; 436 evapi.check_start = ev_check_start;
464 evapi.check_stop = ev_check_stop; 437 evapi.check_stop = ev_check_stop;
465 evapi.child_start = ev_child_start; 438 evapi.child_start = ev_child_start;
466 evapi.child_stop = ev_child_stop; 439 evapi.child_stop = ev_child_stop;
467 evapi.stat_start = ev_stat_start; 440 evapi.stat_start = ev_stat_start;
468 evapi.stat_stop = ev_stat_stop; 441 evapi.stat_stop = ev_stat_stop;
469 evapi.stat_stat = ev_stat_stat; 442 evapi.stat_stat = ev_stat_stat;
443 evapi.embed_start = ev_embed_start;
444 evapi.embed_stop = ev_embed_stop;
445 evapi.embed_sweep = ev_embed_sweep;
446 evapi.fork_start = ev_fork_start;
447 evapi.fork_stop = ev_fork_stop;
448 evapi.async_start = ev_async_start;
449 evapi.async_stop = ev_async_stop;
450 evapi.async_send = ev_async_send;
451 evapi.clear_pending = ev_clear_pending;
452 evapi.invoke = ev_invoke;
470 453
471 sv_setiv (sv, (IV)&evapi); 454 sv_setiv (sv, (IV)&evapi);
472 SvREADONLY_on (sv); 455 SvREADONLY_on (sv);
473 } 456 }
474#ifndef _WIN32 457#ifndef _WIN32
475 pthread_atfork (0, 0, ev_default_fork); 458 pthread_atfork (0, 0, ev_default_fork);
476#endif 459#endif
477} 460}
478 461
462SV *ev_default_loop (unsigned int flags = 0)
463 CODE:
464{
465 if (!default_loop_sv)
466 {
467 evapi.default_loop = ev_default_loop (flags);
468
469 if (!evapi.default_loop)
470 XSRETURN_UNDEF;
471
472 default_loop_sv = sv_bless (newRV_noinc (newSViv (PTR2IV (evapi.default_loop))), stash_loop);
473 }
474
475 RETVAL = newSVsv (default_loop_sv);
476}
477 OUTPUT:
478 RETVAL
479
480void ev_default_destroy ()
481 CODE:
482 ev_default_destroy ();
483 SvREFCNT_dec (default_loop_sv);
484 default_loop_sv = 0;
485
486unsigned int ev_supported_backends ()
487
488unsigned int ev_recommended_backends ()
489
490unsigned int ev_embeddable_backends ()
491
492NV ev_time ()
493
479NV ev_now () 494NV ev_now ()
495 C_ARGS: evapi.default_loop
496
497void ev_now_update ()
498 C_ARGS: evapi.default_loop
480 499
481unsigned int ev_backend () 500unsigned int ev_backend ()
501 C_ARGS: evapi.default_loop
482 502
483NV ev_time () 503unsigned int ev_loop_count ()
504 C_ARGS: evapi.default_loop
484 505
485unsigned int ev_default_loop (unsigned int flags = ev_supported_backends ()) 506void ev_set_io_collect_interval (NV interval)
507 C_ARGS: evapi.default_loop, interval
508
509void ev_set_timeout_collect_interval (NV interval)
510 C_ARGS: evapi.default_loop, interval
486 511
487void ev_loop (int flags = 0) 512void ev_loop (int flags = 0)
513 C_ARGS: evapi.default_loop, flags
488 514
489void ev_unloop (int how = 1) 515void ev_unloop (int how = EVUNLOOP_ONE)
516 C_ARGS: evapi.default_loop, how
517
518void ev_feed_fd_event (int fd, int revents = EV_NONE)
519 C_ARGS: evapi.default_loop, fd, revents
520
521void ev_feed_signal_event (SV *signal)
522 CODE:
523{
524 Signal signum = sv_signum (signal);
525 CHECK_SIG (signal, signum);
526
527 ev_feed_signal_event (evapi.default_loop, signum);
528}
490 529
491ev_io *io (SV *fh, int events, SV *cb) 530ev_io *io (SV *fh, int events, SV *cb)
492 ALIAS: 531 ALIAS:
493 io_ns = 1 532 io_ns = 1
494 CODE: 533 CODE:
495{ 534{
496 int fd = sv_fileno (fh); 535 int fd = sv_fileno (fh);
497 CHECK_FD (fh, fd); 536 CHECK_FD (fh, fd);
498 537
499 RETVAL = e_new (sizeof (ev_io), cb); 538 RETVAL = e_new (sizeof (ev_io), cb, default_loop_sv);
500 RETVAL->fh = newSVsv (fh); 539 RETVAL->fh = newSVsv (fh);
501 ev_io_set (RETVAL, fd, events); 540 ev_io_set (RETVAL, fd, events);
502 if (!ix) START (io, RETVAL); 541 if (!ix) START (io, RETVAL);
503} 542}
504 OUTPUT: 543 OUTPUT:
508 ALIAS: 547 ALIAS:
509 timer_ns = 1 548 timer_ns = 1
510 INIT: 549 INIT:
511 CHECK_REPEAT (repeat); 550 CHECK_REPEAT (repeat);
512 CODE: 551 CODE:
513 RETVAL = e_new (sizeof (ev_timer), cb); 552 RETVAL = e_new (sizeof (ev_timer), cb, default_loop_sv);
514 ev_timer_set (RETVAL, after, repeat); 553 ev_timer_set (RETVAL, after, repeat);
515 if (!ix) START (timer, RETVAL); 554 if (!ix) START (timer, RETVAL);
516 OUTPUT: 555 OUTPUT:
517 RETVAL 556 RETVAL
518 557
522 INIT: 561 INIT:
523 CHECK_REPEAT (interval); 562 CHECK_REPEAT (interval);
524 CODE: 563 CODE:
525{ 564{
526 ev_periodic *w; 565 ev_periodic *w;
527 w = e_new (sizeof (ev_periodic), cb); 566 w = e_new (sizeof (ev_periodic), cb, default_loop_sv);
528 w->fh = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0; 567 w->fh = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0;
529 ev_periodic_set (w, at, interval, w->fh ? e_periodic_cb : 0); 568 ev_periodic_set (w, at, interval, w->fh ? e_periodic_cb : 0);
530 RETVAL = e_bless ((ev_watcher *)w, stash_periodic); 569 RETVAL = e_bless ((ev_watcher *)w, stash_periodic);
531 if (!ix) START (periodic, w); 570 if (!ix) START (periodic, w);
532} 571}
539 CODE: 578 CODE:
540{ 579{
541 Signal signum = sv_signum (signal); 580 Signal signum = sv_signum (signal);
542 CHECK_SIG (signal, signum); 581 CHECK_SIG (signal, signum);
543 582
544 RETVAL = e_new (sizeof (ev_signal), cb); 583 RETVAL = e_new (sizeof (ev_signal), cb, default_loop_sv);
545 ev_signal_set (RETVAL, signum); 584 ev_signal_set (RETVAL, signum);
546 if (!ix) START (signal, RETVAL); 585 if (!ix) START (signal, RETVAL);
547} 586}
548 OUTPUT: 587 OUTPUT:
549 RETVAL 588 RETVAL
550 589
551ev_idle *idle (SV *cb) 590ev_idle *idle (SV *cb)
552 ALIAS: 591 ALIAS:
553 idle_ns = 1 592 idle_ns = 1
554 CODE: 593 CODE:
555 RETVAL = e_new (sizeof (ev_idle), cb); 594 RETVAL = e_new (sizeof (ev_idle), cb, default_loop_sv);
556 ev_idle_set (RETVAL); 595 ev_idle_set (RETVAL);
557 if (!ix) START (idle, RETVAL); 596 if (!ix) START (idle, RETVAL);
558 OUTPUT: 597 OUTPUT:
559 RETVAL 598 RETVAL
560 599
561ev_prepare *prepare (SV *cb) 600ev_prepare *prepare (SV *cb)
562 ALIAS: 601 ALIAS:
563 prepare_ns = 1 602 prepare_ns = 1
564 CODE: 603 CODE:
565 RETVAL = e_new (sizeof (ev_prepare), cb); 604 RETVAL = e_new (sizeof (ev_prepare), cb, default_loop_sv);
566 ev_prepare_set (RETVAL); 605 ev_prepare_set (RETVAL);
567 if (!ix) START (prepare, RETVAL); 606 if (!ix) START (prepare, RETVAL);
568 OUTPUT: 607 OUTPUT:
569 RETVAL 608 RETVAL
570 609
571ev_check *check (SV *cb) 610ev_check *check (SV *cb)
572 ALIAS: 611 ALIAS:
573 check_ns = 1 612 check_ns = 1
574 CODE: 613 CODE:
575 RETVAL = e_new (sizeof (ev_check), cb); 614 RETVAL = e_new (sizeof (ev_check), cb, default_loop_sv);
576 ev_check_set (RETVAL); 615 ev_check_set (RETVAL);
577 if (!ix) START (check, RETVAL); 616 if (!ix) START (check, RETVAL);
578 OUTPUT: 617 OUTPUT:
579 RETVAL 618 RETVAL
580 619
620ev_fork *fork (SV *cb)
621 ALIAS:
622 fork_ns = 1
623 CODE:
624 RETVAL = e_new (sizeof (ev_fork), cb, default_loop_sv);
625 ev_fork_set (RETVAL);
626 if (!ix) START (fork, RETVAL);
627 OUTPUT:
628 RETVAL
629
581ev_child *child (int pid, SV *cb) 630ev_child *child (int pid, int trace, SV *cb)
582 ALIAS: 631 ALIAS:
583 child_ns = 1 632 child_ns = 1
584 CODE: 633 CODE:
585 RETVAL = e_new (sizeof (ev_child), cb); 634 RETVAL = e_new (sizeof (ev_child), cb, default_loop_sv);
586 ev_child_set (RETVAL, pid); 635 ev_child_set (RETVAL, pid, trace);
587 if (!ix) START (child, RETVAL); 636 if (!ix) START (child, RETVAL);
588 OUTPUT: 637 OUTPUT:
589 RETVAL 638 RETVAL
590 639
591ev_stat *stat (SV *path, NV interval, SV *cb) 640ev_stat *stat (SV *path, NV interval, SV *cb)
592 ALIAS: 641 ALIAS:
593 stat_ns = 1 642 stat_ns = 1
594 CODE: 643 CODE:
595 RETVAL = e_new (sizeof (ev_stat), cb); 644 RETVAL = e_new (sizeof (ev_stat), cb, default_loop_sv);
596 RETVAL->fh = newSVsv (path); 645 RETVAL->fh = newSVsv (path);
597 ev_stat_set (RETVAL, SvPVbyte_nolen (RETVAL->fh), interval); 646 ev_stat_set (RETVAL, SvPVbyte_nolen (RETVAL->fh), interval);
598 if (!ix) START (stat, RETVAL); 647 if (!ix) START (stat, RETVAL);
599 OUTPUT: 648 OUTPUT:
600 RETVAL 649 RETVAL
601 650
651ev_embed *embed (struct ev_loop *loop, SV *cb = 0)
652 ALIAS:
653 embed_ns = 1
654 CODE:
655{
656 if (!(ev_backend (loop) & ev_embeddable_backends ()))
657 croak ("passed loop is not embeddable via EV::embed,");
658
659 RETVAL = e_new (sizeof (ev_embed), cb, default_loop_sv);
660 RETVAL->fh = newSVsv (ST (0));
661 ev_embed_set (RETVAL, loop);
662 if (!ix) START (embed, RETVAL);
663}
664 OUTPUT:
665 RETVAL
666
667ev_async *async (SV *cb)
668 ALIAS:
669 async_ns = 1
670 CODE:
671 RETVAL = e_new (sizeof (ev_async), cb, default_loop_sv);
672 ev_async_set (RETVAL);
673 if (!ix) START (async, RETVAL);
674 OUTPUT:
675 RETVAL
676
602void once (SV *fh, int events, SV *timeout, SV *cb) 677void once (SV *fh, int events, SV *timeout, SV *cb)
603 CODE: 678 CODE:
604 ev_once ( 679 ev_once (
680 evapi.default_loop,
605 sv_fileno (fh), events, 681 sv_fileno (fh), events,
606 SvOK (timeout) ? SvNV (timeout) : -1., 682 SvOK (timeout) ? SvNV (timeout) : -1.,
607 e_once_cb, 683 e_once_cb,
608 newSVsv (cb) 684 newSVsv (cb)
609 ); 685 );
614 690
615int ev_is_active (ev_watcher *w) 691int ev_is_active (ev_watcher *w)
616 692
617int ev_is_pending (ev_watcher *w) 693int ev_is_pending (ev_watcher *w)
618 694
695void ev_invoke (ev_watcher *w, int revents = EV_NONE)
696 C_ARGS: e_loop (w), w, revents
697
698int ev_clear_pending (ev_watcher *w)
699 C_ARGS: e_loop (w), w
700
701void ev_feed_event (ev_watcher *w, int revents = EV_NONE)
702 C_ARGS: e_loop (w), w, revents
703
619int keepalive (ev_watcher *w, int new_value = 0) 704int keepalive (ev_watcher *w, int new_value = 0)
620 CODE: 705 CODE:
621{ 706{
622 RETVAL = w->flags & WFLAG_KEEPALIVE; 707 RETVAL = w->e_flags & WFLAG_KEEPALIVE;
623 new_value = new_value ? WFLAG_KEEPALIVE : 0; 708 new_value = new_value ? WFLAG_KEEPALIVE : 0;
624 709
625 if (items > 1 && ((new_value ^ w->flags) & WFLAG_KEEPALIVE)) 710 if (items > 1 && ((new_value ^ w->e_flags) & WFLAG_KEEPALIVE))
626 { 711 {
627 REF (w); 712 REF (w);
628 w->flags = (w->flags & ~WFLAG_KEEPALIVE) | new_value; 713 w->e_flags = (w->e_flags & ~WFLAG_KEEPALIVE) | new_value;
629 UNREF (w); 714 UNREF (w);
630 } 715 }
631} 716}
632 OUTPUT: 717 OUTPUT:
633 RETVAL 718 RETVAL
634 719
635SV *cb (ev_watcher *w, SV *new_cb = 0) 720SV *cb (ev_watcher *w, SV *new_cb = 0)
636 CODE: 721 CODE:
637{ 722{
638 RETVAL = newSVsv (w->cb_sv);
639
640 if (items > 1) 723 if (items > 1)
641 sv_setsv (w->cb_sv, new_cb); 724 {
725 new_cb = e_get_cv (new_cb);
726 RETVAL = newRV_noinc (w->cb_sv);
727 w->cb_sv = SvREFCNT_inc (new_cb);
728 }
729 else
730 RETVAL = newRV_inc (w->cb_sv);
642} 731}
643 OUTPUT: 732 OUTPUT:
644 RETVAL 733 RETVAL
645 734
646SV *data (ev_watcher *w, SV *new_data = 0) 735SV *data (ev_watcher *w, SV *new_data = 0)
655 } 744 }
656} 745}
657 OUTPUT: 746 OUTPUT:
658 RETVAL 747 RETVAL
659 748
660void trigger (ev_watcher *w, int revents = EV_NONE) 749SV *loop (ev_watcher *w)
661 CODE: 750 CODE:
662 w->cb (w, revents); 751 RETVAL = newRV_inc (w->loop);
752 OUTPUT:
753 RETVAL
663 754
664int priority (ev_watcher *w, int new_priority = 0) 755int priority (ev_watcher *w, int new_priority = 0)
665 CODE: 756 CODE:
666{ 757{
667 RETVAL = w->priority; 758 RETVAL = w->priority;
668 759
669 if (items > 1) 760 if (items > 1)
670 { 761 {
671 int active = ev_is_active (w); 762 int active = ev_is_active (w);
672
673 if (new_priority < EV_MINPRI || new_priority > EV_MAXPRI)
674 croak ("watcher priority out of range, value must be between %d and %d, inclusive", EV_MINPRI, EV_MAXPRI);
675 763
676 if (active) 764 if (active)
677 { 765 {
678 /* grrr. */ 766 /* grrr. */
679 PUSHMARK (SP); 767 PUSHMARK (SP);
680 XPUSHs (ST (0)); 768 XPUSHs (ST (0));
769 PUTBACK;
681 call_method ("stop", G_DISCARD | G_VOID); 770 call_method ("stop", G_DISCARD | G_VOID);
682 } 771 }
683 772
684 ev_set_priority (w, new_priority); 773 ev_set_priority (w, new_priority);
685 774
686 if (active) 775 if (active)
687 { 776 {
688 PUSHMARK (SP); 777 PUSHMARK (SP);
689 XPUSHs (ST (0)); 778 XPUSHs (ST (0));
779 PUTBACK;
690 call_method ("start", G_DISCARD | G_VOID); 780 call_method ("start", G_DISCARD | G_VOID);
691 } 781 }
692 } 782 }
693} 783}
694 OUTPUT: 784 OUTPUT:
804void ev_timer_again (ev_timer *w) 894void ev_timer_again (ev_timer *w)
805 INIT: 895 INIT:
806 CHECK_REPEAT (w->repeat); 896 CHECK_REPEAT (w->repeat);
807 CODE: 897 CODE:
808 REF (w); 898 REF (w);
809 ev_timer_again (w); 899 ev_timer_again (e_loop (w), w);
810 UNREF (w); 900 UNREF (w);
811 901
812void DESTROY (ev_timer *w) 902void DESTROY (ev_timer *w)
813 CODE: 903 CODE:
814 STOP (timer, w); 904 STOP (timer, w);
833 STOP (periodic, w); 923 STOP (periodic, w);
834 924
835void ev_periodic_again (ev_periodic *w) 925void ev_periodic_again (ev_periodic *w)
836 CODE: 926 CODE:
837 REF (w); 927 REF (w);
838 ev_periodic_again (w); 928 ev_periodic_again (e_loop (w), w);
839 UNREF (w); 929 UNREF (w);
840 930
841void DESTROY (ev_periodic *w) 931void DESTROY (ev_periodic *w)
842 CODE: 932 CODE:
843 STOP (periodic, w); 933 STOP (periodic, w);
852 w->fh = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0; 942 w->fh = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0;
853 943
854 RESET (periodic, w, (w, at, interval, w->fh ? e_periodic_cb : 0)); 944 RESET (periodic, w, (w, at, interval, w->fh ? e_periodic_cb : 0));
855} 945}
856 946
947NV at (ev_periodic *w)
948 CODE:
949 RETVAL = ev_periodic_at (w);
950 OUTPUT:
951 RETVAL
952
857MODULE = EV PACKAGE = EV::Idle PREFIX = ev_idle_ 953MODULE = EV PACKAGE = EV::Idle PREFIX = ev_idle_
858 954
859void ev_idle_start (ev_idle *w) 955void ev_idle_start (ev_idle *w)
860 CODE: 956 CODE:
861 START (idle, w); 957 START (idle, w);
867void DESTROY (ev_idle *w) 963void DESTROY (ev_idle *w)
868 CODE: 964 CODE:
869 STOP (idle, w); 965 STOP (idle, w);
870 e_destroy (w); 966 e_destroy (w);
871 967
872MODULE = EV PACKAGE = EV::Prepare PREFIX = ev_check_ 968MODULE = EV PACKAGE = EV::Prepare PREFIX = ev_prepare_
873 969
874void ev_prepare_start (ev_prepare *w) 970void ev_prepare_start (ev_prepare *w)
875 CODE: 971 CODE:
876 START (prepare, w); 972 START (prepare, w);
877 973
897void DESTROY (ev_check *w) 993void DESTROY (ev_check *w)
898 CODE: 994 CODE:
899 STOP (check, w); 995 STOP (check, w);
900 e_destroy (w); 996 e_destroy (w);
901 997
998MODULE = EV PACKAGE = EV::Fork PREFIX = ev_fork_
999
1000void ev_fork_start (ev_fork *w)
1001 CODE:
1002 START (fork, w);
1003
1004void ev_fork_stop (ev_fork *w)
1005 CODE:
1006 STOP (fork, w);
1007
1008void DESTROY (ev_fork *w)
1009 CODE:
1010 STOP (fork, w);
1011 e_destroy (w);
1012
902MODULE = EV PACKAGE = EV::Child PREFIX = ev_child_ 1013MODULE = EV PACKAGE = EV::Child PREFIX = ev_child_
903 1014
904void ev_child_start (ev_child *w) 1015void ev_child_start (ev_child *w)
905 CODE: 1016 CODE:
906 START (child, w); 1017 START (child, w);
912void DESTROY (ev_child *w) 1023void DESTROY (ev_child *w)
913 CODE: 1024 CODE:
914 STOP (child, w); 1025 STOP (child, w);
915 e_destroy (w); 1026 e_destroy (w);
916 1027
917void set (ev_child *w, int pid) 1028void set (ev_child *w, int pid, int trace)
918 CODE: 1029 CODE:
919 RESET (child, w, (w, pid)); 1030 RESET (child, w, (w, pid, trace));
920 1031
921int pid (ev_child *w, int new_pid = 0)
922 CODE:
923{
924 RETVAL = w->pid;
925
926 if (items > 1)
927 RESET (child, w, (w, new_pid));
928}
929 OUTPUT:
930 RETVAL
931
932
933int rstatus (ev_child *w) 1032int pid (ev_child *w)
934 ALIAS: 1033 ALIAS:
935 rpid = 1 1034 rpid = 1
1035 rstatus = 2
936 CODE: 1036 CODE:
937 RETVAL = ix ? w->rpid : w->rstatus; 1037 RETVAL = ix == 0 ? w->pid
1038 : ix == 1 ? w->rpid
1039 : w->rstatus;
938 OUTPUT: 1040 OUTPUT:
939 RETVAL 1041 RETVAL
940 1042
941MODULE = EV PACKAGE = EV::Stat PREFIX = ev_stat_ 1043MODULE = EV PACKAGE = EV::Stat PREFIX = ev_stat_
942 1044
984 RESET (stat, w, (w, SvPVbyte_nolen (w->fh), new_interval)); 1086 RESET (stat, w, (w, SvPVbyte_nolen (w->fh), new_interval));
985} 1087}
986 OUTPUT: 1088 OUTPUT:
987 RETVAL 1089 RETVAL
988 1090
989#ifndef _WIN32 1091void prev (ev_stat *w)
1092 ALIAS:
1093 stat = 1
1094 attr = 2
1095 PPCODE:
1096{
1097 ev_statdata *s = ix ? &w->attr : &w->prev;
990 1098
1099 if (ix == 1)
1100 ev_stat_stat (e_loop (w), w);
1101 else if (!s->st_nlink)
1102 errno = ENOENT;
1103
1104 PL_statcache.st_dev = s->st_nlink;
1105 PL_statcache.st_ino = s->st_ino;
1106 PL_statcache.st_mode = s->st_mode;
1107 PL_statcache.st_nlink = s->st_nlink;
1108 PL_statcache.st_uid = s->st_uid;
1109 PL_statcache.st_gid = s->st_gid;
1110 PL_statcache.st_rdev = s->st_rdev;
1111 PL_statcache.st_size = s->st_size;
1112 PL_statcache.st_atime = s->st_atime;
1113 PL_statcache.st_mtime = s->st_mtime;
1114 PL_statcache.st_ctime = s->st_ctime;
1115
1116 if (GIMME_V == G_SCALAR)
1117 XPUSHs (boolSV (s->st_nlink));
1118 else if (GIMME_V == G_ARRAY && s->st_nlink)
1119 {
1120 EXTEND (SP, 13);
1121 PUSHs (sv_2mortal (newSViv (s->st_dev)));
1122 PUSHs (sv_2mortal (newSViv (s->st_ino)));
1123 PUSHs (sv_2mortal (newSVuv (s->st_mode)));
1124 PUSHs (sv_2mortal (newSVuv (s->st_nlink)));
1125 PUSHs (sv_2mortal (newSViv (s->st_uid)));
1126 PUSHs (sv_2mortal (newSViv (s->st_gid)));
1127 PUSHs (sv_2mortal (newSViv (s->st_rdev)));
1128 PUSHs (sv_2mortal (newSVnv ((NV)s->st_size)));
1129 PUSHs (sv_2mortal (newSVnv (s->st_atime)));
1130 PUSHs (sv_2mortal (newSVnv (s->st_mtime)));
1131 PUSHs (sv_2mortal (newSVnv (s->st_ctime)));
1132 PUSHs (sv_2mortal (newSVuv (4096)));
1133 PUSHs (sv_2mortal (newSVnv ((NV)((s->st_size + 4095) / 4096))));
1134 }
1135}
1136
991MODULE = EV PACKAGE = EV::DNS PREFIX = evdns_ 1137MODULE = EV PACKAGE = EV::Embed PREFIX = ev_embed_
992 1138
993BOOT: 1139void ev_embed_start (ev_embed *w)
994{ 1140 CODE:
995 HV *stash = gv_stashpv ("EV::DNS", 1); 1141 START (embed, w);
996 1142
997 static const struct { 1143void ev_embed_stop (ev_embed *w)
998 const char *name; 1144 CODE:
999 IV iv; 1145 STOP (embed, w);
1000 } *civ, const_iv[] = {
1001# define const_iv(pfx, name) { # name, (IV) pfx ## name },
1002 const_iv (DNS_, ERR_NONE)
1003 const_iv (DNS_, ERR_FORMAT)
1004 const_iv (DNS_, ERR_SERVERFAILED)
1005 const_iv (DNS_, ERR_NOTEXIST)
1006 const_iv (DNS_, ERR_NOTIMPL)
1007 const_iv (DNS_, ERR_REFUSED)
1008 const_iv (DNS_, ERR_TRUNCATED)
1009 const_iv (DNS_, ERR_UNKNOWN)
1010 const_iv (DNS_, ERR_TIMEOUT)
1011 const_iv (DNS_, ERR_SHUTDOWN)
1012 const_iv (DNS_, IPv4_A)
1013 const_iv (DNS_, PTR)
1014 const_iv (DNS_, IPv6_AAAA)
1015 const_iv (DNS_, QUERY_NO_SEARCH)
1016 const_iv (DNS_, OPTION_SEARCH)
1017 const_iv (DNS_, OPTION_NAMESERVERS)
1018 const_iv (DNS_, OPTION_MISC)
1019 const_iv (DNS_, OPTIONS_ALL)
1020 const_iv (DNS_, NO_SEARCH)
1021 };
1022 1146
1023 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 1147void DESTROY (ev_embed *w)
1024 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 1148 CODE:
1025} 1149 STOP (embed, w);
1150 e_destroy (w);
1026 1151
1027int evdns_init () 1152void set (ev_embed *w, struct ev_loop *loop)
1153 CODE:
1154{
1155 sv_setsv (w->fh, ST (1));
1156 RESET (embed, w, (w, loop));
1157}
1028 1158
1029void evdns_shutdown (int fail_requests = 1) 1159SV *other (ev_embed *w)
1160 CODE:
1161 RETVAL = newSVsv (w->fh);
1162 OUTPUT:
1163 RETVAL
1030 1164
1031const char *evdns_err_to_string (int err) 1165void ev_embed_sweep (ev_embed *w)
1166 C_ARGS: e_loop (w), w
1032 1167
1033int evdns_nameserver_add (U32 address) 1168MODULE = EV PACKAGE = EV::Async PREFIX = ev_async_
1034 1169
1035int evdns_count_nameservers () 1170void ev_async_start (ev_async *w)
1171 CODE:
1172 START (async, w);
1036 1173
1037int evdns_clear_nameservers_and_suspend () 1174void ev_async_stop (ev_async *w)
1175 CODE:
1176 STOP (async, w);
1038 1177
1039int evdns_resume () 1178void DESTROY (ev_async *w)
1179 CODE:
1180 STOP (async, w);
1181 e_destroy (w);
1040 1182
1041int evdns_nameserver_ip_add (char *ip_as_string) 1183void ev_async_send (ev_async *w)
1184 C_ARGS: e_loop (w), w
1042 1185
1043int evdns_resolve_ipv4 (const char *name, int flags, SV *cb) 1186SV *ev_async_async_pending (ev_async *w)
1044 C_ARGS: name, flags, dns_cb, (void *)SvREFCNT_inc (cb)
1045
1046int evdns_resolve_ipv6 (const char *name, int flags, SV *cb)
1047 C_ARGS: name, flags, dns_cb, (void *)SvREFCNT_inc (cb)
1048
1049int evdns_resolve_reverse (SV *addr, int flags, SV *cb)
1050 ALIAS:
1051 evdns_resolve_reverse_ipv6 = 1
1052 CODE: 1187 CODE:
1053{ 1188 RETVAL = boolSV (ev_async_pending (w));
1054 STRLEN len; 1189 OUTPUT:
1055 char *data = SvPVbyte (addr, len);
1056 if (len != (ix ? 16 : 4))
1057 croak ("ipv4/ipv6 address to be resolved must be given as 4/16 byte octet string");
1058
1059 RETVAL = ix 1190 RETVAL
1060 ? evdns_resolve_reverse_ipv6 ((struct in6_addr *)data, flags, dns_cb, (void *)SvREFCNT_inc (cb))
1061 : evdns_resolve_reverse ((struct in_addr *)data, flags, dns_cb, (void *)SvREFCNT_inc (cb));
1062}
1063 OUTPUT:
1064 RETVAL
1065 1191
1066int evdns_set_option (char *option, char *val, int flags) 1192MODULE = EV PACKAGE = EV::Loop PREFIX = ev_
1067 1193
1068int evdns_resolv_conf_parse (int flags, const char *filename) 1194SV *new (SV *klass, unsigned int flags = 0)
1195 CODE:
1196{
1197 struct ev_loop *loop = ev_loop_new (flags);
1069 1198
1070#ifdef _WIN32 1199 if (!loop)
1200 XSRETURN_UNDEF;
1071 1201
1072int evdns_config_windows_nameservers () 1202 RETVAL = sv_bless (newRV_noinc (newSViv (PTR2IV (loop))), stash_loop);
1203}
1204 OUTPUT:
1205 RETVAL
1206
1207void DESTROY (struct ev_loop *loop)
1208 CODE:
1209 if (loop != evapi.default_loop) /* global destruction sucks */
1210 ev_loop_destroy (loop);
1211
1212void ev_loop_fork (struct ev_loop *loop)
1213
1214void ev_loop_verify (struct ev_loop *loop)
1215
1216NV ev_now (struct ev_loop *loop)
1217
1218void ev_now_update (struct ev_loop *loop)
1219
1220void ev_set_io_collect_interval (struct ev_loop *loop, NV interval)
1221
1222void ev_set_timeout_collect_interval (struct ev_loop *loop, NV interval)
1223
1224unsigned int ev_backend (struct ev_loop *loop)
1225
1226unsigned int ev_loop_count (struct ev_loop *loop)
1227
1228void ev_loop (struct ev_loop *loop, int flags = 0)
1229
1230void ev_unloop (struct ev_loop *loop, int how = 1)
1231
1232void ev_feed_fd_event (struct ev_loop *loop, int fd, int revents = EV_NONE)
1233
1234#if 0
1235
1236void ev_feed_signal_event (struct ev_loop *loop, SV *signal)
1237 CODE:
1238{
1239 Signal signum = sv_signum (signal);
1240 CHECK_SIG (signal, signum);
1241
1242 ev_feed_signal_event (loop, signum);
1243}
1073 1244
1074#endif 1245#endif
1075 1246
1076void evdns_search_clear () 1247ev_io *io (struct ev_loop *loop, SV *fh, int events, SV *cb)
1248 ALIAS:
1249 io_ns = 1
1250 CODE:
1251{
1252 int fd = sv_fileno (fh);
1253 CHECK_FD (fh, fd);
1077 1254
1078void evdns_search_add (char *domain) 1255 RETVAL = e_new (sizeof (ev_io), cb, ST (0));
1256 RETVAL->fh = newSVsv (fh);
1257 ev_io_set (RETVAL, fd, events);
1258 if (!ix) START (io, RETVAL);
1259}
1260 OUTPUT:
1261 RETVAL
1079 1262
1080void evdns_search_ndots_set (int ndots) 1263ev_timer *timer (struct ev_loop *loop, NV after, NV repeat, SV *cb)
1264 ALIAS:
1265 timer_ns = 1
1266 INIT:
1267 CHECK_REPEAT (repeat);
1268 CODE:
1269 RETVAL = e_new (sizeof (ev_timer), cb, ST (0));
1270 ev_timer_set (RETVAL, after, repeat);
1271 if (!ix) START (timer, RETVAL);
1272 OUTPUT:
1273 RETVAL
1274
1275SV *periodic (struct ev_loop *loop, NV at, NV interval, SV *reschedule_cb, SV *cb)
1276 ALIAS:
1277 periodic_ns = 1
1278 INIT:
1279 CHECK_REPEAT (interval);
1280 CODE:
1281{
1282 ev_periodic *w;
1283 w = e_new (sizeof (ev_periodic), cb, ST (0));
1284 w->fh = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0;
1285 ev_periodic_set (w, at, interval, w->fh ? e_periodic_cb : 0);
1286 RETVAL = e_bless ((ev_watcher *)w, stash_periodic);
1287 if (!ix) START (periodic, w);
1288}
1289 OUTPUT:
1290 RETVAL
1081 1291
1082#if 0 1292#if 0
1083 1293
1084MODULE = EV PACKAGE = EV::HTTP PREFIX = evhttp_ 1294ev_signal *signal (struct ev_loop *loop, SV *signal, SV *cb)
1085 1295 ALIAS:
1086BOOT: 1296 signal_ns = 1
1297 CODE:
1087{ 1298{
1088 HV *stash = gv_stashpv ("EV::HTTP", 1); 1299 Signal signum = sv_signum (signal);
1300 CHECK_SIG (signal, signum);
1089 1301
1090 static const struct { 1302 RETVAL = e_new (sizeof (ev_signal), cb, ST (0));
1091 const char *name; 1303 ev_signal_set (RETVAL, signum);
1092 IV iv; 1304 if (!ix) START (signal, RETVAL);
1093 } *civ, const_iv[] = {
1094# define const_iv(pfx, name) { # name, (IV) pfx ## name },
1095 const_iv (HTTP_, OK)
1096 const_iv (HTTP_, NOCONTENT)
1097 const_iv (HTTP_, MOVEPERM)
1098 const_iv (HTTP_, MOVETEMP)
1099 const_iv (HTTP_, NOTMODIFIED)
1100 const_iv (HTTP_, BADREQUEST)
1101 const_iv (HTTP_, NOTFOUND)
1102 const_iv (HTTP_, SERVUNAVAIL)
1103 const_iv (EVHTTP_, REQ_OWN_CONNECTION)
1104 const_iv (EVHTTP_, PROXY_REQUEST)
1105 const_iv (EVHTTP_, REQ_GET)
1106 const_iv (EVHTTP_, REQ_POST)
1107 const_iv (EVHTTP_, REQ_HEAD)
1108 const_iv (EVHTTP_, REQUEST)
1109 const_iv (EVHTTP_, RESPONSE)
1110 };
1111
1112 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1113 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
1114} 1305}
1115 1306 OUTPUT:
1116MODULE = EV PACKAGE = EV::HTTP::Request PREFIX = evhttp_request_ 1307 RETVAL
1117
1118#HttpRequest new (SV *klass, SV *cb)
1119
1120#void DESTROY (struct evhttp_request *req);
1121 1308
1122#endif 1309#endif
1123 1310
1124#endif 1311ev_idle *idle (struct ev_loop *loop, SV *cb)
1312 ALIAS:
1313 idle_ns = 1
1314 CODE:
1315 RETVAL = e_new (sizeof (ev_idle), cb, ST (0));
1316 ev_idle_set (RETVAL);
1317 if (!ix) START (idle, RETVAL);
1318 OUTPUT:
1319 RETVAL
1125 1320
1321ev_prepare *prepare (struct ev_loop *loop, SV *cb)
1322 ALIAS:
1323 prepare_ns = 1
1324 CODE:
1325 RETVAL = e_new (sizeof (ev_prepare), cb, ST (0));
1326 ev_prepare_set (RETVAL);
1327 if (!ix) START (prepare, RETVAL);
1328 OUTPUT:
1329 RETVAL
1126 1330
1331ev_check *check (struct ev_loop *loop, SV *cb)
1332 ALIAS:
1333 check_ns = 1
1334 CODE:
1335 RETVAL = e_new (sizeof (ev_check), cb, ST (0));
1336 ev_check_set (RETVAL);
1337 if (!ix) START (check, RETVAL);
1338 OUTPUT:
1339 RETVAL
1127 1340
1341ev_fork *fork (struct ev_loop *loop, SV *cb)
1342 ALIAS:
1343 fork_ns = 1
1344 CODE:
1345 RETVAL = e_new (sizeof (ev_fork), cb, ST (0));
1346 ev_fork_set (RETVAL);
1347 if (!ix) START (fork, RETVAL);
1348 OUTPUT:
1349 RETVAL
1128 1350
1351ev_child *child (struct ev_loop *loop, int pid, int trace, SV *cb)
1352 ALIAS:
1353 child_ns = 1
1354 CODE:
1355 RETVAL = e_new (sizeof (ev_child), cb, ST (0));
1356 ev_child_set (RETVAL, pid, trace);
1357 if (!ix) START (child, RETVAL);
1358 OUTPUT:
1359 RETVAL
1129 1360
1361ev_stat *stat (struct ev_loop *loop, SV *path, NV interval, SV *cb)
1362 ALIAS:
1363 stat_ns = 1
1364 CODE:
1365 RETVAL = e_new (sizeof (ev_stat), cb, ST (0));
1366 RETVAL->fh = newSVsv (path);
1367 ev_stat_set (RETVAL, SvPVbyte_nolen (RETVAL->fh), interval);
1368 if (!ix) START (stat, RETVAL);
1369 OUTPUT:
1370 RETVAL
1130 1371
1372ev_embed *embed (struct ev_loop *loop, struct ev_loop *other, SV *cb = 0)
1373 ALIAS:
1374 embed_ns = 1
1375 CODE:
1376{
1377 if (!(ev_backend (other) & ev_embeddable_backends ()))
1378 croak ("passed loop is not embeddable via EV::embed,");
1131 1379
1380 RETVAL = e_new (sizeof (ev_embed), cb, ST (0));
1381 RETVAL->fh = newSVsv (ST (1));
1382 ev_embed_set (RETVAL, other);
1383 if (!ix) START (embed, RETVAL);
1384}
1385 OUTPUT:
1386 RETVAL
1387
1388ev_async *async (struct ev_loop *loop, SV *cb)
1389 ALIAS:
1390 async_ns = 1
1391 CODE:
1392 RETVAL = e_new (sizeof (ev_async), cb, ST (0));
1393 ev_async_set (RETVAL);
1394 if (!ix) START (async, RETVAL);
1395 OUTPUT:
1396 RETVAL
1397
1398void once (struct ev_loop *loop, SV *fh, int events, SV *timeout, SV *cb)
1399 CODE:
1400 ev_once (
1401 loop,
1402 sv_fileno (fh), events,
1403 SvOK (timeout) ? SvNV (timeout) : -1.,
1404 e_once_cb,
1405 newSVsv (cb)
1406 );
1407

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines