… | |
… | |
63 | #endif |
63 | #endif |
64 | |
64 | |
65 | /* the maximum number of idle cctx that will be pooled */ |
65 | /* the maximum number of idle cctx that will be pooled */ |
66 | static int cctx_max_idle = 4; |
66 | static int cctx_max_idle = 4; |
67 | |
67 | |
|
|
68 | #if defined(DEBUGGING) && PERL_VERSION_ATLEAST(5,12,0) |
|
|
69 | # define HAS_SCOPESTACK_NAME 1 |
|
|
70 | #endif |
|
|
71 | |
68 | #if !__i386 && !__x86_64 && !__powerpc && !__m68k && !__alpha && !__mips && !__sparc64 |
72 | #if !__i386 && !__x86_64 && !__powerpc && !__m68k && !__alpha && !__mips && !__sparc64 |
69 | # undef CORO_STACKGUARD |
73 | # undef CORO_STACKGUARD |
70 | #endif |
74 | #endif |
71 | |
75 | |
72 | #ifndef CORO_STACKGUARD |
76 | #ifndef CORO_STACKGUARD |
… | |
… | |
177 | void *sptr; |
181 | void *sptr; |
178 | size_t ssize; |
182 | size_t ssize; |
179 | |
183 | |
180 | /* cpu state */ |
184 | /* cpu state */ |
181 | void *idle_sp; /* sp of top-level transfer/schedule/cede call */ |
185 | void *idle_sp; /* sp of top-level transfer/schedule/cede call */ |
|
|
186 | #ifndef NDEBUG |
182 | JMPENV *idle_te; /* same as idle_sp, but for top_env, TODO: remove once stable */ |
187 | JMPENV *idle_te; /* same as idle_sp, but for top_env */ |
|
|
188 | #endif |
183 | JMPENV *top_env; |
189 | JMPENV *top_env; |
184 | coro_context cctx; |
190 | coro_context cctx; |
185 | |
191 | |
186 | U32 gen; |
192 | U32 gen; |
187 | #if CORO_USE_VALGRIND |
193 | #if CORO_USE_VALGRIND |
… | |
… | |
637 | AvARRAY (av)[++AvFILLp (av)] = (SV *)CvPADLIST (cv); |
643 | AvARRAY (av)[++AvFILLp (av)] = (SV *)CvPADLIST (cv); |
638 | } |
644 | } |
639 | |
645 | |
640 | /** load & save, init *******************************************************/ |
646 | /** load & save, init *******************************************************/ |
641 | |
647 | |
|
|
648 | ecb_inline void |
|
|
649 | swap_sv (SV *a, SV *b) |
|
|
650 | { |
|
|
651 | const U32 keep = SVs_PADSTALE | SVs_PADTMP | SVs_PADMY; /* keep these flags */ |
|
|
652 | SV tmp; |
|
|
653 | |
|
|
654 | /* swap sv_any */ |
|
|
655 | SvANY (&tmp) = SvANY (a); SvANY (a) = SvANY (b); SvANY (b) = SvANY (&tmp); |
|
|
656 | |
|
|
657 | /* swap sv_flags */ |
|
|
658 | SvFLAGS (&tmp) = SvFLAGS (a); |
|
|
659 | SvFLAGS (a) = (SvFLAGS (a) & keep) | (SvFLAGS (b ) & ~keep); |
|
|
660 | SvFLAGS (b) = (SvFLAGS (b) & keep) | (SvFLAGS (&tmp) & ~keep); |
|
|
661 | |
|
|
662 | #if PERL_VERSION_ATLEAST (5,10,0) |
|
|
663 | /* perl 5.10 and later complicates this _quite_ a bit, but it also |
|
|
664 | * is much faster, so no quarrels here. alternatively, we could |
|
|
665 | * sv_upgrade to avoid this. |
|
|
666 | */ |
|
|
667 | { |
|
|
668 | /* swap sv_u */ |
|
|
669 | tmp.sv_u = a->sv_u; a->sv_u = b->sv_u; b->sv_u = tmp.sv_u; |
|
|
670 | |
|
|
671 | /* if SvANY points to the head, we need to adjust the pointers, |
|
|
672 | * as the pointer for a still points to b, and maybe vice versa. |
|
|
673 | */ |
|
|
674 | #define svany_in_head(type) \ |
|
|
675 | (((1 << SVt_NULL) | (1 << SVt_BIND) | (1 << SVt_IV) | (1 << SVt_RV)) & (1 << (type))) |
|
|
676 | |
|
|
677 | if (svany_in_head (SvTYPE (a))) |
|
|
678 | SvANY (a) = (void *)((PTRV)SvANY (a) - (PTRV)b + (PTRV)a); |
|
|
679 | |
|
|
680 | if (svany_in_head (SvTYPE (b))) |
|
|
681 | SvANY (b) = (void *)((PTRV)SvANY (b) - (PTRV)a + (PTRV)b); |
|
|
682 | } |
|
|
683 | #endif |
|
|
684 | } |
|
|
685 | |
642 | /* swap sv heads, at least logically */ |
686 | /* swap sv heads, at least logically */ |
643 | static void |
687 | static void |
644 | swap_svs (pTHX_ Coro__State c) |
688 | swap_svs (pTHX_ Coro__State c) |
645 | { |
689 | { |
646 | int i; |
690 | int i; |
647 | |
691 | |
648 | for (i = 0; i <= AvFILLp (c->swap_sv); ) |
692 | for (i = 0; i <= AvFILLp (c->swap_sv); i += 2) |
649 | { |
693 | swap_sv (AvARRAY (c->swap_sv)[i], AvARRAY (c->swap_sv)[i + 1]); |
650 | SV *a = AvARRAY (c->swap_sv)[i++]; |
|
|
651 | SV *b = AvARRAY (c->swap_sv)[i++]; |
|
|
652 | |
|
|
653 | const U32 keep = SVs_PADSTALE | SVs_PADTMP | SVs_PADMY; /* keep these flags */ |
|
|
654 | SV tmp; |
|
|
655 | |
|
|
656 | /* swap sv_any */ |
|
|
657 | SvANY (&tmp) = SvANY (a); SvANY (a) = SvANY (b); SvANY (b) = SvANY (&tmp); |
|
|
658 | |
|
|
659 | /* swap sv_flags */ |
|
|
660 | SvFLAGS (&tmp) = SvFLAGS (a); |
|
|
661 | SvFLAGS (a) = (SvFLAGS (a) & keep) | (SvFLAGS (b ) & ~keep); |
|
|
662 | SvFLAGS (b) = (SvFLAGS (b) & keep) | (SvFLAGS (&tmp) & ~keep); |
|
|
663 | |
|
|
664 | #if PERL_VERSION_ATLEAST (5,10,0) |
|
|
665 | /* perl 5.10 complicates this _quite_ a bit, but it also is |
|
|
666 | * much faster, so no quarrels here. alternatively, we could |
|
|
667 | * sv_upgrade to avoid this. |
|
|
668 | */ |
|
|
669 | { |
|
|
670 | /* swap sv_u */ |
|
|
671 | tmp.sv_u = a->sv_u; a->sv_u = b->sv_u; b->sv_u = tmp.sv_u; |
|
|
672 | |
|
|
673 | /* if SvANY points to the head, we need to adjust the pointers, |
|
|
674 | * as the pointer for a still points to b, and maybe vice versa. |
|
|
675 | */ |
|
|
676 | #define svany_in_head(type) \ |
|
|
677 | (((1 << SVt_NULL) | (1 << SVt_BIND) | (1 << SVt_IV) | (1 << SVt_RV)) & (1 << (type))) |
|
|
678 | |
|
|
679 | if (svany_in_head (SvTYPE (a))) |
|
|
680 | SvANY (a) = (void *)((PTRV)SvANY (a) - (PTRV)b + (PTRV)a); |
|
|
681 | |
|
|
682 | if (svany_in_head (SvTYPE (b))) |
|
|
683 | SvANY (b) = (void *)((PTRV)SvANY (b) - (PTRV)a + (PTRV)b); |
|
|
684 | } |
|
|
685 | #endif |
|
|
686 | } |
|
|
687 | } |
694 | } |
688 | |
695 | |
689 | #define SWAP_SVS(coro) \ |
696 | #define SWAP_SVS(coro) \ |
690 | if (ecb_expect_false ((coro)->swap_sv)) \ |
697 | if (ecb_expect_false ((coro)->swap_sv)) \ |
691 | swap_svs (aTHX_ (coro)) |
698 | swap_svs (aTHX_ (coro)) |
… | |
… | |
879 | #endif |
886 | #endif |
880 | |
887 | |
881 | New(54,PL_scopestack,8,I32); |
888 | New(54,PL_scopestack,8,I32); |
882 | PL_scopestack_ix = 0; |
889 | PL_scopestack_ix = 0; |
883 | PL_scopestack_max = 8; |
890 | PL_scopestack_max = 8; |
|
|
891 | #if HAS_SCOPESTACK_NAME |
|
|
892 | New(54,PL_scopestack_name,8,const char*); |
|
|
893 | #endif |
884 | |
894 | |
885 | New(54,PL_savestack,24,ANY); |
895 | New(54,PL_savestack,24,ANY); |
886 | PL_savestack_ix = 0; |
896 | PL_savestack_ix = 0; |
887 | PL_savestack_max = 24; |
897 | PL_savestack_max = 24; |
888 | |
898 | |
… | |
… | |
916 | } |
926 | } |
917 | |
927 | |
918 | Safefree (PL_tmps_stack); |
928 | Safefree (PL_tmps_stack); |
919 | Safefree (PL_markstack); |
929 | Safefree (PL_markstack); |
920 | Safefree (PL_scopestack); |
930 | Safefree (PL_scopestack); |
|
|
931 | #if HAS_SCOPESTACK_NAME |
|
|
932 | Safefree (PL_scopestack_name); |
|
|
933 | #endif |
921 | Safefree (PL_savestack); |
934 | Safefree (PL_savestack); |
922 | #if !PERL_VERSION_ATLEAST (5,10,0) |
935 | #if !PERL_VERSION_ATLEAST (5,10,0) |
923 | Safefree (PL_retstack); |
936 | Safefree (PL_retstack); |
924 | #endif |
937 | #endif |
925 | } |
938 | } |
… | |
… | |
988 | if (strEQ (s, "__DIE__" )) svp = &PL_diehook; |
1001 | if (strEQ (s, "__DIE__" )) svp = &PL_diehook; |
989 | if (strEQ (s, "__WARN__")) svp = &PL_warnhook; |
1002 | if (strEQ (s, "__WARN__")) svp = &PL_warnhook; |
990 | |
1003 | |
991 | if (svp) |
1004 | if (svp) |
992 | { |
1005 | { |
993 | sv_setsv (sv, *svp ? *svp : &PL_sv_undef); |
1006 | SV *ssv; |
|
|
1007 | |
|
|
1008 | if (!*svp) |
|
|
1009 | ssv = &PL_sv_undef; |
|
|
1010 | else if (SvTYPE (*svp) == SVt_PVCV) /* perlio directly stores a CV in warnhook. ugh. */ |
|
|
1011 | ssv = sv_2mortal (newRV_inc (*svp)); |
|
|
1012 | else |
|
|
1013 | ssv = *svp; |
|
|
1014 | |
|
|
1015 | sv_setsv (sv, ssv); |
994 | return 0; |
1016 | return 0; |
995 | } |
1017 | } |
996 | } |
1018 | } |
997 | |
1019 | |
998 | return orig_sigelem_get ? orig_sigelem_get (aTHX_ sv, mg) : 0; |
1020 | return orig_sigelem_get ? orig_sigelem_get (aTHX_ sv, mg) : 0; |