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.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:
… …
674 e_destroy (w); 710 e_destroy (w);
675 711
676void set (ev_io *w, SV *fh, int events) 712void set (ev_io *w, SV *fh, int events)
677 CODE: 713 CODE:
678{ 714{
679 int active = ev_is_active (w);
680 int fd = sv_fileno (fh); 715 int fd = sv_fileno (fh);
681 CHECK_FD (fh, fd); 716 CHECK_FD (fh, fd);
682 717
683 if (active) STOP (io, w);
684
685 sv_setsv (w->fh, fh); 718 sv_setsv (w->fh, fh);
686 ev_io_set (w, fd, events); 719 RESET (io, w, (w, fd, events));
687
688 if (active) START (io, w);
689} 720}
690 721
691SV *fh (ev_io *w, SV *new_fh = 0) 722SV *fh (ev_io *w, SV *new_fh = 0)
692 CODE: 723 CODE:
693{ 724{
694 RETVAL = newSVsv (w->fh);
695
696 if (items > 1) 725 if (items > 1)
697 { 726 {
698 int active = ev_is_active (w); 727 int fd = sv_fileno (new_fh);
699 if (active) STOP (io, w); 728 CHECK_FD (new_fh, fd);
700 729
701 sv_setsv (w->fh, new_fh); 730 RETVAL = w->fh;
702 ev_io_set (w, sv_fileno (w->fh), w->events); 731 w->fh = newSVsv (new_fh);
703 732
704 if (active) START (io, w); 733 RESET (io, w, (w, fd, w->events));
705 } 734 }
735 else
736 RETVAL = newSVsv (w->fh);
706} 737}
707 OUTPUT: 738 OUTPUT:
708 RETVAL 739 RETVAL
709 740
710int events (ev_io *w, int new_events = EV_UNDEF) 741int events (ev_io *w, int new_events = EV_UNDEF)
711 CODE: 742 CODE:
712{ 743{
713 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;
714 780
715 if (items > 1) 781 if (items > 1)
716 { 782 {
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 */ 783 Signal signum = sv_signum (new_signal);
764 int active = ev_is_active (w); 784 CHECK_SIG (new_signal, signum);
765 if (active) STOP (signal, w);
766 785
767 ev_signal_set (w, signum); 786 RESET (signal, w, (w, signum));
768
769 if (active) START (signal, w);
770 } 787 }
771} 788}
772 OUTPUT: 789 OUTPUT:
773 RETVAL 790 RETVAL
774 791
… …
799 816
800void set (ev_timer *w, NV after, NV repeat = 0.) 817void set (ev_timer *w, NV after, NV repeat = 0.)
801 INIT: 818 INIT:
802 CHECK_REPEAT (repeat); 819 CHECK_REPEAT (repeat);
803 CODE: 820 CODE:
804{
805 int active = ev_is_active (w);
806 if (active) STOP (timer, w);
807 ev_timer_set (w, after, repeat); 821 RESET (timer, w, (w, after, repeat));
808 if (active) START (timer, w);
809}
810 822
811MODULE = EV PACKAGE = EV::Periodic PREFIX = ev_periodic_ 823MODULE = EV PACKAGE = EV::Periodic PREFIX = ev_periodic_
812 824
813void ev_periodic_start (ev_periodic *w) 825void ev_periodic_start (ev_periodic *w)
814 INIT: 826 INIT:
… …
834void 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)
835 INIT: 847 INIT:
836 CHECK_REPEAT (interval); 848 CHECK_REPEAT (interval);
837 CODE: 849 CODE:
838{ 850{
839 int active = ev_is_active (w);
840 if (active) STOP (periodic, w);
841
842 SvREFCNT_dec (w->fh); 851 SvREFCNT_dec (w->fh);
843 w->fh = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0; 852 w->fh = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0;
853
844 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));
845
846 if (active) START (periodic, w);
847} 855}
848 856
849MODULE = EV PACKAGE = EV::Idle PREFIX = ev_idle_ 857MODULE = EV PACKAGE = EV::Idle PREFIX = ev_idle_
850 858
851void ev_idle_start (ev_idle *w) 859void ev_idle_start (ev_idle *w)
… …
906 STOP (child, w); 914 STOP (child, w);
907 e_destroy (w); 915 e_destroy (w);
908 916
909void set (ev_child *w, int pid) 917void set (ev_child *w, int pid)
910 CODE: 918 CODE:
911{ 919 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 920
920int pid (ev_child *w, int new_pid = 0) 921int pid (ev_child *w, int new_pid = 0)
921 CODE: 922 CODE:
922{ 923{
923 RETVAL = w->pid; 924 RETVAL = w->pid;
924 925
925 if (items > 1) 926 if (items > 1)
926 { 927 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} 928}
935 OUTPUT: 929 OUTPUT:
936 RETVAL 930 RETVAL
937 931
938 932
939int rstatus (ev_child *w) 933int rstatus (ev_child *w)
940 ALIAS: 934 ALIAS:
941 rpid = 1 935 rpid = 1
942 CODE: 936 CODE:
943 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}
944 OUTPUT: 986 OUTPUT:
945 RETVAL 987 RETVAL
946 988
947#ifndef _WIN32 989#ifndef _WIN32
948 990

Diff Legend

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