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

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

Diff Legend

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