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

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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines