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

Comparing Coro/Coro/State.xs (file contents):
Revision 1.312 by root, Thu Nov 20 03:10:30 2008 UTC vs.
Revision 1.320 by root, Fri Nov 21 07:29:04 2008 UTC

… …
98# define newSV(l) NEWSV(0,l) 98# define newSV(l) NEWSV(0,l)
99#endif 99#endif
100#ifndef CvISXSUB_on 100#ifndef CvISXSUB_on
101# define CvISXSUB_on(cv) (void)cv 101# define CvISXSUB_on(cv) (void)cv
102#endif 102#endif
103#ifndef CvISXSUB
104# define CvISXSUB(cv) (CvXSUB (cv) ? TRUE : FALSE)
105#endif
103 106
104/* 5.8.7 */ 107/* 5.8.7 */
105#ifndef SvRV_set 108#ifndef SvRV_set
106# define SvRV_set(s,v) SvRV(s) = (v) 109# define SvRV_set(s,v) SvRV(s) = (v)
107#endif 110#endif
… …
167static AV *main_mainstack; /* used to differentiate between $main and others */ 170static AV *main_mainstack; /* used to differentiate between $main and others */
168static JMPENV *main_top_env; 171static JMPENV *main_top_env;
169static HV *coro_state_stash, *coro_stash; 172static HV *coro_state_stash, *coro_stash;
170static volatile SV *coro_mortal; /* will be freed/thrown after next transfer */ 173static volatile SV *coro_mortal; /* will be freed/thrown after next transfer */
171 174
175static AV *av_destroy; /* destruction queue */
176static SV *sv_manager; /* the manager coro */
177
172static GV *irsgv; /* $/ */ 178static GV *irsgv; /* $/ */
173static GV *stdoutgv; /* *STDOUT */ 179static GV *stdoutgv; /* *STDOUT */
174static SV *rv_diehook; 180static SV *rv_diehook;
175static SV *rv_warnhook; 181static SV *rv_warnhook;
176static HV *hv_sig; /* %SIG */ 182static HV *hv_sig; /* %SIG */
177 183
178/* async_pool helper stuff */ 184/* async_pool helper stuff */
179static SV *sv_pool_rss; 185static SV *sv_pool_rss;
180static SV *sv_pool_size; 186static SV *sv_pool_size;
181static SV *sv_async_pool_idle; 187static SV *sv_async_pool_idle; /* description string */
182static AV *av_async_pool; 188static AV *av_async_pool; /* idle pool */
183static SV *sv_Coro; 189static SV *sv_Coro; /* class string */
184static CV *cv_pool_handler; 190static CV *cv_pool_handler;
185static CV *cv_coro_new; 191static CV *cv_coro_state_new;
186 192
187/* Coro::AnyEvent */ 193/* Coro::AnyEvent */
188static SV *sv_activity; 194static SV *sv_activity;
189 195
190static struct coro_cctx *cctx_first; 196static struct coro_cctx *cctx_first;
… …
831slf_check_nop (pTHX_ struct CoroSLF *frame) 837slf_check_nop (pTHX_ struct CoroSLF *frame)
832{ 838{
833 return 0; 839 return 0;
834} 840}
835 841
842static int
843slf_check_repeat (pTHX_ struct CoroSLF *frame)
844{
845 return 1;
846}
847
836static UNOP coro_setup_op; 848static UNOP coro_setup_op;
837 849
838static void NOINLINE /* noinline to keep it out of the transfer fast path */ 850static void NOINLINE /* noinline to keep it out of the transfer fast path */
839coro_setup (pTHX_ struct coro *coro) 851coro_setup (pTHX_ struct coro *coro)
840{ 852{
… …
889 slf_frame.prepare = prepare_nop; /* provide a nop function for an eventual pp_slf */ 901 slf_frame.prepare = prepare_nop; /* provide a nop function for an eventual pp_slf */
890 slf_frame.check = slf_check_nop; /* signal pp_slf to not repeat */ 902 slf_frame.check = slf_check_nop; /* signal pp_slf to not repeat */
891 903
892 /* and we have to provide the pp_slf op in any case, so pp_slf can skip it */ 904 /* and we have to provide the pp_slf op in any case, so pp_slf can skip it */
893 coro_setup_op.op_next = PL_op; 905 coro_setup_op.op_next = PL_op;
894 coro_setup_op.op_type = OP_CUSTOM; 906 coro_setup_op.op_type = OP_ENTERSUB;
895 coro_setup_op.op_ppaddr = pp_slf; 907 coro_setup_op.op_ppaddr = pp_slf;
896 /* no flags etc. required, as an init function won't be called */ 908 /* no flags etc. required, as an init function won't be called */
897 909
898 PL_op = (OP *)&coro_setup_op; 910 PL_op = (OP *)&coro_setup_op;
899 911
… …
1014 { 1026 {
1015 PERL_CONTEXT *cx = &cxstack[cxstack_ix]; 1027 PERL_CONTEXT *cx = &cxstack[cxstack_ix];
1016 1028
1017 if (CxTYPE (cx) == CXt_SUB && oldcxix < cxstack_ix) 1029 if (CxTYPE (cx) == CXt_SUB && oldcxix < cxstack_ix)
1018 { 1030 {
1019 runops_proc_t old_runops = PL_runops;
1020 dSP; 1031 dSP;
1021 GV *gv = CvGV (cx->blk_sub.cv); 1032 GV *gv = CvGV (cx->blk_sub.cv);
1022 SV *fullname = sv_2mortal (newSV (0)); 1033 SV *fullname = sv_2mortal (newSV (0));
1023 1034
1024 if (isGV (gv)) 1035 if (isGV (gv))
… …
1609api_is_ready (pTHX_ SV *coro_sv) 1620api_is_ready (pTHX_ SV *coro_sv)
1610{ 1621{
1611 return !!(SvSTATE (coro_sv)->flags & CF_READY); 1622 return !!(SvSTATE (coro_sv)->flags & CF_READY);
1612} 1623}
1613 1624
1625/* expects to own a reference to next->hv */
1614INLINE void 1626INLINE void
1627prepare_schedule_to (pTHX_ struct coro_transfer_args *ta, struct coro *next)
1628{
1629 SV *prev_sv = SvRV (coro_current);
1630
1631 ta->prev = SvSTATE_hv (prev_sv);
1632 ta->next = next;
1633
1634 TRANSFER_CHECK (*ta);
1635
1636 SvRV_set (coro_current, (SV *)next->hv);
1637
1638 free_coro_mortal (aTHX);
1639 coro_mortal = prev_sv;
1640}
1641
1642static void
1615prepare_schedule (pTHX_ struct coro_transfer_args *ta) 1643prepare_schedule (pTHX_ struct coro_transfer_args *ta)
1616{ 1644{
1617 SV *prev_sv, *next_sv;
1618
1619 for (;;) 1645 for (;;)
1620 { 1646 {
1621 next_sv = coro_deq (aTHX); 1647 SV *next_sv = coro_deq (aTHX);
1622 1648
1623 /* nothing to schedule: call the idle handler */
1624 if (expect_false (!next_sv)) 1649 if (expect_true (next_sv))
1625 { 1650 {
1651 struct coro *next = SvSTATE_hv (next_sv);
1652
1653 /* cannot transfer to destroyed coros, skip and look for next */
1654 if (expect_false (next->flags & CF_DESTROYED))
1655 SvREFCNT_dec (next_sv); /* coro_nready has already been taken care of by destroy */
1656 else
1657 {
1658 next->flags &= ~CF_READY;
1659 --coro_nready;
1660
1661 prepare_schedule_to (aTHX_ ta, next);
1662 break;
1663 }
1664 }
1665 else
1666 {
1667 /* nothing to schedule: call the idle handler */
1626 dSP; 1668 dSP;
1627 1669
1628 ENTER; 1670 ENTER;
1629 SAVETMPS; 1671 SAVETMPS;
1630 1672
… …
1632 PUTBACK; 1674 PUTBACK;
1633 call_sv (get_sv ("Coro::idle", FALSE), G_VOID | G_DISCARD); 1675 call_sv (get_sv ("Coro::idle", FALSE), G_VOID | G_DISCARD);
1634 1676
1635 FREETMPS; 1677 FREETMPS;
1636 LEAVE; 1678 LEAVE;
1637 continue;
1638 } 1679 }
1639
1640 ta->next = SvSTATE_hv (next_sv);
1641
1642 /* cannot transfer to destroyed coros, skip and look for next */
1643 if (expect_false (ta->next->flags & CF_DESTROYED))
1644 {
1645 SvREFCNT_dec (next_sv);
1646 /* coro_nready has already been taken care of by destroy */
1647 continue;
1648 }
1649
1650 --coro_nready;
1651 break;
1652 } 1680 }
1653
1654 /* free this only after the transfer */
1655 prev_sv = SvRV (coro_current);
1656 ta->prev = SvSTATE_hv (prev_sv);
1657 TRANSFER_CHECK (*ta);
1658 assert (("FATAL: next coroutine isn't marked as ready in Coro (please report)", ta->next->flags & CF_READY));
1659 ta->next->flags &= ~CF_READY;
1660 SvRV_set (coro_current, next_sv);
1661
1662 free_coro_mortal (aTHX);
1663 coro_mortal = prev_sv;
1664} 1681}
1665 1682
1666INLINE void 1683INLINE void
1667prepare_cede (pTHX_ struct coro_transfer_args *ta) 1684prepare_cede (pTHX_ struct coro_transfer_args *ta)
1668{ 1685{
… …
1689{ 1706{
1690 struct coro_transfer_args ta; 1707 struct coro_transfer_args ta;
1691 1708
1692 prepare_schedule (aTHX_ &ta); 1709 prepare_schedule (aTHX_ &ta);
1693 TRANSFER (ta, 1); 1710 TRANSFER (ta, 1);
1711}
1712
1713static void
1714api_schedule_to (pTHX_ SV *coro_sv)
1715{
1716 struct coro_transfer_args ta;
1717 struct coro *next = SvSTATE (coro_sv);
1718
1719 SvREFCNT_inc_NN (coro_sv);
1720 prepare_schedule_to (aTHX_ &ta, next);
1694} 1721}
1695 1722
1696static int 1723static int
1697api_cede (pTHX) 1724api_cede (pTHX)
1698{ 1725{
… …
1747 else 1774 else
1748 coro->slot->runops = RUNOPS_DEFAULT; 1775 coro->slot->runops = RUNOPS_DEFAULT;
1749 } 1776 }
1750} 1777}
1751 1778
1779static void
1780coro_call_on_destroy (pTHX_ struct coro *coro)
1781{
1782 SV **on_destroyp = hv_fetch (coro->hv, "_on_destroy", sizeof ("_on_destroy") - 1, 0);
1783 SV **statusp = hv_fetch (coro->hv, "_status", sizeof ("_status") - 1, 0);
1784
1785 if (on_destroyp)
1786 {
1787 AV *on_destroy = (AV *)SvRV (*on_destroyp);
1788
1789 while (AvFILLp (on_destroy) >= 0)
1790 {
1791 dSP; /* don't disturb outer sp */
1792 SV *cb = av_pop (on_destroy);
1793
1794 PUSHMARK (SP);
1795
1796 if (statusp)
1797 {
1798 int i;
1799 AV *status = (AV *)SvRV (*statusp);
1800 EXTEND (SP, AvFILLp (status) + 1);
1801
1802 for (i = 0; i <= AvFILLp (status); ++i)
1803 PUSHs (AvARRAY (status)[i]);
1804 }
1805
1806 PUTBACK;
1807 call_sv (sv_2mortal (cb), G_VOID | G_DISCARD);
1808 }
1809 }
1810}
1811
1812static void
1813slf_init_terminate (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
1814{
1815 int i;
1816 HV *hv = (HV *)SvRV (coro_current);
1817 AV *av = newAV ();
1818
1819 av_extend (av, items - 1);
1820 for (i = 0; i < items; ++i)
1821 av_push (av, SvREFCNT_inc_NN (arg [i]));
1822
1823 hv_store (hv, "_status", sizeof ("_status") - 1, newRV_noinc ((SV *)av), 0);
1824
1825 av_push (av_destroy, (SV *)newRV_inc ((SV *)hv)); /* RVinc for perl */
1826 api_ready (aTHX_ sv_manager);
1827
1828 frame->prepare = prepare_schedule;
1829 frame->check = slf_check_repeat;
1830}
1831
1752/*****************************************************************************/ 1832/*****************************************************************************/
1753/* async pool handler */ 1833/* async pool handler */
1754 1834
1755static int 1835static int
1756slf_check_pool_handler (pTHX_ struct CoroSLF *frame) 1836slf_check_pool_handler (pTHX_ struct CoroSLF *frame)
… …
1760 1840
1761 if (!coro->invoke_cb) 1841 if (!coro->invoke_cb)
1762 return 1; /* loop till we have invoke */ 1842 return 1; /* loop till we have invoke */
1763 else 1843 else
1764 { 1844 {
1765 int i, len;
1766
1767 hv_store (hv, "desc", sizeof ("desc") - 1, 1845 hv_store (hv, "desc", sizeof ("desc") - 1,
1768 newSVpvn ("[async_pool]", sizeof ("[async_pool]") - 1), 0); 1846 newSVpvn ("[async_pool]", sizeof ("[async_pool]") - 1), 0);
1769 1847
1770 coro->saved_deffh = SvREFCNT_inc_NN ((SV *)PL_defoutgv); 1848 coro->saved_deffh = SvREFCNT_inc_NN ((SV *)PL_defoutgv);
1771
1772 len = av_len (coro->invoke_av);
1773 1849
1774 { 1850 {
1775 dSP; 1851 dSP;
1776 XPUSHs (sv_2mortal (coro->invoke_cb)); coro->invoke_cb = 0; 1852 XPUSHs (sv_2mortal (coro->invoke_cb)); coro->invoke_cb = 0;
1777 PUTBACK; 1853 PUTBACK;
… …
1841 SV *data = (SV *)GENSUB_ARG; 1917 SV *data = (SV *)GENSUB_ARG;
1842 1918
1843 if (SvTYPE (SvRV (data)) != SVt_PVAV) 1919 if (SvTYPE (SvRV (data)) != SVt_PVAV)
1844 { 1920 {
1845 /* first call, set args */ 1921 /* first call, set args */
1846 int i;
1847 AV *av = newAV (); 1922 AV *av = newAV ();
1848 SV *coro = SvRV (data); 1923 SV *coro = SvRV (data);
1849 1924
1850 SvRV_set (data, (SV *)av); 1925 SvRV_set (data, (SV *)av);
1851 api_ready (aTHX_ coro); 1926 api_ready (aTHX_ coro);
… …
1992static void 2067static void
1993slf_init_schedule (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items) 2068slf_init_schedule (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
1994{ 2069{
1995 frame->prepare = prepare_schedule; 2070 frame->prepare = prepare_schedule;
1996 frame->check = slf_check_nop; 2071 frame->check = slf_check_nop;
2072}
2073
2074static void
2075slf_prepare_schedule_to (pTHX_ struct coro_transfer_args *ta)
2076{
2077 struct coro *next = (struct coro *)slf_frame.data;
2078
2079 SvREFCNT_inc_NN (next->hv);
2080 prepare_schedule_to (aTHX_ ta, next);
2081}
2082
2083static void
2084slf_init_schedule_to (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2085{
2086 if (!items)
2087 croak ("Coro::schedule_to expects a coroutine argument, caught");
2088
2089 frame->data = (void *)SvSTATE (arg [0]);
2090 frame->prepare = slf_prepare_schedule_to;
2091 frame->check = slf_check_nop;
2092}
2093
2094static void
2095slf_init_cede_to (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2096{
2097 api_ready (aTHX_ SvRV (coro_current));
2098
2099 slf_init_schedule_to (aTHX_ frame, cv, arg, items);
1997} 2100}
1998 2101
1999static void 2102static void
2000slf_init_cede (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items) 2103slf_init_cede (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2001{ 2104{
… …
2147 } 2250 }
2148 else 2251 else
2149 slf_argc = 0; 2252 slf_argc = 0;
2150 2253
2151 PL_op->op_ppaddr = pp_slf; 2254 PL_op->op_ppaddr = pp_slf;
2152 PL_op->op_type = OP_CUSTOM; /* maybe we should leave it at entersub? */ 2255 /*PL_op->op_type = OP_CUSTOM; /* we do behave like entersub still */
2153 2256
2154 PL_op = (OP *)&slf_restore; 2257 PL_op = (OP *)&slf_restore;
2155} 2258}
2156 2259
2157/*****************************************************************************/ 2260/*****************************************************************************/
… …
2662 2765
2663 { 2766 {
2664 SV *slf = sv_2mortal (newSViv (PTR2IV (pp_slf))); 2767 SV *slf = sv_2mortal (newSViv (PTR2IV (pp_slf)));
2665 2768
2666 if (!PL_custom_op_names) PL_custom_op_names = newHV (); 2769 if (!PL_custom_op_names) PL_custom_op_names = newHV ();
2667 hv_store_ent (PL_custom_op_names, slf, 2770 hv_store_ent (PL_custom_op_names, slf, newSVpv ("coro_slf", 0), 0);
2668 newSVpv ("coro_slf", 0), 0);
2669 2771
2670 if (!PL_custom_op_descs) PL_custom_op_descs = newHV (); 2772 if (!PL_custom_op_descs) PL_custom_op_descs = newHV ();
2671 hv_store_ent (PL_custom_op_descs, slf, 2773 hv_store_ent (PL_custom_op_descs, slf, newSVpv ("coro schedule like function", 0), 0);
2672 newSVpv ("coro schedule like function", 0), 0);
2673 } 2774 }
2674 2775
2675 coroapi.ver = CORO_API_VERSION; 2776 coroapi.ver = CORO_API_VERSION;
2676 coroapi.rev = CORO_API_REVISION; 2777 coroapi.rev = CORO_API_REVISION;
2677 2778
… …
2955 3056
2956BOOT: 3057BOOT:
2957{ 3058{
2958 int i; 3059 int i;
2959 3060
2960 av_async_pool = coro_get_av (aTHX_ "Coro::async_pool", TRUE);
2961 sv_pool_rss = coro_get_sv (aTHX_ "Coro::POOL_RSS" , TRUE); 3061 sv_pool_rss = coro_get_sv (aTHX_ "Coro::POOL_RSS" , TRUE);
2962 sv_pool_size = coro_get_sv (aTHX_ "Coro::POOL_SIZE" , TRUE); 3062 sv_pool_size = coro_get_sv (aTHX_ "Coro::POOL_SIZE" , TRUE);
2963 cv_coro_run = get_cv ( "Coro::_terminate", GV_ADD); 3063 cv_coro_run = get_cv ( "Coro::_terminate", GV_ADD);
2964 cv_coro_terminate = get_cv ( "Coro::terminate", GV_ADD); 3064 cv_coro_terminate = get_cv ( "Coro::terminate" , GV_ADD);
2965 coro_current = coro_get_sv (aTHX_ "Coro::current" , FALSE); 3065 coro_current = coro_get_sv (aTHX_ "Coro::current" , FALSE); SvREADONLY_on (coro_current);
2966 SvREADONLY_on (coro_current); 3066 av_async_pool = coro_get_av (aTHX_ "Coro::async_pool", TRUE);
3067 av_destroy = coro_get_av (aTHX_ "Coro::destroy" , TRUE);
3068 sv_manager = coro_get_sv (aTHX_ "Coro::manager" , TRUE);
2967 3069
2968 sv_async_pool_idle = newSVpv ("[async pool idle]", 0); SvREADONLY_on (sv_async_pool_idle); 3070 sv_async_pool_idle = newSVpv ("[async pool idle]", 0); SvREADONLY_on (sv_async_pool_idle);
2969 sv_Coro = newSVpv ("Coro", 0); SvREADONLY_on (sv_Coro); 3071 sv_Coro = newSVpv ("Coro", 0); SvREADONLY_on (sv_Coro);
2970 cv_pool_handler = get_cv ("Coro::_pool_handler", 0); SvREADONLY_on (cv_pool_handler); 3072 cv_pool_handler = get_cv ("Coro::pool_handler", GV_ADD); SvREADONLY_on (cv_pool_handler);
2971 cv_coro_new = get_cv ("Coro::new", 0); SvREADONLY_on (cv_coro_new); 3073 cv_coro_state_new = get_cv ("Coro::State::new", 0); SvREADONLY_on (cv_coro_state_new);
2972 3074
2973 coro_stash = gv_stashpv ("Coro", TRUE); 3075 coro_stash = gv_stashpv ("Coro", TRUE);
2974 3076
2975 newCONSTSUB (coro_stash, "PRIO_MAX", newSViv (PRIO_MAX)); 3077 newCONSTSUB (coro_stash, "PRIO_MAX", newSViv (PRIO_MAX));
2976 newCONSTSUB (coro_stash, "PRIO_HIGH", newSViv (PRIO_HIGH)); 3078 newCONSTSUB (coro_stash, "PRIO_HIGH", newSViv (PRIO_HIGH));
… …
2984 3086
2985 { 3087 {
2986 SV *sv = coro_get_sv (aTHX_ "Coro::API", TRUE); 3088 SV *sv = coro_get_sv (aTHX_ "Coro::API", TRUE);
2987 3089
2988 coroapi.schedule = api_schedule; 3090 coroapi.schedule = api_schedule;
3091 coroapi.schedule_to = api_schedule_to;
2989 coroapi.cede = api_cede; 3092 coroapi.cede = api_cede;
2990 coroapi.cede_notself = api_cede_notself; 3093 coroapi.cede_notself = api_cede_notself;
2991 coroapi.ready = api_ready; 3094 coroapi.ready = api_ready;
2992 coroapi.is_ready = api_is_ready; 3095 coroapi.is_ready = api_is_ready;
2993 coroapi.nready = coro_nready; 3096 coroapi.nready = coro_nready;
… …
2998 SvREADONLY_on (sv); 3101 SvREADONLY_on (sv);
2999 } 3102 }
3000} 3103}
3001 3104
3002void 3105void
3106terminate (...)
3107 CODE:
3108 CORO_EXECUTE_SLF_XS (slf_init_terminate);
3109
3110void
3003schedule (...) 3111schedule (...)
3004 CODE: 3112 CODE:
3005 CORO_EXECUTE_SLF_XS (slf_init_schedule); 3113 CORO_EXECUTE_SLF_XS (slf_init_schedule);
3114
3115void
3116schedule_to (...)
3117 CODE:
3118 CORO_EXECUTE_SLF_XS (slf_init_schedule_to);
3119
3120void
3121cede_to (...)
3122 CODE:
3123 CORO_EXECUTE_SLF_XS (slf_init_cede_to);
3006 3124
3007void 3125void
3008cede (...) 3126cede (...)
3009 CODE: 3127 CODE:
3010 CORO_EXECUTE_SLF_XS (slf_init_cede); 3128 CORO_EXECUTE_SLF_XS (slf_init_cede);
3011 3129
3012void 3130void
3013cede_notself (...) 3131cede_notself (...)
3014 CODE: 3132 CODE:
3015 CORO_EXECUTE_SLF_XS (slf_init_cede_notself); 3133 CORO_EXECUTE_SLF_XS (slf_init_cede_notself);
3134
3135void
3136_cancel (Coro::State self)
3137 CODE:
3138 coro_state_destroy (aTHX_ self);
3139 coro_call_on_destroy (aTHX_ self);
3016 3140
3017void 3141void
3018_set_current (SV *current) 3142_set_current (SV *current)
3019 PROTOTYPE: $ 3143 PROTOTYPE: $
3020 CODE: 3144 CODE:
… …
3091 PUSHMARK (SP); 3215 PUSHMARK (SP);
3092 EXTEND (SP, 2); 3216 EXTEND (SP, 2);
3093 PUSHs (sv_Coro); 3217 PUSHs (sv_Coro);
3094 PUSHs ((SV *)cv_pool_handler); 3218 PUSHs ((SV *)cv_pool_handler);
3095 PUTBACK; 3219 PUTBACK;
3096 call_sv (cv_coro_new, G_SCALAR); 3220 call_sv ((SV *)cv_coro_state_new, G_SCALAR);
3097 SPAGAIN; 3221 SPAGAIN;
3098 3222
3099 hv = (HV *)SvREFCNT_inc_NN (SvRV (POPs)); 3223 hv = (HV *)SvREFCNT_inc_NN (SvRV (POPs));
3100 } 3224 }
3101 3225
… …
3106 assert (!coro->invoke_av); 3230 assert (!coro->invoke_av);
3107 coro->invoke_cb = SvREFCNT_inc (cb); 3231 coro->invoke_cb = SvREFCNT_inc (cb);
3108 coro->invoke_av = av; 3232 coro->invoke_av = av;
3109 } 3233 }
3110 3234
3111 api_ready ((SV *)hv); 3235 api_ready (aTHX_ (SV *)hv);
3112 3236
3113 if (GIMME_V != G_VOID) 3237 if (GIMME_V != G_VOID)
3114 XPUSHs (sv_2mortal (newRV_noinc ((SV *)hv))); 3238 XPUSHs (sv_2mortal (newRV_noinc ((SV *)hv)));
3115 else 3239 else
3116 SvREFCNT_dec (hv); 3240 SvREFCNT_dec (hv);

Diff Legend

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