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

Comparing EV/EV.xs (file contents):
Revision 1.83 by root, Thu Nov 29 17:28:13 2007 UTC vs.
Revision 1.139 by root, Thu Apr 22 11:12:06 2010 UTC

1#include "EXTERN.h" 1#include "EXTERN.h"
2#include "perl.h" 2#include "perl.h"
3#include "XSUB.h" 3#include "XSUB.h"
4 4
5/*#include <netinet/in.h>*/
6
7#define EV_PROTOTYPES 1
8#include "EV/EVAPI.h"
9
10/* fix perl api breakage */ 5/* fix perl api breakage */
11#undef signal 6#undef signal
12#undef sigaction 7#undef sigaction
8
9#include "schmorp.h"
10
11/* old API compatibility */
12static int
13sv_fileno (SV *fh)
14{
15 return s_fileno (fh, 0);
16}
17
18#define EV_STANDALONE 1
19#define EV_PROTOTYPES 1
20#define EV_USE_NANOSLEEP EV_USE_MONOTONIC
21#define EV_H <ev.h>
22#define EV_CONFIG_H error
23#include "EV/EVAPI.h"
13 24
14#define EV_SELECT_IS_WINSOCKET 0 25#define EV_SELECT_IS_WINSOCKET 0
15#ifdef _WIN32 26#ifdef _WIN32
16# define EV_SELECT_USE_FD_SET 0 27# define EV_SELECT_USE_FD_SET 0
17# define NFDBITS PERL_NFDBITS 28# define NFDBITS PERL_NFDBITS
18# define fd_mask Perl_fd_mask 29# define fd_mask Perl_fd_mask
19#endif 30#endif
20/* due to bugs in OS X we have to use libev/ explicitly here */ 31/* due to bugs in OS X we have to use libev/ explicitly here */
21#include "libev/ev.c" 32#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 33
36#ifndef _WIN32 34#ifndef _WIN32
37# include <pthread.h> 35# include <pthread.h>
38#endif 36#endif
39 37
38#define e_loop(w) INT2PTR (struct ev_loop *, SvIVX (((ev_watcher *)(w))->loop))
39#define e_flags(w) ((ev_watcher *)(w))->e_flags
40#define e_self(w) ((ev_watcher *)(w))->self
41#define e_fh(w) ((ev_watcher *)(w))->fh
42#define e_data(w) ((ev_watcher *)(w))->data
43
40#define WFLAG_KEEPALIVE 1 44#define WFLAG_KEEPALIVE 1
45#define WFLAG_UNREFED 2 /* has been unref'ed */
41 46
42#define UNREF(w) \ 47#define UNREF(w) \
43 if (!((w)->flags & WFLAG_KEEPALIVE) \ 48 if (!(e_flags (w) & (WFLAG_KEEPALIVE | WFLAG_UNREFED)) \
44 && !ev_is_active (w)) \ 49 && ev_is_active (w)) \
45 ev_unref (); 50 { \
51 ev_unref (e_loop (w)); \
52 e_flags (w) |= WFLAG_UNREFED; \
53 }
46 54
47#define REF(w) \ 55#define REF(w) \
48 if (!((w)->flags & WFLAG_KEEPALIVE) \ 56 if (e_flags (w) & WFLAG_UNREFED) \
49 && ev_is_active (w)) \ 57 { \
50 ev_ref (); 58 e_flags (w) &= ~WFLAG_UNREFED; \
59 ev_ref (e_loop (w)); \
60 }
51 61
52#define START(type,w) \ 62#define START(type,w) \
53 do { \ 63 do { \
64 ev_ ## type ## _start (e_loop (w), w); \
54 UNREF (w); \ 65 UNREF (w); \
55 ev_ ## type ## _start (w); \
56 } while (0) 66 } while (0)
57 67
58#define STOP(type,w) \ 68#define STOP(type,w) \
59 do { \ 69 do { \
60 REF (w); \ 70 REF (w); \
61 ev_ ## type ## _stop (w); \ 71 ev_ ## type ## _stop (e_loop (w), w); \
62 } while (0) 72 } while (0)
63 73
64#define RESET(type,w,seta) \ 74#define RESET(type,w,seta) \
65 do { \ 75 do { \
66 int active = ev_is_active (w); \ 76 int active = ev_is_active (w); \
67 if (active) STOP (type, w); \ 77 if (active) STOP (type, w); \
68 ev_ ## type ## _set seta; \ 78 ev_ ## type ## _set seta; \
69 if (active) START (type, w); \ 79 if (active) START (type, w); \
70 } while (0) 80 } while (0)
71 81
72typedef int Signal; 82typedef int Signal;
73 83
84/* horrible... */
85#define CHECK_SIGNAL_CAN_START(w) \
86 do { \
87 /* dive into the internals of libev to avoid aborting in libev */ \
88 if (signals [(w)->signum - 1].loop \
89 && signals [(w)->signum - 1].loop != e_loop (w)) \
90 croak ("unable to start signal watcher, signal %d already registered in another loop", w->signum); \
91 } while (0)
92
93#define START_SIGNAL(w) \
94 do { \
95 CHECK_SIGNAL_CAN_START (w); \
96 START (signal, w); \
97 } while (0) \
98
99#define RESET_SIGNAL(w,seta) \
100 do { \
101 int active = ev_is_active (w); \
102 if (active) STOP (signal, w); \
103 ev_ ## signal ## _set seta; \
104 if (active) START_SIGNAL (w); \
105 } while (0)
106
107static SV *default_loop_sv;
108
74static struct EVAPI evapi; 109static struct EVAPI evapi;
75 110
76static HV 111static HV
112 *stash_loop,
77 *stash_watcher, 113 *stash_watcher,
78 *stash_io, 114 *stash_io,
79 *stash_timer, 115 *stash_timer,
80 *stash_periodic, 116 *stash_periodic,
81 *stash_signal, 117 *stash_signal,
83 *stash_stat, 119 *stash_stat,
84 *stash_idle, 120 *stash_idle,
85 *stash_prepare, 121 *stash_prepare,
86 *stash_check, 122 *stash_check,
87 *stash_embed, 123 *stash_embed,
88 *stash_fork; 124 *stash_fork,
89 125 *stash_async;
90#ifndef SIG_SIZE
91/* kudos to Slaven Rezic for the idea */
92static char sig_size [] = { SIG_NUM };
93# define SIG_SIZE (sizeof (sig_size) + 1)
94#endif
95
96static Signal
97sv_signum (SV *sig)
98{
99 Signal signum;
100
101 SvGETMAGIC (sig);
102
103 for (signum = 1; signum < SIG_SIZE; ++signum)
104 if (strEQ (SvPV_nolen (sig), PL_sig_name [signum]))
105 return signum;
106
107 signum = SvIV (sig);
108
109 if (signum > 0 && signum < SIG_SIZE)
110 return signum;
111
112 return -1;
113}
114 126
115///////////////////////////////////////////////////////////////////////////// 127/////////////////////////////////////////////////////////////////////////////
116// Event 128// Event
117 129
118static void e_cb (ev_watcher *w, int revents); 130static void e_cb (EV_P_ ev_watcher *w, int revents);
119 131
120static int 132void *
121sv_fileno (SV *fh)
122{
123 SvGETMAGIC (fh);
124
125 if (SvROK (fh))
126 fh = SvRV (fh);
127
128 if (SvTYPE (fh) == SVt_PVGV)
129 return PerlIO_fileno (IoIFP (sv_2io (fh)));
130
131 if (SvOK (fh) && (SvIV (fh) >= 0) && (SvIV (fh) < 0x7fffffffL))
132 return SvIV (fh);
133
134 return -1;
135}
136
137static void *
138e_new (int size, SV *cb_sv) 133e_new (int size, SV *cb_sv, SV *loop)
139{ 134{
135 SV *cv = cb_sv ? s_get_cv_croak (cb_sv) : 0;
140 ev_watcher *w; 136 ev_watcher *w;
141 SV *self = NEWSV (0, size); 137 SV *self = NEWSV (0, size);
142 SvPOK_only (self); 138 SvPOK_only (self);
143 SvCUR_set (self, size); 139 SvCUR_set (self, size);
144 140
145 w = (ev_watcher *)SvPVX (self); 141 w = (ev_watcher *)SvPVX (self);
146 142
147 ev_init (w, e_cb); 143 ev_init (w, cv ? e_cb : 0);
148 144
145 w->loop = SvREFCNT_inc (SvRV (loop));
149 w->flags = WFLAG_KEEPALIVE; 146 w->e_flags = WFLAG_KEEPALIVE;
150 w->data = 0; 147 w->data = 0;
151 w->fh = 0; 148 w->fh = 0;
152 w->cb_sv = newSVsv (cb_sv); 149 w->cb_sv = SvREFCNT_inc (cv);
153 w->self = self; 150 w->self = self;
154 151
155 return (void *)w; 152 return (void *)w;
156} 153}
157 154
158static void 155static void
159e_destroy (void *w_) 156e_destroy (void *w_)
160{ 157{
161 ev_watcher *w = (ev_watcher *)w_; 158 ev_watcher *w = (ev_watcher *)w_;
162 159
160 SvREFCNT_dec (w->loop ); w->loop = 0;
163 SvREFCNT_dec (w->fh ); w->fh = 0; 161 SvREFCNT_dec (w->fh ); w->fh = 0;
164 SvREFCNT_dec (w->cb_sv); w->cb_sv = 0; 162 SvREFCNT_dec (w->cb_sv); w->cb_sv = 0;
165 SvREFCNT_dec (w->data ); w->data = 0; 163 SvREFCNT_dec (w->data ); w->data = 0;
166} 164}
167 165
180 } 178 }
181 179
182 return rv; 180 return rv;
183} 181}
184 182
185static SV *sv_events_cache; 183static SV *sv_self_cache, *sv_events_cache;
186 184
187static void 185static void
188e_cb (ev_watcher *w, int revents) 186e_cb (EV_P_ ev_watcher *w, int revents)
189{ 187{
190 dSP; 188 dSP;
191 I32 mark = SP - PL_stack_base; 189 I32 mark = SP - PL_stack_base;
192 SV *sv_self, *sv_events; 190 SV *sv_self, *sv_events;
193 191
192 /* libev might have stopped the watcher */
193 if (expect_false (w->e_flags & WFLAG_UNREFED)
194 && !ev_is_active (w))
195 REF (w);
196
197 if (expect_true (sv_self_cache))
198 {
199 sv_self = sv_self_cache; sv_self_cache = 0;
200 SvRV_set (sv_self, SvREFCNT_inc_NN (w->self));
201 }
202 else
203 {
194 sv_self = newRV_inc (w->self); /* w->self MUST be blessed by now */ 204 sv_self = newRV_inc (w->self); /* e_self (w) MUST be blessed by now */
205 SvREADONLY_on (sv_self);
206 }
207
208 if (expect_true (sv_events_cache))
209 {
210 sv_events = sv_events_cache; sv_events_cache = 0;
211 SvIV_set (sv_events, revents);
212 }
213 else
214 {
215 sv_events = newSViv (revents);
216 SvREADONLY_on (sv_events);
217 }
218
219 PUSHMARK (SP);
220 EXTEND (SP, 2);
221 PUSHs (sv_self);
222 PUSHs (sv_events);
223
224 PUTBACK;
225 call_sv (w->cb_sv, G_DISCARD | G_VOID | G_EVAL);
226
227 if (expect_false (SvREFCNT (sv_self) != 1 || sv_self_cache))
228 SvREFCNT_dec (sv_self);
229 else
230 {
231 SvREFCNT_dec (SvRV (sv_self));
232 SvRV_set (sv_self, &PL_sv_undef);
233 sv_self_cache = sv_self;
234 }
235
236 if (expect_false (SvREFCNT (sv_events) != 1 || sv_events_cache))
237 SvREFCNT_dec (sv_events);
238 else
239 sv_events_cache = sv_events;
240
241 if (expect_false (SvTRUE (ERRSV)))
242 {
243 SPAGAIN;
244 PUSHMARK (SP);
245 PUTBACK;
246 call_sv (get_sv ("EV::DIED", 1), G_DISCARD | G_VOID | G_EVAL | G_KEEPERR);
247 }
248
249 SP = PL_stack_base + mark;
250 PUTBACK;
251}
252
253static void
254e_once_cb (int revents, void *arg)
255{
256 dSP;
257 I32 mark = SP - PL_stack_base;
258 SV *sv_events;
195 259
196 if (sv_events_cache) 260 if (sv_events_cache)
197 { 261 {
198 sv_events = sv_events_cache; sv_events_cache = 0; 262 sv_events = sv_events_cache; sv_events_cache = 0;
199 SvIV_set (sv_events, revents); 263 SvIV_set (sv_events, revents);
200 } 264 }
201 else 265 else
202 sv_events = newSViv (revents); 266 sv_events = newSViv (revents);
203 267
204 PUSHMARK (SP); 268 PUSHMARK (SP);
205 EXTEND (SP, 2);
206 PUSHs (sv_self);
207 PUSHs (sv_events); 269 XPUSHs (sv_events);
208 270
209 PUTBACK; 271 PUTBACK;
210 call_sv (w->cb_sv, G_DISCARD | G_VOID | G_EVAL); 272 call_sv ((SV *)arg, G_DISCARD | G_VOID | G_EVAL);
211 273
212 SvREFCNT_dec (sv_self); 274 SvREFCNT_dec ((SV *)arg);
213 275
214 if (sv_events_cache) 276 if (sv_events_cache)
215 SvREFCNT_dec (sv_events); 277 SvREFCNT_dec (sv_events);
216 else 278 else
217 sv_events_cache = sv_events; 279 sv_events_cache = sv_events;
218 280
219 if (SvTRUE (ERRSV)) 281 if (SvTRUE (ERRSV))
220 { 282 {
283 SPAGAIN;
221 PUSHMARK (SP); 284 PUSHMARK (SP);
222 PUTBACK; 285 PUTBACK;
223 call_sv (get_sv ("EV::DIED", 1), G_DISCARD | G_VOID | G_EVAL | G_KEEPERR); 286 call_sv (get_sv ("EV::DIED", 1), G_DISCARD | G_VOID | G_EVAL | G_KEEPERR);
224 } 287 }
225 288
226 SP = PL_stack_base + mark; 289 SP = PL_stack_base + mark;
227 PUTBACK; 290 PUTBACK;
228} 291}
229 292
230static void
231e_once_cb (int revents, void *arg)
232{
233 dSP;
234 I32 mark = SP - PL_stack_base;
235 SV *sv_events;
236
237 if (sv_events_cache)
238 {
239 sv_events = sv_events_cache; sv_events_cache = 0;
240 SvIV_set (sv_events, revents);
241 }
242 else
243 sv_events = newSViv (revents);
244
245 PUSHMARK (SP);
246 XPUSHs (sv_events);
247
248 PUTBACK;
249 call_sv ((SV *)arg, G_DISCARD | G_VOID | G_EVAL);
250
251 SvREFCNT_dec ((SV *)arg);
252
253 if (sv_events_cache)
254 SvREFCNT_dec (sv_events);
255 else
256 sv_events_cache = sv_events;
257
258 if (SvTRUE (ERRSV))
259 {
260 PUSHMARK (SP);
261 PUTBACK;
262 call_sv (get_sv ("EV::DIED", 1), G_DISCARD | G_VOID | G_EVAL | G_KEEPERR);
263 }
264
265 SP = PL_stack_base + mark;
266 PUTBACK;
267}
268
269static ev_tstamp 293static ev_tstamp
270e_periodic_cb (ev_periodic *w, ev_tstamp now) 294e_periodic_cb (ev_periodic *w, ev_tstamp now)
271{ 295{
272 ev_tstamp retval; 296 ev_tstamp retval;
273 int count; 297 int count;
276 ENTER; 300 ENTER;
277 SAVETMPS; 301 SAVETMPS;
278 302
279 PUSHMARK (SP); 303 PUSHMARK (SP);
280 EXTEND (SP, 2); 304 EXTEND (SP, 2);
281 PUSHs (newRV_inc (w->self)); /* w->self MUST be blessed by now */ 305 PUSHs (newRV_inc (e_self (w))); /* e_self (w) MUST be blessed by now */
282 PUSHs (newSVnv (now)); 306 PUSHs (newSVnv (now));
283 307
284 PUTBACK; 308 PUTBACK;
285 count = call_sv (w->fh, G_SCALAR | G_EVAL); 309 count = call_sv (w->fh, G_SCALAR | G_EVAL);
286 SPAGAIN; 310 SPAGAIN;
307 LEAVE; 331 LEAVE;
308 332
309 return retval; 333 return retval;
310} 334}
311 335
312/////////////////////////////////////////////////////////////////////////////
313// DNS
314
315#ifndef _WIN32
316static void
317dns_cb (int result, char type, int count, int ttl, void *addresses, void *arg)
318{
319 dSP;
320 SV *cb = (SV *)arg;
321
322 ENTER;
323 SAVETMPS;
324 PUSHMARK (SP);
325 EXTEND (SP, count + 3);
326 PUSHs (sv_2mortal (newSViv (result)));
327
328 if (result == DNS_ERR_NONE && ttl >= 0)
329 {
330 int i;
331
332 PUSHs (sv_2mortal (newSViv (type)));
333 PUSHs (sv_2mortal (newSViv (ttl)));
334
335 for (i = 0; i < count; ++i)
336 switch (type)
337 {
338 case DNS_IPv6_AAAA:
339 PUSHs (sv_2mortal (newSVpvn (i * 16 + (char *)addresses, 16)));
340 break;
341 case DNS_IPv4_A:
342 PUSHs (sv_2mortal (newSVpvn (i * 4 + (char *)addresses, 4)));
343 break;
344 case DNS_PTR:
345 PUSHs (sv_2mortal (newSVpv (*(char **)addresses, 0)));
346 break;
347 }
348 }
349
350 PUTBACK;
351 call_sv (sv_2mortal (cb), G_DISCARD | G_VOID | G_EVAL);
352
353 FREETMPS;
354
355 if (SvTRUE (ERRSV))
356 {
357 PUSHMARK (SP);
358 PUTBACK;
359 call_sv (get_sv ("EV::DIED", 1), G_DISCARD | G_VOID | G_EVAL | G_KEEPERR);
360 }
361
362 LEAVE;
363}
364#endif
365
366#define CHECK_REPEAT(repeat) if (repeat < 0.) \ 336#define CHECK_REPEAT(repeat) if (repeat < 0.) \
367 croak (# repeat " value must be >= 0"); 337 croak (# repeat " value must be >= 0");
368 338
369#define CHECK_FD(fh,fd) if ((fd) < 0) \ 339#define CHECK_FD(fh,fd) if ((fd) < 0) \
370 croak ("illegal file descriptor or filehandle (either no attached file descriptor or illegal value): %s", SvPV_nolen (fh)); 340 croak ("illegal file descriptor or filehandle (either no attached file descriptor or illegal value): %s", SvPV_nolen (fh));
391 const_iv (EV_, MINPRI) 361 const_iv (EV_, MINPRI)
392 const_iv (EV_, MAXPRI) 362 const_iv (EV_, MAXPRI)
393 363
394 const_iv (EV_, UNDEF) 364 const_iv (EV_, UNDEF)
395 const_iv (EV_, NONE) 365 const_iv (EV_, NONE)
396 const_iv (EV_, TIMEOUT)
397 const_iv (EV_, READ) 366 const_iv (EV_, READ)
398 const_iv (EV_, WRITE) 367 const_iv (EV_, WRITE)
368 const_iv (EV_, IO)
369 const_iv (EV_, TIMEOUT) /* deprecated */
370 const_iv (EV_, TIMER)
371 const_iv (EV_, PERIODIC)
399 const_iv (EV_, SIGNAL) 372 const_iv (EV_, SIGNAL)
373 const_iv (EV_, CHILD)
374 const_iv (EV_, STAT)
400 const_iv (EV_, IDLE) 375 const_iv (EV_, IDLE)
376 const_iv (EV_, PREPARE)
401 const_iv (EV_, CHECK) 377 const_iv (EV_, CHECK)
378 const_iv (EV_, EMBED)
379 const_iv (EV_, FORK)
380 const_iv (EV_, ASYNC)
381 const_iv (EV_, CUSTOM)
402 const_iv (EV_, ERROR) 382 const_iv (EV_, ERROR)
403 383
384 const_iv (EV, LOOP_NONBLOCK)
404 const_iv (EV, LOOP_ONESHOT) 385 const_iv (EV, LOOP_ONESHOT)
386
405 const_iv (EV, LOOP_NONBLOCK) 387 const_iv (EV, UNLOOP_CANCEL)
406 const_iv (EV, UNLOOP_ONE) 388 const_iv (EV, UNLOOP_ONE)
407 const_iv (EV, UNLOOP_ALL) 389 const_iv (EV, UNLOOP_ALL)
408 390
409 const_iv (EV, BACKEND_SELECT) 391 const_iv (EV, BACKEND_SELECT)
410 const_iv (EV, BACKEND_POLL) 392 const_iv (EV, BACKEND_POLL)
411 const_iv (EV, BACKEND_EPOLL) 393 const_iv (EV, BACKEND_EPOLL)
412 const_iv (EV, BACKEND_KQUEUE) 394 const_iv (EV, BACKEND_KQUEUE)
413 const_iv (EV, BACKEND_DEVPOLL) 395 const_iv (EV, BACKEND_DEVPOLL)
414 const_iv (EV, BACKEND_PORT) 396 const_iv (EV, BACKEND_PORT)
397 const_iv (EV, BACKEND_ALL)
415 const_iv (EV, FLAG_AUTO) 398 const_iv (EV, FLAG_AUTO)
399 const_iv (EV, FLAG_FORKCHECK)
400 const_iv (EV, FLAG_SIGNALFD)
416 const_iv (EV, FLAG_NOENV) 401 const_iv (EV, FLAG_NOENV)
402 const_iv (EV, FLAG_NOSIGFD) /* compatibility, always 0 */
417 const_iv (EV, FLAG_FORKCHECK) 403 const_iv (EV, FLAG_NOINOTIFY)
404
405 const_iv (EV_, VERSION_MAJOR)
406 const_iv (EV_, VERSION_MINOR)
418 }; 407 };
419 408
420 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 409 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
421 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 410 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
422 411
412 stash_loop = gv_stashpv ("EV::Loop" , 1);
423 stash_watcher = gv_stashpv ("EV::Watcher" , 1); 413 stash_watcher = gv_stashpv ("EV::Watcher" , 1);
424 stash_io = gv_stashpv ("EV::IO" , 1); 414 stash_io = gv_stashpv ("EV::IO" , 1);
425 stash_timer = gv_stashpv ("EV::Timer" , 1); 415 stash_timer = gv_stashpv ("EV::Timer" , 1);
426 stash_periodic = gv_stashpv ("EV::Periodic", 1); 416 stash_periodic = gv_stashpv ("EV::Periodic", 1);
427 stash_signal = gv_stashpv ("EV::Signal" , 1); 417 stash_signal = gv_stashpv ("EV::Signal" , 1);
429 stash_prepare = gv_stashpv ("EV::Prepare" , 1); 419 stash_prepare = gv_stashpv ("EV::Prepare" , 1);
430 stash_check = gv_stashpv ("EV::Check" , 1); 420 stash_check = gv_stashpv ("EV::Check" , 1);
431 stash_child = gv_stashpv ("EV::Child" , 1); 421 stash_child = gv_stashpv ("EV::Child" , 1);
432 stash_embed = gv_stashpv ("EV::Embed" , 1); 422 stash_embed = gv_stashpv ("EV::Embed" , 1);
433 stash_stat = gv_stashpv ("EV::Stat" , 1); 423 stash_stat = gv_stashpv ("EV::Stat" , 1);
424 stash_fork = gv_stashpv ("EV::Fork" , 1);
425 stash_async = gv_stashpv ("EV::Async" , 1);
434 426
435 { 427 {
436 SV *sv = perl_get_sv ("EV::API", TRUE); 428 SV *sv = perl_get_sv ("EV::API", TRUE);
437 perl_get_sv ("EV::API", TRUE); /* silence 5.10 warning */ 429 perl_get_sv ("EV::API", TRUE); /* silence 5.10 warning */
438 430
439 /* the poor man's shared library emulator */ 431 /* the poor man's shared library emulator */
440 evapi.ver = EV_API_VERSION; 432 evapi.ver = EV_API_VERSION;
441 evapi.rev = EV_API_REVISION; 433 evapi.rev = EV_API_REVISION;
442 evapi.sv_fileno = sv_fileno; 434 evapi.sv_fileno = sv_fileno;
443 evapi.sv_signum = sv_signum; 435 evapi.sv_signum = s_signum;
436 evapi.supported_backends = ev_supported_backends ();
437 evapi.recommended_backends = ev_recommended_backends ();
438 evapi.embeddable_backends = ev_embeddable_backends ();
439 evapi.time_ = ev_time;
440 evapi.sleep_ = ev_sleep;
441 evapi.loop_new = ev_loop_new;
442 evapi.loop_destroy = ev_loop_destroy;
443 evapi.loop_fork = ev_loop_fork;
444 evapi.iteration = ev_iteration;
445 evapi.depth = ev_depth;
446 evapi.set_userdata = ev_set_userdata;
447 evapi.userdata = ev_userdata;
444 evapi.now = ev_now; 448 evapi.now = ev_now;
449 evapi.now_update = ev_now_update;
450 evapi.suspend = ev_suspend;
451 evapi.resume = ev_resume;
445 evapi.backend = ev_backend; 452 evapi.backend = ev_backend;
446 evapi.unloop = ev_unloop; 453 evapi.unloop = ev_unloop;
454 evapi.invoke_pending = ev_invoke_pending;
455 evapi.pending_count = ev_pending_count;
456 evapi.verify = ev_verify;
457 evapi.set_loop_release_cb = ev_set_loop_release_cb;
458 evapi.set_invoke_pending_cb= ev_set_invoke_pending_cb;
447 evapi.ref = ev_ref; 459 evapi.ref = ev_ref;
448 evapi.unref = ev_unref; 460 evapi.unref = ev_unref;
449 evapi.time = ev_time;
450 evapi.loop = ev_loop; 461 evapi.loop = ev_loop;
451 evapi.once = ev_once; 462 evapi.once = ev_once;
452 evapi.io_start = ev_io_start; 463 evapi.io_start = ev_io_start;
453 evapi.io_stop = ev_io_stop; 464 evapi.io_stop = ev_io_stop;
454 evapi.timer_start = ev_timer_start; 465 evapi.timer_start = ev_timer_start;
455 evapi.timer_stop = ev_timer_stop; 466 evapi.timer_stop = ev_timer_stop;
456 evapi.timer_again = ev_timer_again; 467 evapi.timer_again = ev_timer_again;
468 evapi.timer_remaining = ev_timer_remaining;
457 evapi.periodic_start = ev_periodic_start; 469 evapi.periodic_start = ev_periodic_start;
458 evapi.periodic_stop = ev_periodic_stop; 470 evapi.periodic_stop = ev_periodic_stop;
459 evapi.signal_start = ev_signal_start; 471 evapi.signal_start = ev_signal_start;
460 evapi.signal_stop = ev_signal_stop; 472 evapi.signal_stop = ev_signal_stop;
461 evapi.idle_start = ev_idle_start; 473 evapi.idle_start = ev_idle_start;
462 evapi.idle_stop = ev_idle_stop; 474 evapi.idle_stop = ev_idle_stop;
463 evapi.prepare_start = ev_prepare_start; 475 evapi.prepare_start = ev_prepare_start;
464 evapi.prepare_stop = ev_prepare_stop; 476 evapi.prepare_stop = ev_prepare_stop;
465 evapi.check_start = ev_check_start; 477 evapi.check_start = ev_check_start;
466 evapi.check_stop = ev_check_stop; 478 evapi.check_stop = ev_check_stop;
479#if EV_CHILD_ENABLE
467 evapi.child_start = ev_child_start; 480 evapi.child_start = ev_child_start;
468 evapi.child_stop = ev_child_stop; 481 evapi.child_stop = ev_child_stop;
482#endif
469 evapi.stat_start = ev_stat_start; 483 evapi.stat_start = ev_stat_start;
470 evapi.stat_stop = ev_stat_stop; 484 evapi.stat_stop = ev_stat_stop;
471 evapi.stat_stat = ev_stat_stat; 485 evapi.stat_stat = ev_stat_stat;
486 evapi.embed_start = ev_embed_start;
487 evapi.embed_stop = ev_embed_stop;
488 evapi.embed_sweep = ev_embed_sweep;
489 evapi.fork_start = ev_fork_start;
490 evapi.fork_stop = ev_fork_stop;
491 evapi.async_start = ev_async_start;
492 evapi.async_stop = ev_async_stop;
493 evapi.async_send = ev_async_send;
494 evapi.clear_pending = ev_clear_pending;
495 evapi.invoke = ev_invoke;
472 496
473 sv_setiv (sv, (IV)&evapi); 497 sv_setiv (sv, (IV)&evapi);
474 SvREADONLY_on (sv); 498 SvREADONLY_on (sv);
475 } 499 }
476#ifndef _WIN32 500#ifndef _WIN32
477 pthread_atfork (0, 0, ev_default_fork); 501 pthread_atfork (0, 0, ev_default_fork);
478#endif 502#endif
479} 503}
480 504
505SV *ev_default_loop (unsigned int flags = 0)
506 CODE:
507{
508 if (!default_loop_sv)
509 {
510 evapi.default_loop = ev_default_loop (flags);
511
512 if (!evapi.default_loop)
513 XSRETURN_UNDEF;
514
515 default_loop_sv = sv_bless (newRV_noinc (newSViv (PTR2IV (evapi.default_loop))), stash_loop);
516 }
517
518 RETVAL = newSVsv (default_loop_sv);
519}
520 OUTPUT:
521 RETVAL
522
523void ev_default_destroy ()
524 CODE:
525 ev_default_destroy ();
526 SvREFCNT_dec (default_loop_sv);
527 default_loop_sv = 0;
528
529unsigned int ev_supported_backends ()
530
531unsigned int ev_recommended_backends ()
532
533unsigned int ev_embeddable_backends ()
534
535void ev_sleep (NV interval)
536
537NV ev_time ()
538
481NV ev_now () 539NV ev_now ()
540 C_ARGS: evapi.default_loop
541
542void ev_now_update ()
543 C_ARGS: evapi.default_loop
544
545void ev_suspend ()
546 C_ARGS: evapi.default_loop
547
548void ev_resume ()
549 C_ARGS: evapi.default_loop
482 550
483unsigned int ev_backend () 551unsigned int ev_backend ()
552 C_ARGS: evapi.default_loop
484 553
485NV ev_time () 554void ev_verify ()
555 C_ARGS: evapi.default_loop
486 556
487unsigned int ev_default_loop (unsigned int flags = ev_supported_backends ()) 557unsigned int ev_iteration ()
558 C_ARGS: evapi.default_loop
559
560unsigned int ev_depth ()
561 C_ARGS: evapi.default_loop
562
563void ev_set_io_collect_interval (NV interval)
564 C_ARGS: evapi.default_loop, interval
565
566void ev_set_timeout_collect_interval (NV interval)
567 C_ARGS: evapi.default_loop, interval
488 568
489void ev_loop (int flags = 0) 569void ev_loop (int flags = 0)
570 C_ARGS: evapi.default_loop, flags
490 571
491void ev_unloop (int how = 1) 572void ev_unloop (int how = EVUNLOOP_ONE)
573 C_ARGS: evapi.default_loop, how
574
575void ev_feed_fd_event (int fd, int revents = EV_NONE)
576 C_ARGS: evapi.default_loop, fd, revents
577
578void ev_feed_signal_event (SV *signal)
579 CODE:
580{
581 Signal signum = s_signum (signal);
582 CHECK_SIG (signal, signum);
583
584 ev_feed_signal_event (evapi.default_loop, signum);
585}
586
587unsigned int ev_pending_count ()
588 C_ARGS: evapi.default_loop
589
590void ev_invoke_pending ()
591 C_ARGS: evapi.default_loop
492 592
493ev_io *io (SV *fh, int events, SV *cb) 593ev_io *io (SV *fh, int events, SV *cb)
494 ALIAS: 594 ALIAS:
495 io_ns = 1 595 io_ns = 1
596 _ae_io = 2
496 CODE: 597 CODE:
497{ 598{
498 int fd = sv_fileno (fh); 599 int fd = s_fileno (fh, events & EV_WRITE);
499 CHECK_FD (fh, fd); 600 CHECK_FD (fh, fd);
500 601
602 if (ix == 2)
603 {
604 ix = 0;
605 events = events ? EV_WRITE : EV_READ;
606 }
607
501 RETVAL = e_new (sizeof (ev_io), cb); 608 RETVAL = e_new (sizeof (ev_io), cb, default_loop_sv);
502 RETVAL->fh = newSVsv (fh); 609 e_fh (RETVAL) = newSVsv (fh);
503 ev_io_set (RETVAL, fd, events); 610 ev_io_set (RETVAL, fd, events);
504 if (!ix) START (io, RETVAL); 611 if (!ix) START (io, RETVAL);
505} 612}
506 OUTPUT: 613 OUTPUT:
507 RETVAL 614 RETVAL
510 ALIAS: 617 ALIAS:
511 timer_ns = 1 618 timer_ns = 1
512 INIT: 619 INIT:
513 CHECK_REPEAT (repeat); 620 CHECK_REPEAT (repeat);
514 CODE: 621 CODE:
515 RETVAL = e_new (sizeof (ev_timer), cb); 622 RETVAL = e_new (sizeof (ev_timer), cb, default_loop_sv);
516 ev_timer_set (RETVAL, after, repeat); 623 ev_timer_set (RETVAL, after, repeat);
517 if (!ix) START (timer, RETVAL); 624 if (!ix) START (timer, RETVAL);
518 OUTPUT: 625 OUTPUT:
519 RETVAL 626 RETVAL
520 627
524 INIT: 631 INIT:
525 CHECK_REPEAT (interval); 632 CHECK_REPEAT (interval);
526 CODE: 633 CODE:
527{ 634{
528 ev_periodic *w; 635 ev_periodic *w;
529 w = e_new (sizeof (ev_periodic), cb); 636 w = e_new (sizeof (ev_periodic), cb, default_loop_sv);
530 w->fh = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0; 637 e_fh (w) = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0;
531 ev_periodic_set (w, at, interval, w->fh ? e_periodic_cb : 0); 638 ev_periodic_set (w, at, interval, e_fh (w) ? e_periodic_cb : 0);
532 RETVAL = e_bless ((ev_watcher *)w, stash_periodic); 639 RETVAL = e_bless ((ev_watcher *)w, stash_periodic);
533 if (!ix) START (periodic, w); 640 if (!ix) START (periodic, w);
534} 641}
535 OUTPUT: 642 OUTPUT:
536 RETVAL 643 RETVAL
538ev_signal *signal (SV *signal, SV *cb) 645ev_signal *signal (SV *signal, SV *cb)
539 ALIAS: 646 ALIAS:
540 signal_ns = 1 647 signal_ns = 1
541 CODE: 648 CODE:
542{ 649{
543 Signal signum = sv_signum (signal); 650 Signal signum = s_signum (signal);
544 CHECK_SIG (signal, signum); 651 CHECK_SIG (signal, signum);
545 652
546 RETVAL = e_new (sizeof (ev_signal), cb); 653 RETVAL = e_new (sizeof (ev_signal), cb, default_loop_sv);
547 ev_signal_set (RETVAL, signum); 654 ev_signal_set (RETVAL, signum);
548 if (!ix) START (signal, RETVAL); 655 if (!ix) START_SIGNAL (RETVAL);
549} 656}
550 OUTPUT: 657 OUTPUT:
551 RETVAL 658 RETVAL
552 659
553ev_idle *idle (SV *cb) 660ev_idle *idle (SV *cb)
554 ALIAS: 661 ALIAS:
555 idle_ns = 1 662 idle_ns = 1
556 CODE: 663 CODE:
557 RETVAL = e_new (sizeof (ev_idle), cb); 664 RETVAL = e_new (sizeof (ev_idle), cb, default_loop_sv);
558 ev_idle_set (RETVAL); 665 ev_idle_set (RETVAL);
559 if (!ix) START (idle, RETVAL); 666 if (!ix) START (idle, RETVAL);
560 OUTPUT: 667 OUTPUT:
561 RETVAL 668 RETVAL
562 669
563ev_prepare *prepare (SV *cb) 670ev_prepare *prepare (SV *cb)
564 ALIAS: 671 ALIAS:
565 prepare_ns = 1 672 prepare_ns = 1
566 CODE: 673 CODE:
567 RETVAL = e_new (sizeof (ev_prepare), cb); 674 RETVAL = e_new (sizeof (ev_prepare), cb, default_loop_sv);
568 ev_prepare_set (RETVAL); 675 ev_prepare_set (RETVAL);
569 if (!ix) START (prepare, RETVAL); 676 if (!ix) START (prepare, RETVAL);
570 OUTPUT: 677 OUTPUT:
571 RETVAL 678 RETVAL
572 679
573ev_check *check (SV *cb) 680ev_check *check (SV *cb)
574 ALIAS: 681 ALIAS:
575 check_ns = 1 682 check_ns = 1
576 CODE: 683 CODE:
577 RETVAL = e_new (sizeof (ev_check), cb); 684 RETVAL = e_new (sizeof (ev_check), cb, default_loop_sv);
578 ev_check_set (RETVAL); 685 ev_check_set (RETVAL);
579 if (!ix) START (check, RETVAL); 686 if (!ix) START (check, RETVAL);
580 OUTPUT: 687 OUTPUT:
581 RETVAL 688 RETVAL
582 689
690ev_fork *fork (SV *cb)
691 ALIAS:
692 fork_ns = 1
693 CODE:
694 RETVAL = e_new (sizeof (ev_fork), cb, default_loop_sv);
695 ev_fork_set (RETVAL);
696 if (!ix) START (fork, RETVAL);
697 OUTPUT:
698 RETVAL
699
700#if EV_CHILD_ENABLE
701
583ev_child *child (int pid, SV *cb) 702ev_child *child (int pid, int trace, SV *cb)
584 ALIAS: 703 ALIAS:
585 child_ns = 1 704 child_ns = 1
586 CODE: 705 CODE:
587 RETVAL = e_new (sizeof (ev_child), cb); 706 RETVAL = e_new (sizeof (ev_child), cb, default_loop_sv);
588 ev_child_set (RETVAL, pid); 707 ev_child_set (RETVAL, pid, trace);
589 if (!ix) START (child, RETVAL); 708 if (!ix) START (child, RETVAL);
590 OUTPUT: 709 OUTPUT:
591 RETVAL 710 RETVAL
592 711
712#endif
713
593ev_stat *stat (SV *path, NV interval, SV *cb) 714ev_stat *stat (SV *path, NV interval, SV *cb)
594 ALIAS: 715 ALIAS:
595 stat_ns = 1 716 stat_ns = 1
596 CODE: 717 CODE:
597 RETVAL = e_new (sizeof (ev_stat), cb); 718 RETVAL = e_new (sizeof (ev_stat), cb, default_loop_sv);
598 RETVAL->fh = newSVsv (path); 719 e_fh (RETVAL) = newSVsv (path);
599 ev_stat_set (RETVAL, SvPVbyte_nolen (RETVAL->fh), interval); 720 ev_stat_set (RETVAL, SvPVbyte_nolen (e_fh (RETVAL)), interval);
600 if (!ix) START (stat, RETVAL); 721 if (!ix) START (stat, RETVAL);
601 OUTPUT: 722 OUTPUT:
602 RETVAL 723 RETVAL
603 724
725ev_embed *embed (struct ev_loop *loop, SV *cb = 0)
726 ALIAS:
727 embed_ns = 1
728 CODE:
729{
730 if (!(ev_backend (loop) & ev_embeddable_backends ()))
731 croak ("passed loop is not embeddable via EV::embed,");
732
733 RETVAL = e_new (sizeof (ev_embed), cb, default_loop_sv);
734 e_fh (RETVAL) = newSVsv (ST (0));
735 ev_embed_set (RETVAL, loop);
736 if (!ix) START (embed, RETVAL);
737}
738 OUTPUT:
739 RETVAL
740
741ev_async *async (SV *cb)
742 ALIAS:
743 async_ns = 1
744 CODE:
745 RETVAL = e_new (sizeof (ev_async), cb, default_loop_sv);
746 ev_async_set (RETVAL);
747 if (!ix) START (async, RETVAL);
748 OUTPUT:
749 RETVAL
750
604void once (SV *fh, int events, SV *timeout, SV *cb) 751void once (SV *fh, int events, SV *timeout, SV *cb)
605 CODE: 752 CODE:
606 ev_once ( 753 ev_once (
754 evapi.default_loop,
607 sv_fileno (fh), events, 755 s_fileno (fh, events & EV_WRITE), events,
608 SvOK (timeout) ? SvNV (timeout) : -1., 756 SvOK (timeout) ? SvNV (timeout) : -1.,
609 e_once_cb, 757 e_once_cb,
610 newSVsv (cb) 758 newSVsv (cb)
611 ); 759 );
612 760
616 764
617int ev_is_active (ev_watcher *w) 765int ev_is_active (ev_watcher *w)
618 766
619int ev_is_pending (ev_watcher *w) 767int ev_is_pending (ev_watcher *w)
620 768
769void ev_invoke (ev_watcher *w, int revents = EV_NONE)
770 C_ARGS: e_loop (w), w, revents
771
772int ev_clear_pending (ev_watcher *w)
773 C_ARGS: e_loop (w), w
774
775void ev_feed_event (ev_watcher *w, int revents = EV_NONE)
776 C_ARGS: e_loop (w), w, revents
777
621int keepalive (ev_watcher *w, int new_value = 0) 778int keepalive (ev_watcher *w, int new_value = 0)
622 CODE: 779 CODE:
623{ 780{
624 RETVAL = w->flags & WFLAG_KEEPALIVE; 781 RETVAL = w->e_flags & WFLAG_KEEPALIVE;
625 new_value = new_value ? WFLAG_KEEPALIVE : 0; 782 new_value = new_value ? WFLAG_KEEPALIVE : 0;
626 783
627 if (items > 1 && ((new_value ^ w->flags) & WFLAG_KEEPALIVE)) 784 if (items > 1 && ((new_value ^ w->e_flags) & WFLAG_KEEPALIVE))
628 { 785 {
786 w->e_flags = (w->e_flags & ~WFLAG_KEEPALIVE) | new_value;
629 REF (w); 787 REF (w);
630 w->flags = (w->flags & ~WFLAG_KEEPALIVE) | new_value;
631 UNREF (w); 788 UNREF (w);
632 } 789 }
633} 790}
634 OUTPUT: 791 OUTPUT:
635 RETVAL 792 RETVAL
636 793
637SV *cb (ev_watcher *w, SV *new_cb = 0) 794SV *cb (ev_watcher *w, SV *new_cb = 0)
638 CODE: 795 CODE:
639{ 796{
640 RETVAL = newSVsv (w->cb_sv);
641
642 if (items > 1) 797 if (items > 1)
643 sv_setsv (w->cb_sv, new_cb); 798 {
799 new_cb = s_get_cv_croak (new_cb);
800 RETVAL = newRV_noinc (w->cb_sv);
801 w->cb_sv = SvREFCNT_inc (new_cb);
802 }
803 else
804 RETVAL = newRV_inc (w->cb_sv);
644} 805}
645 OUTPUT: 806 OUTPUT:
646 RETVAL 807 RETVAL
647 808
648SV *data (ev_watcher *w, SV *new_data = 0) 809SV *data (ev_watcher *w, SV *new_data = 0)
657 } 818 }
658} 819}
659 OUTPUT: 820 OUTPUT:
660 RETVAL 821 RETVAL
661 822
662void trigger (ev_watcher *w, int revents = EV_NONE) 823SV *loop (ev_watcher *w)
663 CODE: 824 CODE:
664 w->cb (w, revents); 825 RETVAL = newRV_inc (w->loop);
826 OUTPUT:
827 RETVAL
665 828
666int priority (ev_watcher *w, int new_priority = 0) 829int priority (ev_watcher *w, int new_priority = 0)
667 CODE: 830 CODE:
668{ 831{
669 RETVAL = w->priority; 832 RETVAL = w->priority;
670 833
671 if (items > 1) 834 if (items > 1)
672 { 835 {
673 int active = ev_is_active (w); 836 int active = ev_is_active (w);
674
675 if (new_priority < EV_MINPRI || new_priority > EV_MAXPRI)
676 croak ("watcher priority out of range, value must be between %d and %d, inclusive", EV_MINPRI, EV_MAXPRI);
677 837
678 if (active) 838 if (active)
679 { 839 {
680 /* grrr. */ 840 /* grrr. */
681 PUSHMARK (SP); 841 PUSHMARK (SP);
682 XPUSHs (ST (0)); 842 XPUSHs (ST (0));
843 PUTBACK;
683 call_method ("stop", G_DISCARD | G_VOID); 844 call_method ("stop", G_DISCARD | G_VOID);
684 } 845 }
685 846
686 ev_set_priority (w, new_priority); 847 ev_set_priority (w, new_priority);
687 848
688 if (active) 849 if (active)
689 { 850 {
690 PUSHMARK (SP); 851 PUSHMARK (SP);
691 XPUSHs (ST (0)); 852 XPUSHs (ST (0));
853 PUTBACK;
692 call_method ("start", G_DISCARD | G_VOID); 854 call_method ("start", G_DISCARD | G_VOID);
693 } 855 }
694 } 856 }
695} 857}
696 OUTPUT: 858 OUTPUT:
712 e_destroy (w); 874 e_destroy (w);
713 875
714void set (ev_io *w, SV *fh, int events) 876void set (ev_io *w, SV *fh, int events)
715 CODE: 877 CODE:
716{ 878{
717 int fd = sv_fileno (fh); 879 int fd = s_fileno (fh, events & EV_WRITE);
718 CHECK_FD (fh, fd); 880 CHECK_FD (fh, fd);
719 881
720 sv_setsv (w->fh, fh); 882 sv_setsv (e_fh (w), fh);
721 RESET (io, w, (w, fd, events)); 883 RESET (io, w, (w, fd, events));
722} 884}
723 885
724SV *fh (ev_io *w, SV *new_fh = 0) 886SV *fh (ev_io *w, SV *new_fh = 0)
725 CODE: 887 CODE:
726{ 888{
727 if (items > 1) 889 if (items > 1)
728 { 890 {
729 int fd = sv_fileno (new_fh); 891 int fd = s_fileno (new_fh, w->events & EV_WRITE);
730 CHECK_FD (new_fh, fd); 892 CHECK_FD (new_fh, fd);
731 893
732 RETVAL = w->fh; 894 RETVAL = e_fh (w);
733 w->fh = newSVsv (new_fh); 895 e_fh (w) = newSVsv (new_fh);
734 896
735 RESET (io, w, (w, fd, w->events)); 897 RESET (io, w, (w, fd, w->events));
736 } 898 }
737 else 899 else
738 RETVAL = newSVsv (w->fh); 900 RETVAL = newSVsv (e_fh (w));
739} 901}
740 OUTPUT: 902 OUTPUT:
741 RETVAL 903 RETVAL
742 904
743int events (ev_io *w, int new_events = EV_UNDEF) 905int events (ev_io *w, int new_events = EV_UNDEF)
753 915
754MODULE = EV PACKAGE = EV::Signal PREFIX = ev_signal_ 916MODULE = EV PACKAGE = EV::Signal PREFIX = ev_signal_
755 917
756void ev_signal_start (ev_signal *w) 918void ev_signal_start (ev_signal *w)
757 CODE: 919 CODE:
758 START (signal, w); 920 START_SIGNAL (w);
759 921
760void ev_signal_stop (ev_signal *w) 922void ev_signal_stop (ev_signal *w)
761 CODE: 923 CODE:
762 STOP (signal, w); 924 STOP (signal, w);
763 925
767 e_destroy (w); 929 e_destroy (w);
768 930
769void set (ev_signal *w, SV *signal) 931void set (ev_signal *w, SV *signal)
770 CODE: 932 CODE:
771{ 933{
772 Signal signum = sv_signum (signal); 934 Signal signum = s_signum (signal);
773 CHECK_SIG (signal, signum); 935 CHECK_SIG (signal, signum);
774 936
775 RESET (signal, w, (w, signum)); 937 RESET_SIGNAL (w, (w, signum));
776} 938}
777 939
778int signal (ev_signal *w, SV *new_signal = 0) 940int signal (ev_signal *w, SV *new_signal = 0)
779 CODE: 941 CODE:
780{ 942{
781 RETVAL = w->signum; 943 RETVAL = w->signum;
782 944
783 if (items > 1) 945 if (items > 1)
784 { 946 {
785 Signal signum = sv_signum (new_signal); 947 Signal signum = s_signum (new_signal);
786 CHECK_SIG (new_signal, signum); 948 CHECK_SIG (new_signal, signum);
787 949
788 RESET (signal, w, (w, signum)); 950 RESET_SIGNAL (w, (w, signum));
789 } 951 }
790} 952}
791 OUTPUT: 953 OUTPUT:
792 RETVAL 954 RETVAL
793 955
805 967
806void ev_timer_again (ev_timer *w) 968void ev_timer_again (ev_timer *w)
807 INIT: 969 INIT:
808 CHECK_REPEAT (w->repeat); 970 CHECK_REPEAT (w->repeat);
809 CODE: 971 CODE:
810 REF (w);
811 ev_timer_again (w); 972 ev_timer_again (e_loop (w), w);
812 UNREF (w); 973 UNREF (w);
974
975NV ev_timer_remaining (ev_timer *w)
976 C_ARGS: e_loop (w), w
813 977
814void DESTROY (ev_timer *w) 978void DESTROY (ev_timer *w)
815 CODE: 979 CODE:
816 STOP (timer, w); 980 STOP (timer, w);
817 e_destroy (w); 981 e_destroy (w);
834 CODE: 998 CODE:
835 STOP (periodic, w); 999 STOP (periodic, w);
836 1000
837void ev_periodic_again (ev_periodic *w) 1001void ev_periodic_again (ev_periodic *w)
838 CODE: 1002 CODE:
839 REF (w);
840 ev_periodic_again (w); 1003 ev_periodic_again (e_loop (w), w);
841 UNREF (w); 1004 UNREF (w);
842 1005
843void DESTROY (ev_periodic *w) 1006void DESTROY (ev_periodic *w)
844 CODE: 1007 CODE:
845 STOP (periodic, w); 1008 STOP (periodic, w);
848void set (ev_periodic *w, NV at, NV interval = 0., SV *reschedule_cb = &PL_sv_undef) 1011void set (ev_periodic *w, NV at, NV interval = 0., SV *reschedule_cb = &PL_sv_undef)
849 INIT: 1012 INIT:
850 CHECK_REPEAT (interval); 1013 CHECK_REPEAT (interval);
851 CODE: 1014 CODE:
852{ 1015{
853 SvREFCNT_dec (w->fh); 1016 SvREFCNT_dec (e_fh (w));
854 w->fh = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0; 1017 e_fh (w) = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0;
855 1018
856 RESET (periodic, w, (w, at, interval, w->fh ? e_periodic_cb : 0)); 1019 RESET (periodic, w, (w, at, interval, e_fh (w) ? e_periodic_cb : 0));
857} 1020}
1021
1022NV at (ev_periodic *w)
1023 CODE:
1024 RETVAL = ev_periodic_at (w);
1025 OUTPUT:
1026 RETVAL
858 1027
859MODULE = EV PACKAGE = EV::Idle PREFIX = ev_idle_ 1028MODULE = EV PACKAGE = EV::Idle PREFIX = ev_idle_
860 1029
861void ev_idle_start (ev_idle *w) 1030void ev_idle_start (ev_idle *w)
862 CODE: 1031 CODE:
869void DESTROY (ev_idle *w) 1038void DESTROY (ev_idle *w)
870 CODE: 1039 CODE:
871 STOP (idle, w); 1040 STOP (idle, w);
872 e_destroy (w); 1041 e_destroy (w);
873 1042
874MODULE = EV PACKAGE = EV::Prepare PREFIX = ev_check_ 1043MODULE = EV PACKAGE = EV::Prepare PREFIX = ev_prepare_
875 1044
876void ev_prepare_start (ev_prepare *w) 1045void ev_prepare_start (ev_prepare *w)
877 CODE: 1046 CODE:
878 START (prepare, w); 1047 START (prepare, w);
879 1048
899void DESTROY (ev_check *w) 1068void DESTROY (ev_check *w)
900 CODE: 1069 CODE:
901 STOP (check, w); 1070 STOP (check, w);
902 e_destroy (w); 1071 e_destroy (w);
903 1072
1073MODULE = EV PACKAGE = EV::Fork PREFIX = ev_fork_
1074
1075void ev_fork_start (ev_fork *w)
1076 CODE:
1077 START (fork, w);
1078
1079void ev_fork_stop (ev_fork *w)
1080 CODE:
1081 STOP (fork, w);
1082
1083void DESTROY (ev_fork *w)
1084 CODE:
1085 STOP (fork, w);
1086 e_destroy (w);
1087
904MODULE = EV PACKAGE = EV::Child PREFIX = ev_child_ 1088MODULE = EV PACKAGE = EV::Child PREFIX = ev_child_
1089
1090#if EV_CHILD_ENABLE
905 1091
906void ev_child_start (ev_child *w) 1092void ev_child_start (ev_child *w)
907 CODE: 1093 CODE:
908 START (child, w); 1094 START (child, w);
909 1095
914void DESTROY (ev_child *w) 1100void DESTROY (ev_child *w)
915 CODE: 1101 CODE:
916 STOP (child, w); 1102 STOP (child, w);
917 e_destroy (w); 1103 e_destroy (w);
918 1104
919void set (ev_child *w, int pid) 1105void set (ev_child *w, int pid, int trace)
920 CODE: 1106 CODE:
921 RESET (child, w, (w, pid)); 1107 RESET (child, w, (w, pid, trace));
922 1108
923int pid (ev_child *w, int new_pid = 0)
924 CODE:
925{
926 RETVAL = w->pid;
927
928 if (items > 1)
929 RESET (child, w, (w, new_pid));
930}
931 OUTPUT:
932 RETVAL
933
934
935int rstatus (ev_child *w) 1109int pid (ev_child *w)
936 ALIAS: 1110 ALIAS:
937 rpid = 1 1111 rpid = 1
1112 rstatus = 2
938 CODE: 1113 CODE:
939 RETVAL = ix ? w->rpid : w->rstatus; 1114 RETVAL = ix == 0 ? w->pid
1115 : ix == 1 ? w->rpid
1116 : w->rstatus;
940 OUTPUT: 1117 OUTPUT:
941 RETVAL 1118 RETVAL
1119
1120#endif
942 1121
943MODULE = EV PACKAGE = EV::Stat PREFIX = ev_stat_ 1122MODULE = EV PACKAGE = EV::Stat PREFIX = ev_stat_
944 1123
945void ev_stat_start (ev_stat *w) 1124void ev_stat_start (ev_stat *w)
946 CODE: 1125 CODE:
956 e_destroy (w); 1135 e_destroy (w);
957 1136
958void set (ev_stat *w, SV *path, NV interval) 1137void set (ev_stat *w, SV *path, NV interval)
959 CODE: 1138 CODE:
960{ 1139{
961 sv_setsv (w->fh, path); 1140 sv_setsv (e_fh (w), path);
962 RESET (stat, w, (w, SvPVbyte_nolen (w->fh), interval)); 1141 RESET (stat, w, (w, SvPVbyte_nolen (e_fh (w)), interval));
963} 1142}
964 1143
965SV *path (ev_stat *w, SV *new_path = 0) 1144SV *path (ev_stat *w, SV *new_path = 0)
966 CODE: 1145 CODE:
967{ 1146{
968 RETVAL = SvREFCNT_inc (w->fh); 1147 RETVAL = SvREFCNT_inc (e_fh (w));
969 1148
970 if (items > 1) 1149 if (items > 1)
971 { 1150 {
972 SvREFCNT_dec (w->fh); 1151 SvREFCNT_dec (e_fh (w));
973 w->fh = newSVsv (new_path); 1152 e_fh (w) = newSVsv (new_path);
974 RESET (stat, w, (w, SvPVbyte_nolen (w->fh), w->interval)); 1153 RESET (stat, w, (w, SvPVbyte_nolen (e_fh (w)), w->interval));
975 } 1154 }
976} 1155}
977 OUTPUT: 1156 OUTPUT:
978 RETVAL 1157 RETVAL
979 1158
981 CODE: 1160 CODE:
982{ 1161{
983 RETVAL = w->interval; 1162 RETVAL = w->interval;
984 1163
985 if (items > 1) 1164 if (items > 1)
986 RESET (stat, w, (w, SvPVbyte_nolen (w->fh), new_interval)); 1165 RESET (stat, w, (w, SvPVbyte_nolen (e_fh (w)), new_interval));
987} 1166}
988 OUTPUT: 1167 OUTPUT:
989 RETVAL 1168 RETVAL
990 1169
991void prev (ev_stat *w) 1170void prev (ev_stat *w)
995 PPCODE: 1174 PPCODE:
996{ 1175{
997 ev_statdata *s = ix ? &w->attr : &w->prev; 1176 ev_statdata *s = ix ? &w->attr : &w->prev;
998 1177
999 if (ix == 1) 1178 if (ix == 1)
1000 ev_stat_stat (w); 1179 ev_stat_stat (e_loop (w), w);
1001 else if (!s->st_nlink) 1180 else if (!s->st_nlink)
1002 errno = ENOENT; 1181 errno = ENOENT;
1003 1182
1004 PL_statcache.st_dev = s->st_nlink; 1183 PL_statcache.st_dev = s->st_nlink;
1005 PL_statcache.st_ino = s->st_ino; 1184 PL_statcache.st_ino = s->st_ino;
1032 PUSHs (sv_2mortal (newSVuv (4096))); 1211 PUSHs (sv_2mortal (newSVuv (4096)));
1033 PUSHs (sv_2mortal (newSVnv ((NV)((s->st_size + 4095) / 4096)))); 1212 PUSHs (sv_2mortal (newSVnv ((NV)((s->st_size + 4095) / 4096))));
1034 } 1213 }
1035} 1214}
1036 1215
1037#ifndef _WIN32
1038
1039MODULE = EV PACKAGE = EV::DNS PREFIX = evdns_ 1216MODULE = EV PACKAGE = EV::Embed PREFIX = ev_embed_
1040 1217
1041BOOT: 1218void ev_embed_start (ev_embed *w)
1042{ 1219 CODE:
1043 HV *stash = gv_stashpv ("EV::DNS", 1); 1220 START (embed, w);
1044 1221
1045 static const struct { 1222void ev_embed_stop (ev_embed *w)
1046 const char *name; 1223 CODE:
1047 IV iv; 1224 STOP (embed, w);
1048 } *civ, const_iv[] = {
1049# define const_iv(pfx, name) { # name, (IV) pfx ## name },
1050 const_iv (DNS_, ERR_NONE)
1051 const_iv (DNS_, ERR_FORMAT)
1052 const_iv (DNS_, ERR_SERVERFAILED)
1053 const_iv (DNS_, ERR_NOTEXIST)
1054 const_iv (DNS_, ERR_NOTIMPL)
1055 const_iv (DNS_, ERR_REFUSED)
1056 const_iv (DNS_, ERR_TRUNCATED)
1057 const_iv (DNS_, ERR_UNKNOWN)
1058 const_iv (DNS_, ERR_TIMEOUT)
1059 const_iv (DNS_, ERR_SHUTDOWN)
1060 const_iv (DNS_, IPv4_A)
1061 const_iv (DNS_, PTR)
1062 const_iv (DNS_, IPv6_AAAA)
1063 const_iv (DNS_, QUERY_NO_SEARCH)
1064 const_iv (DNS_, OPTION_SEARCH)
1065 const_iv (DNS_, OPTION_NAMESERVERS)
1066 const_iv (DNS_, OPTION_MISC)
1067 const_iv (DNS_, OPTIONS_ALL)
1068 const_iv (DNS_, NO_SEARCH)
1069 };
1070 1225
1071 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 1226void DESTROY (ev_embed *w)
1072 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 1227 CODE:
1073} 1228 STOP (embed, w);
1229 e_destroy (w);
1074 1230
1075int evdns_init () 1231void set (ev_embed *w, struct ev_loop *loop)
1232 CODE:
1233{
1234 sv_setsv (e_fh (w), ST (1));
1235 RESET (embed, w, (w, loop));
1236}
1076 1237
1077void evdns_shutdown (int fail_requests = 1) 1238SV *other (ev_embed *w)
1239 CODE:
1240 RETVAL = newSVsv (e_fh (w));
1241 OUTPUT:
1242 RETVAL
1078 1243
1079const char *evdns_err_to_string (int err) 1244void ev_embed_sweep (ev_embed *w)
1245 C_ARGS: e_loop (w), w
1080 1246
1081int evdns_nameserver_add (U32 address) 1247MODULE = EV PACKAGE = EV::Async PREFIX = ev_async_
1082 1248
1083int evdns_count_nameservers () 1249void ev_async_start (ev_async *w)
1250 CODE:
1251 START (async, w);
1084 1252
1085int evdns_clear_nameservers_and_suspend () 1253void ev_async_stop (ev_async *w)
1254 CODE:
1255 STOP (async, w);
1086 1256
1087int evdns_resume () 1257void DESTROY (ev_async *w)
1258 CODE:
1259 STOP (async, w);
1260 e_destroy (w);
1088 1261
1089int evdns_nameserver_ip_add (char *ip_as_string) 1262void ev_async_send (ev_async *w)
1263 C_ARGS: e_loop (w), w
1090 1264
1091int evdns_resolve_ipv4 (const char *name, int flags, SV *cb) 1265SV *ev_async_async_pending (ev_async *w)
1092 C_ARGS: name, flags, dns_cb, (void *)SvREFCNT_inc (cb)
1093
1094int evdns_resolve_ipv6 (const char *name, int flags, SV *cb)
1095 C_ARGS: name, flags, dns_cb, (void *)SvREFCNT_inc (cb)
1096
1097int evdns_resolve_reverse (SV *addr, int flags, SV *cb)
1098 ALIAS:
1099 evdns_resolve_reverse_ipv6 = 1
1100 CODE: 1266 CODE:
1101{ 1267 RETVAL = boolSV (ev_async_pending (w));
1102 STRLEN len; 1268 OUTPUT:
1103 char *data = SvPVbyte (addr, len);
1104 if (len != (ix ? 16 : 4))
1105 croak ("ipv4/ipv6 address to be resolved must be given as 4/16 byte octet string");
1106
1107 RETVAL = ix 1269 RETVAL
1108 ? evdns_resolve_reverse_ipv6 ((struct in6_addr *)data, flags, dns_cb, (void *)SvREFCNT_inc (cb))
1109 : evdns_resolve_reverse ((struct in_addr *)data, flags, dns_cb, (void *)SvREFCNT_inc (cb));
1110}
1111 OUTPUT:
1112 RETVAL
1113 1270
1114int evdns_set_option (char *option, char *val, int flags) 1271MODULE = EV PACKAGE = EV::Loop PREFIX = ev_
1115 1272
1116int evdns_resolv_conf_parse (int flags, const char *filename) 1273SV *new (SV *klass, unsigned int flags = 0)
1274 CODE:
1275{
1276 struct ev_loop *loop = ev_loop_new (flags);
1117 1277
1118#ifdef _WIN32 1278 if (!loop)
1279 XSRETURN_UNDEF;
1119 1280
1120int evdns_config_windows_nameservers () 1281 RETVAL = sv_bless (newRV_noinc (newSViv (PTR2IV (loop))), stash_loop);
1282}
1283 OUTPUT:
1284 RETVAL
1285
1286void DESTROY (struct ev_loop *loop)
1287 CODE:
1288 if (loop != evapi.default_loop) /* global destruction sucks */
1289 ev_loop_destroy (loop);
1290
1291void ev_loop_fork (struct ev_loop *loop)
1292
1293void ev_verify (struct ev_loop *loop)
1294
1295NV ev_now (struct ev_loop *loop)
1296
1297void ev_now_update (struct ev_loop *loop)
1298
1299void ev_suspend (struct ev_loop *loop)
1300
1301void ev_resume (struct ev_loop *loop)
1302
1303void ev_set_io_collect_interval (struct ev_loop *loop, NV interval)
1304
1305void ev_set_timeout_collect_interval (struct ev_loop *loop, NV interval)
1306
1307unsigned int ev_backend (struct ev_loop *loop)
1308
1309unsigned int ev_iteration (struct ev_loop *loop)
1310
1311unsigned int ev_depth (struct ev_loop *loop)
1312
1313void ev_loop (struct ev_loop *loop, int flags = 0)
1314
1315void ev_unloop (struct ev_loop *loop, int how = 1)
1316
1317void ev_feed_fd_event (struct ev_loop *loop, int fd, int revents = EV_NONE)
1318
1319unsigned int ev_pending_count (struct ev_loop *loop)
1320
1321void ev_invoke_pending (struct ev_loop *loop)
1322
1323#if 0
1324
1325void ev_feed_signal_event (struct ev_loop *loop, SV *signal)
1326 CODE:
1327{
1328 Signal signum = s_signum (signal);
1329 CHECK_SIG (signal, signum);
1330
1331 ev_feed_signal_event (loop, signum);
1332}
1121 1333
1122#endif 1334#endif
1123 1335
1124void evdns_search_clear () 1336ev_io *io (struct ev_loop *loop, SV *fh, int events, SV *cb)
1125 1337 ALIAS:
1126void evdns_search_add (char *domain) 1338 io_ns = 1
1127 1339 CODE:
1128void evdns_search_ndots_set (int ndots)
1129
1130#if 0
1131
1132MODULE = EV PACKAGE = EV::HTTP PREFIX = evhttp_
1133
1134BOOT:
1135{ 1340{
1136 HV *stash = gv_stashpv ("EV::HTTP", 1); 1341 int fd = s_fileno (fh, events & EV_WRITE);
1342 CHECK_FD (fh, fd);
1137 1343
1138 static const struct { 1344 RETVAL = e_new (sizeof (ev_io), cb, ST (0));
1139 const char *name; 1345 e_fh (RETVAL) = newSVsv (fh);
1140 IV iv; 1346 ev_io_set (RETVAL, fd, events);
1141 } *civ, const_iv[] = { 1347 if (!ix) START (io, RETVAL);
1142# define const_iv(pfx, name) { # name, (IV) pfx ## name },
1143 const_iv (HTTP_, OK)
1144 const_iv (HTTP_, NOCONTENT)
1145 const_iv (HTTP_, MOVEPERM)
1146 const_iv (HTTP_, MOVETEMP)
1147 const_iv (HTTP_, NOTMODIFIED)
1148 const_iv (HTTP_, BADREQUEST)
1149 const_iv (HTTP_, NOTFOUND)
1150 const_iv (HTTP_, SERVUNAVAIL)
1151 const_iv (EVHTTP_, REQ_OWN_CONNECTION)
1152 const_iv (EVHTTP_, PROXY_REQUEST)
1153 const_iv (EVHTTP_, REQ_GET)
1154 const_iv (EVHTTP_, REQ_POST)
1155 const_iv (EVHTTP_, REQ_HEAD)
1156 const_iv (EVHTTP_, REQUEST)
1157 const_iv (EVHTTP_, RESPONSE)
1158 };
1159
1160 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1161 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
1162} 1348}
1349 OUTPUT:
1350 RETVAL
1163 1351
1164MODULE = EV PACKAGE = EV::HTTP::Request PREFIX = evhttp_request_ 1352ev_timer *timer (struct ev_loop *loop, NV after, NV repeat, SV *cb)
1353 ALIAS:
1354 timer_ns = 1
1355 INIT:
1356 CHECK_REPEAT (repeat);
1357 CODE:
1358 RETVAL = e_new (sizeof (ev_timer), cb, ST (0));
1359 ev_timer_set (RETVAL, after, repeat);
1360 if (!ix) START (timer, RETVAL);
1361 OUTPUT:
1362 RETVAL
1165 1363
1166#HttpRequest new (SV *klass, SV *cb) 1364SV *periodic (struct ev_loop *loop, NV at, NV interval, SV *reschedule_cb, SV *cb)
1365 ALIAS:
1366 periodic_ns = 1
1367 INIT:
1368 CHECK_REPEAT (interval);
1369 CODE:
1370{
1371 ev_periodic *w;
1372 w = e_new (sizeof (ev_periodic), cb, ST (0));
1373 e_fh (w) = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0;
1374 ev_periodic_set (w, at, interval, e_fh (w) ? e_periodic_cb : 0);
1375 RETVAL = e_bless ((ev_watcher *)w, stash_periodic);
1376 if (!ix) START (periodic, w);
1377}
1378 OUTPUT:
1379 RETVAL
1167 1380
1168#void DESTROY (struct evhttp_request *req); 1381ev_signal *signal (struct ev_loop *loop, SV *signal, SV *cb)
1382 ALIAS:
1383 signal_ns = 1
1384 CODE:
1385{
1386 Signal signum = s_signum (signal);
1387 CHECK_SIG (signal, signum);
1388
1389 RETVAL = e_new (sizeof (ev_signal), cb, ST (0));
1390 ev_signal_set (RETVAL, signum);
1391 if (!ix) START_SIGNAL (RETVAL);
1392}
1393 OUTPUT:
1394 RETVAL
1395
1396ev_idle *idle (struct ev_loop *loop, SV *cb)
1397 ALIAS:
1398 idle_ns = 1
1399 CODE:
1400 RETVAL = e_new (sizeof (ev_idle), cb, ST (0));
1401 ev_idle_set (RETVAL);
1402 if (!ix) START (idle, RETVAL);
1403 OUTPUT:
1404 RETVAL
1405
1406ev_prepare *prepare (struct ev_loop *loop, SV *cb)
1407 ALIAS:
1408 prepare_ns = 1
1409 CODE:
1410 RETVAL = e_new (sizeof (ev_prepare), cb, ST (0));
1411 ev_prepare_set (RETVAL);
1412 if (!ix) START (prepare, RETVAL);
1413 OUTPUT:
1414 RETVAL
1415
1416ev_check *check (struct ev_loop *loop, SV *cb)
1417 ALIAS:
1418 check_ns = 1
1419 CODE:
1420 RETVAL = e_new (sizeof (ev_check), cb, ST (0));
1421 ev_check_set (RETVAL);
1422 if (!ix) START (check, RETVAL);
1423 OUTPUT:
1424 RETVAL
1425
1426ev_fork *fork (struct ev_loop *loop, SV *cb)
1427 ALIAS:
1428 fork_ns = 1
1429 CODE:
1430 RETVAL = e_new (sizeof (ev_fork), cb, ST (0));
1431 ev_fork_set (RETVAL);
1432 if (!ix) START (fork, RETVAL);
1433 OUTPUT:
1434 RETVAL
1435
1436#if EV_CHILD_ENABLE
1437
1438ev_child *child (struct ev_loop *loop, int pid, int trace, SV *cb)
1439 ALIAS:
1440 child_ns = 1
1441 CODE:
1442 RETVAL = e_new (sizeof (ev_child), cb, ST (0));
1443 ev_child_set (RETVAL, pid, trace);
1444 if (!ix) START (child, RETVAL);
1445 OUTPUT:
1446 RETVAL
1169 1447
1170#endif 1448#endif
1171 1449
1172#endif 1450ev_stat *stat (struct ev_loop *loop, SV *path, NV interval, SV *cb)
1451 ALIAS:
1452 stat_ns = 1
1453 CODE:
1454 RETVAL = e_new (sizeof (ev_stat), cb, ST (0));
1455 e_fh (RETVAL) = newSVsv (path);
1456 ev_stat_set (RETVAL, SvPVbyte_nolen (e_fh (RETVAL)), interval);
1457 if (!ix) START (stat, RETVAL);
1458 OUTPUT:
1459 RETVAL
1173 1460
1461ev_embed *embed (struct ev_loop *loop, struct ev_loop *other, SV *cb = 0)
1462 ALIAS:
1463 embed_ns = 1
1464 CODE:
1465{
1466 if (!(ev_backend (other) & ev_embeddable_backends ()))
1467 croak ("passed loop is not embeddable via EV::embed,");
1174 1468
1469 RETVAL = e_new (sizeof (ev_embed), cb, ST (0));
1470 e_fh (RETVAL) = newSVsv (ST (1));
1471 ev_embed_set (RETVAL, other);
1472 if (!ix) START (embed, RETVAL);
1473}
1474 OUTPUT:
1475 RETVAL
1175 1476
1477ev_async *async (struct ev_loop *loop, SV *cb)
1478 ALIAS:
1479 async_ns = 1
1480 CODE:
1481 RETVAL = e_new (sizeof (ev_async), cb, ST (0));
1482 ev_async_set (RETVAL);
1483 if (!ix) START (async, RETVAL);
1484 OUTPUT:
1485 RETVAL
1176 1486
1487void once (struct ev_loop *loop, SV *fh, int events, SV *timeout, SV *cb)
1488 CODE:
1489 ev_once (
1490 loop,
1491 s_fileno (fh, events & EV_WRITE), events,
1492 SvOK (timeout) ? SvNV (timeout) : -1.,
1493 e_once_cb,
1494 newSVsv (cb)
1495 );
1177 1496
1178
1179

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines