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

Comparing EV/EV.xs (file contents):
Revision 1.79 by root, Sat Nov 24 16:57:30 2007 UTC vs.
Revision 1.81 by root, Tue Nov 27 10:59:10 2007 UTC

… …
59 do { \ 59 do { \
60 REF (w); \ 60 REF (w); \
61 ev_ ## type ## _stop (w); \ 61 ev_ ## type ## _stop (w); \
62 } while (0) 62 } while (0)
63 63
64#define RESET(type,w,seta) \
65 do { \
66 int active = ev_is_active (w); \
67 if (active) STOP (type, w); \
68 ev_ ## type ## _set seta; \
69 if (active) START (type, w); \
70 } while (0)
71
64typedef int Signal; 72typedef int Signal;
65 73
66static struct EVAPI evapi; 74static struct EVAPI evapi;
67 75
68static HV 76static HV
69 *stash_watcher, 77 *stash_watcher,
70 *stash_io, 78 *stash_io,
71 *stash_timer, 79 *stash_timer,
72 *stash_periodic, 80 *stash_periodic,
73 *stash_signal, 81 *stash_signal,
82 *stash_child,
83 *stash_stat,
74 *stash_idle, 84 *stash_idle,
75 *stash_prepare, 85 *stash_prepare,
76 *stash_check, 86 *stash_check,
77 *stash_child; 87 *stash_embed,
88 *stash_fork;
78 89
79#ifndef SIG_SIZE 90#ifndef SIG_SIZE
80/* kudos to Slaven Rezic for the idea */ 91/* kudos to Slaven Rezic for the idea */
81static char sig_size [] = { SIG_NUM }; 92static char sig_size [] = { SIG_NUM };
82# define SIG_SIZE (sizeof (sig_size) + 1) 93# define SIG_SIZE (sizeof (sig_size) + 1)
83#endif 94#endif
84 95
85static int 96static Signal
86sv_signum (SV *sig) 97sv_signum (SV *sig)
87{ 98{
88 int signum; 99 Signal signum;
89 100
90 SvGETMAGIC (sig); 101 SvGETMAGIC (sig);
91 102
92 for (signum = 1; signum < SIG_SIZE; ++signum) 103 for (signum = 1; signum < SIG_SIZE; ++signum)
93 if (strEQ (SvPV_nolen (sig), PL_sig_name [signum])) 104 if (strEQ (SvPV_nolen (sig), PL_sig_name [signum]))
94 return signum; 105 return signum;
95 106
96 if (SvIV (sig) > 0) 107 signum = SvIV (sig);
108
109 if (signum > 0 && signum < SIG_SIZE)
97 return SvIV (sig); 110 return signum;
98 111
99 return -1; 112 return -1;
100} 113}
101 114
102///////////////////////////////////////////////////////////////////////////// 115/////////////////////////////////////////////////////////////////////////////
… …
354 croak (# repeat " value must be >= 0"); 367 croak (# repeat " value must be >= 0");
355 368
356#define CHECK_FD(fh,fd) if ((fd) < 0) \ 369#define CHECK_FD(fh,fd) if ((fd) < 0) \
357 croak ("illegal file descriptor or filehandle (either no attached file descriptor or illegal value): %s", SvPV_nolen (fh)); 370 croak ("illegal file descriptor or filehandle (either no attached file descriptor or illegal value): %s", SvPV_nolen (fh));
358 371
372#define CHECK_SIG(sv,num) if ((num) < 0) \
373 croak ("illegal signal number or name: %s", SvPV_nolen (sv));
374
359///////////////////////////////////////////////////////////////////////////// 375/////////////////////////////////////////////////////////////////////////////
360// XS interface functions 376// XS interface functions
361 377
362MODULE = EV PACKAGE = EV PREFIX = ev_ 378MODULE = EV PACKAGE = EV PREFIX = ev_
363 379
… …
410 stash_signal = gv_stashpv ("EV::Signal" , 1); 426 stash_signal = gv_stashpv ("EV::Signal" , 1);
411 stash_idle = gv_stashpv ("EV::Idle" , 1); 427 stash_idle = gv_stashpv ("EV::Idle" , 1);
412 stash_prepare = gv_stashpv ("EV::Prepare" , 1); 428 stash_prepare = gv_stashpv ("EV::Prepare" , 1);
413 stash_check = gv_stashpv ("EV::Check" , 1); 429 stash_check = gv_stashpv ("EV::Check" , 1);
414 stash_child = gv_stashpv ("EV::Child" , 1); 430 stash_child = gv_stashpv ("EV::Child" , 1);
431 stash_embed = gv_stashpv ("EV::Embed" , 1);
432 stash_stat = gv_stashpv ("EV::Stat" , 1);
415 433
416 { 434 {
417 SV *sv = perl_get_sv ("EV::API", TRUE); 435 SV *sv = perl_get_sv ("EV::API", TRUE);
418 perl_get_sv ("EV::API", TRUE); /* silence 5.10 warning */ 436 perl_get_sv ("EV::API", TRUE); /* silence 5.10 warning */
419 437
… …
423 evapi.sv_fileno = sv_fileno; 441 evapi.sv_fileno = sv_fileno;
424 evapi.sv_signum = sv_signum; 442 evapi.sv_signum = sv_signum;
425 evapi.now = ev_now; 443 evapi.now = ev_now;
426 evapi.backend = ev_backend; 444 evapi.backend = ev_backend;
427 evapi.unloop = ev_unloop; 445 evapi.unloop = ev_unloop;
446 evapi.ref = ev_ref;
447 evapi.unref = ev_unref;
428 evapi.time = ev_time; 448 evapi.time = ev_time;
429 evapi.loop = ev_loop; 449 evapi.loop = ev_loop;
430 evapi.once = ev_once; 450 evapi.once = ev_once;
431 evapi.io_start = ev_io_start; 451 evapi.io_start = ev_io_start;
432 evapi.io_stop = ev_io_stop; 452 evapi.io_stop = ev_io_stop;
… …
443 evapi.prepare_stop = ev_prepare_stop; 463 evapi.prepare_stop = ev_prepare_stop;
444 evapi.check_start = ev_check_start; 464 evapi.check_start = ev_check_start;
445 evapi.check_stop = ev_check_stop; 465 evapi.check_stop = ev_check_stop;
446 evapi.child_start = ev_child_start; 466 evapi.child_start = ev_child_start;
447 evapi.child_stop = ev_child_stop; 467 evapi.child_stop = ev_child_stop;
448 evapi.ref = ev_ref; 468 evapi.stat_start = ev_stat_start;
449 evapi.unref = ev_unref; 469 evapi.stat_stop = ev_stat_stop;
470 evapi.stat_stat = ev_stat_stat;
450 471
451 sv_setiv (sv, (IV)&evapi); 472 sv_setiv (sv, (IV)&evapi);
452 SvREADONLY_on (sv); 473 SvREADONLY_on (sv);
453 } 474 }
454#ifndef _WIN32 475#ifndef _WIN32
… …
511 if (!ix) START (periodic, w); 532 if (!ix) START (periodic, w);
512} 533}
513 OUTPUT: 534 OUTPUT:
514 RETVAL 535 RETVAL
515 536
516ev_signal *signal (Signal signum, SV *cb) 537ev_signal *signal (SV *signal, SV *cb)
517 ALIAS: 538 ALIAS:
518 signal_ns = 1 539 signal_ns = 1
519 CODE: 540 CODE:
541{
542 Signal signum = sv_signum (signal);
543 CHECK_SIG (signal, signum);
544
520 RETVAL = e_new (sizeof (ev_signal), cb); 545 RETVAL = e_new (sizeof (ev_signal), cb);
521 ev_signal_set (RETVAL, signum); 546 ev_signal_set (RETVAL, signum);
522 if (!ix) START (signal, RETVAL); 547 if (!ix) START (signal, RETVAL);
548}
523 OUTPUT: 549 OUTPUT:
524 RETVAL 550 RETVAL
525 551
526ev_idle *idle (SV *cb) 552ev_idle *idle (SV *cb)
527 ALIAS: 553 ALIAS:
… …
558 child_ns = 1 584 child_ns = 1
559 CODE: 585 CODE:
560 RETVAL = e_new (sizeof (ev_child), cb); 586 RETVAL = e_new (sizeof (ev_child), cb);
561 ev_child_set (RETVAL, pid); 587 ev_child_set (RETVAL, pid);
562 if (!ix) START (child, RETVAL); 588 if (!ix) START (child, RETVAL);
589 OUTPUT:
590 RETVAL
591
592ev_stat *stat (SV *path, NV interval, SV *cb)
593 ALIAS:
594 stat_ns = 1
595 CODE:
596 RETVAL = e_new (sizeof (ev_stat), cb);
597 RETVAL->fh = newSVsv (path);
598 ev_stat_set (RETVAL, SvPVbyte_nolen (RETVAL->fh), interval);
599 if (!ix) START (stat, RETVAL);
563 OUTPUT: 600 OUTPUT:
564 RETVAL 601 RETVAL
565 602
566void once (SV *fh, int events, SV *timeout, SV *cb) 603void once (SV *fh, int events, SV *timeout, SV *cb)
567 CODE: 604 CODE:
… …
674 e_destroy (w); 711 e_destroy (w);
675 712
676void set (ev_io *w, SV *fh, int events) 713void set (ev_io *w, SV *fh, int events)
677 CODE: 714 CODE:
678{ 715{
679 int active = ev_is_active (w);
680 int fd = sv_fileno (fh); 716 int fd = sv_fileno (fh);
681 CHECK_FD (fh, fd); 717 CHECK_FD (fh, fd);
682 718
683 if (active) STOP (io, w);
684
685 sv_setsv (w->fh, fh); 719 sv_setsv (w->fh, fh);
686 ev_io_set (w, fd, events); 720 RESET (io, w, (w, fd, events));
687
688 if (active) START (io, w);
689} 721}
690 722
691SV *fh (ev_io *w, SV *new_fh = 0) 723SV *fh (ev_io *w, SV *new_fh = 0)
692 CODE: 724 CODE:
693{ 725{
694 RETVAL = newSVsv (w->fh);
695
696 if (items > 1) 726 if (items > 1)
697 { 727 {
698 int active = ev_is_active (w); 728 int fd = sv_fileno (new_fh);
699 if (active) STOP (io, w); 729 CHECK_FD (new_fh, fd);
700 730
701 sv_setsv (w->fh, new_fh); 731 RETVAL = w->fh;
702 ev_io_set (w, sv_fileno (w->fh), w->events); 732 w->fh = newSVsv (new_fh);
703 733
704 if (active) START (io, w); 734 RESET (io, w, (w, fd, w->events));
705 } 735 }
736 else
737 RETVAL = newSVsv (w->fh);
706} 738}
707 OUTPUT: 739 OUTPUT:
708 RETVAL 740 RETVAL
709 741
710int events (ev_io *w, int new_events = EV_UNDEF) 742int events (ev_io *w, int new_events = EV_UNDEF)
711 CODE: 743 CODE:
712{ 744{
713 RETVAL = w->events; 745 RETVAL = w->events;
746
747 if (items > 1)
748 RESET (io, w, (w, w->fd, new_events));
749}
750 OUTPUT:
751 RETVAL
752
753MODULE = EV PACKAGE = EV::Signal PREFIX = ev_signal_
754
755void ev_signal_start (ev_signal *w)
756 CODE:
757 START (signal, w);
758
759void ev_signal_stop (ev_signal *w)
760 CODE:
761 STOP (signal, w);
762
763void DESTROY (ev_signal *w)
764 CODE:
765 STOP (signal, w);
766 e_destroy (w);
767
768void set (ev_signal *w, SV *signal)
769 CODE:
770{
771 Signal signum = sv_signum (signal);
772 CHECK_SIG (signal, signum);
773
774 RESET (signal, w, (w, signum));
775}
776
777int signal (ev_signal *w, SV *new_signal = 0)
778 CODE:
779{
780 RETVAL = w->signum;
714 781
715 if (items > 1) 782 if (items > 1)
716 { 783 {
717 int active = ev_is_active (w);
718 if (active) STOP (io, w);
719
720 ev_io_set (w, w->fd, new_events);
721
722 if (active) START (io, w);
723 }
724}
725 OUTPUT:
726 RETVAL
727
728MODULE = EV PACKAGE = EV::Signal PREFIX = ev_signal_
729
730void ev_signal_start (ev_signal *w)
731 CODE:
732 START (signal, w);
733
734void ev_signal_stop (ev_signal *w)
735 CODE:
736 STOP (signal, w);
737
738void DESTROY (ev_signal *w)
739 CODE:
740 STOP (signal, w);
741 e_destroy (w);
742
743void set (ev_signal *w, SV *signal)
744 CODE:
745{
746 Signal signum = sv_signum (signal); /* may croak here */
747 int active = ev_is_active (w);
748
749 if (active) STOP (signal, w);
750
751 ev_signal_set (w, signum);
752
753 if (active) START (signal, w);
754}
755
756int signal (ev_signal *w, SV *new_signal = 0)
757 CODE:
758{
759 RETVAL = w->signum;
760
761 if (items > 1)
762 {
763 Signal signum = sv_signum (new_signal); /* may croak here */ 784 Signal signum = sv_signum (new_signal);
764 int active = ev_is_active (w); 785 CHECK_SIG (new_signal, signum);
765 if (active) STOP (signal, w);
766 786
767 ev_signal_set (w, signum); 787 RESET (signal, w, (w, signum));
768
769 if (active) START (signal, w);
770 } 788 }
771} 789}
772 OUTPUT: 790 OUTPUT:
773 RETVAL 791 RETVAL
774 792
… …
799 817
800void set (ev_timer *w, NV after, NV repeat = 0.) 818void set (ev_timer *w, NV after, NV repeat = 0.)
801 INIT: 819 INIT:
802 CHECK_REPEAT (repeat); 820 CHECK_REPEAT (repeat);
803 CODE: 821 CODE:
804{
805 int active = ev_is_active (w);
806 if (active) STOP (timer, w);
807 ev_timer_set (w, after, repeat); 822 RESET (timer, w, (w, after, repeat));
808 if (active) START (timer, w);
809}
810 823
811MODULE = EV PACKAGE = EV::Periodic PREFIX = ev_periodic_ 824MODULE = EV PACKAGE = EV::Periodic PREFIX = ev_periodic_
812 825
813void ev_periodic_start (ev_periodic *w) 826void ev_periodic_start (ev_periodic *w)
814 INIT: 827 INIT:
… …
834void set (ev_periodic *w, NV at, NV interval = 0., SV *reschedule_cb = &PL_sv_undef) 847void set (ev_periodic *w, NV at, NV interval = 0., SV *reschedule_cb = &PL_sv_undef)
835 INIT: 848 INIT:
836 CHECK_REPEAT (interval); 849 CHECK_REPEAT (interval);
837 CODE: 850 CODE:
838{ 851{
839 int active = ev_is_active (w);
840 if (active) STOP (periodic, w);
841
842 SvREFCNT_dec (w->fh); 852 SvREFCNT_dec (w->fh);
843 w->fh = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0; 853 w->fh = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0;
854
844 ev_periodic_set (w, at, interval, w->fh ? e_periodic_cb : 0); 855 RESET (periodic, w, (w, at, interval, w->fh ? e_periodic_cb : 0));
845
846 if (active) START (periodic, w);
847} 856}
848 857
849MODULE = EV PACKAGE = EV::Idle PREFIX = ev_idle_ 858MODULE = EV PACKAGE = EV::Idle PREFIX = ev_idle_
850 859
851void ev_idle_start (ev_idle *w) 860void ev_idle_start (ev_idle *w)
… …
906 STOP (child, w); 915 STOP (child, w);
907 e_destroy (w); 916 e_destroy (w);
908 917
909void set (ev_child *w, int pid) 918void set (ev_child *w, int pid)
910 CODE: 919 CODE:
911{ 920 RESET (child, w, (w, pid));
912 int active = ev_is_active (w);
913 if (active) STOP (child, w);
914
915 ev_child_set (w, pid);
916
917 if (active) START (child, w);
918}
919 921
920int pid (ev_child *w, int new_pid = 0) 922int pid (ev_child *w, int new_pid = 0)
921 CODE: 923 CODE:
922{ 924{
923 RETVAL = w->pid; 925 RETVAL = w->pid;
924 926
925 if (items > 1) 927 if (items > 1)
926 { 928 RESET (child, w, (w, new_pid));
927 int active = ev_is_active (w);
928 if (active) STOP (child, w);
929
930 ev_child_set (w, new_pid);
931
932 if (active) START (child, w);
933 }
934} 929}
935 OUTPUT: 930 OUTPUT:
936 RETVAL 931 RETVAL
937 932
938 933
939int rstatus (ev_child *w) 934int rstatus (ev_child *w)
940 ALIAS: 935 ALIAS:
941 rpid = 1 936 rpid = 1
942 CODE: 937 CODE:
943 RETVAL = ix ? w->rpid : w->rstatus; 938 RETVAL = ix ? w->rpid : w->rstatus;
939 OUTPUT:
940 RETVAL
941
942MODULE = EV PACKAGE = EV::Stat PREFIX = ev_stat_
943
944void ev_stat_start (ev_stat *w)
945 CODE:
946 START (stat, w);
947
948void ev_stat_stop (ev_stat *w)
949 CODE:
950 STOP (stat, w);
951
952void DESTROY (ev_stat *w)
953 CODE:
954 STOP (stat, w);
955 e_destroy (w);
956
957void set (ev_stat *w, SV *path, NV interval)
958 CODE:
959{
960 sv_setsv (w->fh, path);
961 RESET (stat, w, (w, SvPVbyte_nolen (w->fh), interval));
962}
963
964SV *path (ev_stat *w, SV *new_path = 0)
965 CODE:
966{
967 RETVAL = SvREFCNT_inc (w->fh);
968
969 if (items > 1)
970 {
971 SvREFCNT_dec (w->fh);
972 w->fh = newSVsv (new_path);
973 RESET (stat, w, (w, SvPVbyte_nolen (w->fh), w->interval));
974 }
975}
976 OUTPUT:
977 RETVAL
978
979NV interval (ev_stat *w, NV new_interval = 0.)
980 CODE:
981{
982 RETVAL = w->interval;
983
984 if (items > 1)
985 RESET (stat, w, (w, SvPVbyte_nolen (w->fh), new_interval));
986}
944 OUTPUT: 987 OUTPUT:
945 RETVAL 988 RETVAL
946 989
947#ifndef _WIN32 990#ifndef _WIN32
948 991

Diff Legend

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