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

Comparing EV/EV.xs (file contents):
Revision 1.7 by root, Sat Oct 27 14:54:21 2007 UTC vs.
Revision 1.14 by root, Tue Oct 30 12:48:29 2007 UTC

… …
23#define EV_NONE 0 23#define EV_NONE 0
24#define EV_UNDEF -1 24#define EV_UNDEF -1
25 25
26#define TIMEOUT_NONE HUGE_VAL 26#define TIMEOUT_NONE HUGE_VAL
27 27
28#include "EV/EVAPI.h"
29
28typedef struct event_base *Base; 30typedef struct event_base *Base;
31typedef int Signal;
32
33static struct EVAPI evapi;
29 34
30static HV *stash_base, *stash_event; 35static HV *stash_base, *stash_event;
31 36
32static double tv_get (struct timeval *tv) 37static double tv_get (struct timeval *tv)
33{ 38{
… …
37static void tv_set (struct timeval *tv, double val) 42static void tv_set (struct timeval *tv, double val)
38{ 43{
39 tv->tv_sec = (long)val; 44 tv->tv_sec = (long)val;
40 tv->tv_usec = (long)((val - (double)tv->tv_sec) * 1e6); 45 tv->tv_usec = (long)((val - (double)tv->tv_sec) * 1e6);
41 46
47}
48
49static int
50sv_signum (SV *sig)
51{
52 int signum;
53
54 if (SvIV (sig) > 0)
55 return SvIV (sig);
56
57 for (signum = 1; signum < SIG_SIZE; ++signum)
58 if (strEQ (SvPV_nolen (sig), PL_sig_name [signum]))
59 return signum;
60
61 return -1;
62}
63
64static void
65api_once (int fd, short events, double timeout, void (*cb)(int, short, void *), void *arg)
66{
67 if (timeout >= 0.)
68 {
69 struct timeval tv;
70 tv_set (&tv, timeout);
71 event_once (fd, events, cb, arg, &tv);
72 }
73 else
74 event_once (fd, events, cb, arg, 0);
42} 75}
43 76
44///////////////////////////////////////////////////////////////////////////// 77/////////////////////////////////////////////////////////////////////////////
45// Event 78// Event
46 79
… …
53 unsigned char active; 86 unsigned char active;
54 unsigned char abstime; 87 unsigned char abstime;
55} *Event; 88} *Event;
56 89
57static double 90static double
58e_now () 91e_now (void)
59{ 92{
60 struct timeval tv; 93 struct timeval tv;
61 gettimeofday (&tv, 0); 94 gettimeofday (&tv, 0);
62 95
63 return tv_get (&tv); 96 return tv_get (&tv);
… …
165static void 198static void
166e_cb (int fd, short events, void *arg) 199e_cb (int fd, short events, void *arg)
167{ 200{
168 struct ev *ev = (struct ev*)arg; 201 struct ev *ev = (struct ev*)arg;
169 dSP; 202 dSP;
170 203 I32 mark = SP - PL_stack_base;
171 ENTER; 204 SV *sv_self, *sv_events;
172 SAVETMPS; 205 static SV *sv_events_cache;
173 206
174 if (!(ev->ev.ev_events & EV_PERSIST) || (events & EV_TIMEOUT)) 207 if (!(ev->ev.ev_events & EV_PERSIST) || (events & EV_TIMEOUT))
175 ev->active = 0; 208 ev->active = 0;
176 209
210 sv_self = e_self (ev);
211
212 if (sv_events_cache)
213 {
214 sv_events = sv_events_cache; sv_events_cache = 0;
215 SvIV_set (sv_events, events);
216 }
217 else
218 sv_events = newSViv (events);
219
177 PUSHMARK (SP); 220 PUSHMARK (SP);
178 EXTEND (SP, 2); 221 EXTEND (SP, 2);
179 PUSHs (sv_2mortal (e_self (ev))); 222 PUSHs (sv_self);
180 PUSHs (sv_2mortal (newSViv (events))); 223 PUSHs (sv_events);
181 PUTBACK; 224 PUTBACK;
182 call_sv (ev->cb, G_DISCARD | G_VOID | G_EVAL); 225 call_sv (ev->cb, G_DISCARD | G_VOID | G_EVAL);
183 /*TODO: if err, call some logging function */ 226 SP = PL_stack_base + mark; PUTBACK;
227
228 SvREFCNT_dec (sv_self);
229
230 if (sv_events_cache)
231 SvREFCNT_dec (sv_events);
232 else
233 sv_events_cache = sv_events;
184 234
185 if (ev->interval && !ev->active) 235 if (ev->interval && !ev->active)
186 e_start (ev); 236 e_start (ev);
187 237
188 FREETMPS; 238 if (SvTRUE (ERRSV))
189 LEAVE; 239 {
240 PUSHMARK (SP);
241 PUTBACK;
242 call_sv (get_sv ("EV::DIED", 1), G_DISCARD | G_VOID | G_EVAL | G_KEEPERR);
243 SP = PL_stack_base + mark; PUTBACK;
244 }
190} 245}
191 246
192///////////////////////////////////////////////////////////////////////////// 247/////////////////////////////////////////////////////////////////////////////
193// DNS 248// DNS
194 249
… …
228 283
229 PUTBACK; 284 PUTBACK;
230 call_sv (sv_2mortal (cb), G_DISCARD | G_VOID | G_EVAL); 285 call_sv (sv_2mortal (cb), G_DISCARD | G_VOID | G_EVAL);
231 286
232 FREETMPS; 287 FREETMPS;
288
289 if (SvTRUE (ERRSV))
290 {
291 PUSHMARK (SP);
292 PUTBACK;
293 call_sv (get_sv ("EV::DIED", 1), G_DISCARD | G_VOID | G_EVAL | G_KEEPERR);
294 }
295
233 LEAVE; 296 LEAVE;
234} 297}
235 298
236///////////////////////////////////////////////////////////////////////////// 299/////////////////////////////////////////////////////////////////////////////
237// XS interface functions 300// XS interface functions
238 301
239MODULE = EV PACKAGE = EV PREFIX = event_ 302MODULE = EV PACKAGE = EV PREFIX = event_
240 303
241BOOT: 304BOOT:
242{ 305{
306 int i;
243 HV *stash = gv_stashpv ("EV", 1); 307 HV *stash = gv_stashpv ("EV", 1);
244 308
245 static const struct { 309 static const struct {
246 const char *name; 310 const char *name;
247 IV iv; 311 IV iv;
… …
265 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 329 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
266 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 330 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
267 331
268 stash_base = gv_stashpv ("EV::Base" , 1); 332 stash_base = gv_stashpv ("EV::Base" , 1);
269 stash_event = gv_stashpv ("EV::Event", 1); 333 stash_event = gv_stashpv ("EV::Event", 1);
334
335 {
336 SV *sv = perl_get_sv ("EV::API", TRUE);
337 perl_get_sv ("EV::API", TRUE); /* silence 5.10 warning */
338
339 evapi.ver = EV_API_VERSION;
340 evapi.rev = EV_API_REVISION;
341 evapi.now = e_now;
342 evapi.once = api_once;
343 evapi.loop = event_loop;
344
345 sv_setiv (sv, (IV)&evapi);
346 SvREADONLY_on (sv);
347 }
270} 348}
271 349
272double now () 350double now ()
273 CODE: 351 CODE:
274 RETVAL = e_now (); 352 RETVAL = e_now ();
… …
309 ALIAS: 387 ALIAS:
310 io_ns = 1 388 io_ns = 1
311 CODE: 389 CODE:
312 RETVAL = e_new (fh, events, cb); 390 RETVAL = e_new (fh, events, cb);
313 if (!ix) e_start (RETVAL); 391 if (!ix) e_start (RETVAL);
392 OUTPUT:
393 RETVAL
394
395Event timed_io (SV *fh, short events, double timeout, SV *cb)
396 ALIAS:
397 timed_io_ns = 1
398 CODE:
399{
400 events = timeout ? events & ~EV_PERSIST : events | EV_PERSIST;
401
402 RETVAL = e_new (fh, events, cb);
403
404 if (timeout)
405 {
406 RETVAL->timeout = timeout;
407 RETVAL->interval = 1;
408 }
409
410 if (!ix) e_start (RETVAL);
411}
314 OUTPUT: 412 OUTPUT:
315 RETVAL 413 RETVAL
316 414
317Event timer (double after, int repeat, SV *cb) 415Event timer (double after, int repeat, SV *cb)
318 ALIAS: 416 ALIAS:
… …
335 RETVAL->abstime = 1; 433 RETVAL->abstime = 1;
336 if (!ix) e_start (RETVAL); 434 if (!ix) e_start (RETVAL);
337 OUTPUT: 435 OUTPUT:
338 RETVAL 436 RETVAL
339 437
340Event signal (SV *signal, SV *cb) 438Event signal (Signal signum, SV *cb)
341 ALIAS: 439 ALIAS:
342 signal_ns = 1 440 signal_ns = 1
343 CODE: 441 CODE:
344 RETVAL = e_new (signal, EV_SIGNAL | EV_PERSIST, cb); 442 RETVAL = e_new (ST (0), EV_SIGNAL | EV_PERSIST, cb);
443 RETVAL->ev.ev_fd = signum;
345 if (!ix) e_start (RETVAL); 444 if (!ix) e_start (RETVAL);
346 OUTPUT: 445 OUTPUT:
347 RETVAL 446 RETVAL
348 447
349PROTOTYPES: DISABLE 448PROTOTYPES: DISABLE
… …
420 sv_setsv (ev->cb, new_cb); 519 sv_setsv (ev->cb, new_cb);
421 OUTPUT: 520 OUTPUT:
422 RETVAL 521 RETVAL
423 522
424SV *fh (Event ev, SV *new_fh = 0) 523SV *fh (Event ev, SV *new_fh = 0)
425 ALIAS:
426 signal = 0
427 CODE: 524 CODE:
428 RETVAL = newSVsv (ev->fh); 525 RETVAL = newSVsv (ev->fh);
429 if (items > 1) 526 if (items > 1)
430 { 527 {
431 if (ev->active) event_del (&ev->ev); 528 if (ev->active) event_del (&ev->ev);
432 sv_setsv (ev->fh, new_fh); 529 sv_setsv (ev->fh, new_fh);
433 ev->ev.ev_fd = sv_fileno (ev->fh); 530 ev->ev.ev_fd = sv_fileno (ev->fh);
531 ev->ev.ev_events &= ev->ev.ev_events & ~EV_SIGNAL;
434 if (ev->active) event_add (&ev->ev, e_tv (ev)); 532 if (ev->active) event_add (&ev->ev, e_tv (ev));
435 } 533 }
534 OUTPUT:
535 RETVAL
536
537SV *signal (Event ev, SV *new_signal = 0)
538 CODE:
539{
540 Signal signum;
541
542 if (items > 1)
543 signum = sv_signum (new_signal); /* may croak here */
544
545 RETVAL = newSVsv (ev->fh);
546
547 if (items > 1)
548 {
549 if (ev->active) event_del (&ev->ev);
550 sv_setsv (ev->fh, new_signal);
551 ev->ev.ev_fd = signum;
552 ev->ev.ev_events |= EV_SIGNAL;
553 if (ev->active) event_add (&ev->ev, e_tv (ev));
554 }
555}
436 OUTPUT: 556 OUTPUT:
437 RETVAL 557 RETVAL
438 558
439short events (Event ev, short new_events = EV_UNDEF) 559short events (Event ev, short new_events = EV_UNDEF)
440 CODE: 560 CODE:
… …
535 CODE: 655 CODE:
536{ 656{
537 STRLEN len; 657 STRLEN len;
538 char *data = SvPVbyte (addr, len); 658 char *data = SvPVbyte (addr, len);
539 if (len != (ix ? 16 : 4)) 659 if (len != (ix ? 16 : 4))
540 croak ("ipv4/ipv6 address to resolve must be given as 4/16 byte octet string"); 660 croak ("ipv4/ipv6 address to be resolved must be given as 4/16 byte octet string");
541 661
542 RETVAL = ix 662 RETVAL = ix
543 ? evdns_resolve_reverse_ipv6 ((struct in6_addr *)data, flags, dns_cb, (void *)SvREFCNT_inc (cb)) 663 ? evdns_resolve_reverse_ipv6 ((struct in6_addr *)data, flags, dns_cb, (void *)SvREFCNT_inc (cb))
544 : evdns_resolve_reverse ((struct in_addr *)data, flags, dns_cb, (void *)SvREFCNT_inc (cb)); 664 : evdns_resolve_reverse ((struct in_addr *)data, flags, dns_cb, (void *)SvREFCNT_inc (cb));
545} 665}

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines