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

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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines