ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/EV/EV.xs
Revision: 1.146
Committed: Sun Oct 24 20:05:43 2010 UTC (13 years, 6 months ago) by root
Branch: MAIN
CVS Tags: rel-4_00
Changes since 1.145: +6 -0 lines
Log Message:
*** empty log message ***

File Contents

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