X-Git-Url: https://perl5.git.perl.org/perl5.git/blobdiff_plain/86d2498c0b3132b9d76f935b317b213effc43990..1e4f088863436a8019c7d864691903ffdafeefda:/pad.c diff --git a/pad.c b/pad.c index 148fdf8..70519e4 100644 --- a/pad.c +++ b/pad.c @@ -196,7 +196,7 @@ sv_eq_pvn_flags(pTHX_ const SV *sv, const char* pv, const STRLEN pvlen, const U3 sv_recode_to_utf8(svrecode, PL_encoding); pv1 = SvPV_const(svrecode, cur1); } - SvREFCNT_dec(svrecode); + SvREFCNT_dec_NN(svrecode); } if (flags & SVf_UTF8) return (bytes_cmp_utf8( @@ -247,8 +247,8 @@ Perl_pad_new(pTHX_ int flags) if (flags & padnew_SAVE) { SAVECOMPPAD(); - SAVESPTR(PL_comppad_name); if (! (flags & padnew_CLONE)) { + SAVESPTR(PL_comppad_name); SAVEI32(PL_padix); SAVEI32(PL_comppad_name_fill); SAVEI32(PL_min_intro_pending); @@ -265,7 +265,6 @@ Perl_pad_new(pTHX_ int flags) /* ... create new pad ... */ Newxz(padlist, 1, PADLIST); - padname = newAV(); pad = newAV(); if (flags & padnew_CLONE) { @@ -277,10 +276,12 @@ Perl_pad_new(pTHX_ int flags) AV * const a0 = newAV(); /* will be @_ */ av_store(pad, 0, MUTABLE_SV(a0)); AvREIFY_only(a0); + + padname = (PAD *)SvREFCNT_inc_simple_NN(PL_comppad_name); } else { - padlist->xpadl_id = PL_padlist_generation++; av_store(pad, 0, NULL); + padname = newAV(); } /* Most subroutines never recurse, hence only need 2 entries in the padlist @@ -295,11 +296,11 @@ Perl_pad_new(pTHX_ int flags) /* ... then update state variables */ - PL_comppad_name = padname; PL_comppad = pad; PL_curpad = AvARRAY(pad); if (! (flags & padnew_CLONE)) { + PL_comppad_name = padname; PL_comppad_name_fill = 0; PL_min_intro_pending = 0; PL_padix = 0; @@ -369,6 +370,8 @@ Perl_cv_undef(pTHX_ CV *cv) PAD_SAVE_SETNULLPAD(); /* discard any leaked ops */ + if (PL_parser) + parser_free_nexttoke_ops(PL_parser, (OPSLAB *)CvSTART(cv)); opslab_force_free((OPSLAB *)CvSTART(cv)); CvSTART(cv) = NULL; @@ -379,7 +382,8 @@ Perl_cv_undef(pTHX_ CV *cv) #endif SvPOK_off(MUTABLE_SV(cv)); /* forget prototype */ sv_unmagic((SV *)cv, PERL_MAGIC_checkcall); - CvGV_set(cv, NULL); + if (CvNAMED(cv)) CvNAME_HEK_set(cv, NULL); + else CvGV_set(cv, NULL); /* This statement and the subsequence if block was pad_undef(). */ pad_peg("pad_undef"); @@ -420,12 +424,10 @@ Perl_cv_undef(pTHX_ CV *cv) U32 inner_rc = SvREFCNT(innercv); assert(inner_rc); assert(SvTYPE(innercv) != SVt_PVFM); - namepad[ix] = NULL; - SvREFCNT_dec(namesv); if (SvREFCNT(comppad) < 2) { /* allow for /(?{ sub{} })/ */ curpad[ix] = NULL; - SvREFCNT_dec(innercv); + SvREFCNT_dec_NN(innercv); inner_rc--; } @@ -455,12 +457,12 @@ Perl_cv_undef(pTHX_ CV *cv) PL_comppad = NULL; PL_curpad = NULL; } - SvREFCNT_dec(sv); + SvREFCNT_dec_NN(sv); } } { PAD * const sv = PadlistARRAY(padlist)[0]; - if (sv == PL_comppad_name) + if (sv == PL_comppad_name && SvREFCNT(sv) == 1) PL_comppad_name = NULL; SvREFCNT_dec(sv); } @@ -505,9 +507,7 @@ void Perl_cv_forget_slab(pTHX_ CV *cv) { const bool slabbed = !!CvSLABBED(cv); -#ifdef PERL_DEBUG_READONLY_OPS OPSLAB *slab = NULL; -#endif PERL_ARGS_ASSERT_CV_FORGET_SLAB; @@ -515,25 +515,21 @@ Perl_cv_forget_slab(pTHX_ CV *cv) CvSLABBED_off(cv); -#ifdef PERL_DEBUG_READONLY_OPS if (CvROOT(cv)) slab = OpSLAB(CvROOT(cv)); else if (CvSTART(cv)) slab = (OPSLAB *)CvSTART(cv); -#else - if (CvROOT(cv)) OpslabREFCNT_dec(OpSLAB(CvROOT(cv))); - else if (CvSTART(cv)) OpslabREFCNT_dec((OPSLAB *)CvSTART(cv)); -#endif #ifdef DEBUGGING else if (slabbed) Perl_warn(aTHX_ "Slab leaked from cv %p", cv); #endif -#ifdef PERL_DEBUG_READONLY_OPS if (slab) { - size_t refcnt; - refcnt = slab->opslab_refcnt; +#ifdef PERL_DEBUG_READONLY_OPS + const size_t refcnt = slab->opslab_refcnt; +#endif OpslabREFCNT_dec(slab); +#ifdef PERL_DEBUG_READONLY_OPS if (refcnt > 1) Slab_to_ro(slab); - } #endif + } } /* @@ -631,8 +627,12 @@ Perl_pad_add_name_pvn(pTHX_ const char *namepv, STRLEN namelen, flags &= ~padadd_UTF8_NAME; if ((flags & padadd_NO_DUP_CHECK) == 0) { + ENTER; + SAVEFREESV(namesv); /* in case of fatal warnings */ /* check for duplicate declaration */ pad_check_dup(namesv, flags & padadd_OUR, ourstash); + SvREFCNT_inc_simple_void_NN(namesv); + LEAVE; } offset = pad_alloc_name(namesv, flags & ~padadd_UTF8_NAME, typestash, ourstash); @@ -651,6 +651,8 @@ Perl_pad_add_name_pvn(pTHX_ const char *namepv, STRLEN namelen, sv_upgrade(PL_curpad[offset], SVt_PVAV); else if (namelen != 0 && *namepv == '%') sv_upgrade(PL_curpad[offset], SVt_PVHV); + else if (namelen != 0 && *namepv == '&') + sv_upgrade(PL_curpad[offset], SVt_PVCV); assert(SvPADMY(PL_curpad[offset])); DEBUG_Xv(PerlIO_printf(Perl_debug_log, "Pad addname: %ld \"%s\" new lex=0x%"UVxf"\n", @@ -828,7 +830,7 @@ Perl_pad_add_anon(pTHX_ CV* func, I32 optype) if (CvOUTSIDE(func) && SvTYPE(func) == SVt_PVCV) { assert(!CvWEAKOUTSIDE(func)); CvWEAKOUTSIDE_on(func); - SvREFCNT_dec(CvOUTSIDE(func)); + SvREFCNT_dec_NN(CvOUTSIDE(func)); } return ix; } @@ -880,9 +882,11 @@ S_pad_check_dup(pTHX_ SV *name, U32 flags, const HV *ourstash) { if (is_our && (SvPAD_OUR(sv))) break; /* "our" masking "our" */ + /* diag_listed_as: "%s" variable %s masks earlier declaration in same %s */ Perl_warner(aTHX_ packWARN(WARN_MISC), - "\"%s\" variable %"SVf" masks earlier declaration in same %s", + "\"%s\" %s %"SVf" masks earlier declaration in same %s", (is_our ? "our" : PL_parser->in_my == KEY_my ? "my" : "state"), + *SvPVX(sv) == '&' ? "subroutine" : "variable", sv, (COP_SEQ_RANGE_HIGH(sv) == PERL_PADSEQ_INTRO ? "scope" : "statement")); @@ -1115,8 +1119,19 @@ the parent pad. #define CvCOMPILED(cv) CvROOT(cv) /* the CV does late binding of its lexicals */ -#define CvLATE(cv) (CvANON(cv) || SvTYPE(cv) == SVt_PVFM) +#define CvLATE(cv) (CvANON(cv) || CvCLONE(cv) || SvTYPE(cv) == SVt_PVFM) +static void +S_unavailable(pTHX_ SV *namesv) +{ + /* diag_listed_as: Variable "%s" is not available */ + Perl_ck_warner(aTHX_ packWARN(WARN_CLOSURE), + "%se \"%"SVf"\" is not available", + *SvPVX_const(namesv) == '&' + ? "Subroutin" + : "Variabl", + namesv); +} STATIC PADOFFSET S_pad_findlex(pTHX_ const char *namepv, STRLEN namelen, U32 flags, const CV* cv, U32 seq, @@ -1239,8 +1254,7 @@ S_pad_findlex(pTHX_ const char *namepv, STRLEN namelen, U32 flags, const CV* cv, : *out_flags & PAD_FAKELEX_ANON) { if (warn) - Perl_ck_warner(aTHX_ packWARN(WARN_CLOSURE), - "Variable \"%"SVf"\" is not available", + S_unavailable(aTHX_ newSVpvn_flags(namepv, namelen, SVs_TEMP | (flags & padadd_UTF8_NAME ? SVf_UTF8 : 0))); @@ -1288,8 +1302,7 @@ S_pad_findlex(pTHX_ const char *namepv, STRLEN namelen, U32 flags, const CV* cv, && (!CvDEPTH(cv) || !staleok) && !SvPAD_STATE(name_svp[offset])) { - Perl_ck_warner(aTHX_ packWARN(WARN_CLOSURE), - "Variable \"%"SVf"\" is not available", + S_unavailable(aTHX_ newSVpvn_flags(namepv, namelen, SVs_TEMP | (flags & padadd_UTF8_NAME ? SVf_UTF8 : 0))); @@ -1301,6 +1314,8 @@ S_pad_findlex(pTHX_ const char *namepv, STRLEN namelen, U32 flags, const CV* cv, *out_capture = sv_2mortal(MUTABLE_SV(newAV())); else if (namelen != 0 && *namepv == '%') *out_capture = sv_2mortal(MUTABLE_SV(newHV())); + else if (namelen != 0 && *namepv == '&') + *out_capture = sv_2mortal(newSV_type(SVt_PVCV)); else *out_capture = sv_newmortal(); } @@ -1373,6 +1388,8 @@ S_pad_findlex(pTHX_ const char *namepv, STRLEN namelen, U32 flags, const CV* cv, else { /* immediate creation - capture outer value right now */ av_store(PL_comppad, new_offset, SvREFCNT_inc(*new_capturep)); + /* But also note the offset, as newMYSUB needs it */ + PARENT_PAD_INDEX_set(new_namesv, offset); DEBUG_Xv(PerlIO_printf(Perl_debug_log, "Pad findlex cv=0x%"UVxf" saved captured sv 0x%"UVxf" at offset %ld\n", PTR2UV(cv), PTR2UV(*new_capturep), (long)new_offset)); @@ -1534,11 +1551,12 @@ lexicals in this scope and warn of any lexicals that never got introduced. =cut */ -void +OP * Perl_pad_leavemy(pTHX) { dVAR; I32 off; + OP *o = NULL; SV * const * const svp = AvARRAY(PL_comppad_name); PL_pad_reset_pending = FALSE; @@ -1555,7 +1573,7 @@ Perl_pad_leavemy(pTHX) } /* "Deintroduce" my variables that are leaving with this scope. */ for (off = AvFILLp(PL_comppad_name); off > PL_comppad_name_fill; off--) { - const SV * const sv = svp[off]; + SV * const sv = svp[off]; if (sv && sv != &PL_sv_undef && !SvFAKE(sv) && COP_SEQ_RANGE_HIGH(sv) == PERL_PADSEQ_INTRO) { @@ -1566,6 +1584,12 @@ Perl_pad_leavemy(pTHX) (unsigned long)COP_SEQ_RANGE_LOW(sv), (unsigned long)COP_SEQ_RANGE_HIGH(sv)) ); + if (!PadnameIsSTATE(sv) && !PadnameIsOUR(sv) + && *PadnamePV(sv) == '&' && PadnameLEN(sv) > 1) { + OP *kid = newOP(OP_INTROCV, 0); + kid->op_targ = off; + o = op_prepend_elem(OP_LINESEQ, kid, o); + } } } PL_cop_seqmax++; @@ -1573,6 +1597,7 @@ Perl_pad_leavemy(pTHX) PL_cop_seqmax++; DEBUG_Xv(PerlIO_printf(Perl_debug_log, "Pad leavemy: seq = %ld\n", (long)PL_cop_seqmax)); + return o; } /* @@ -1650,7 +1675,7 @@ S_pad_reset(pTHX) ) ); - if (!PL_tainting) { /* Can't mix tainted and non-tainted temporaries. */ + if (!TAINTING_get) { /* Can't mix tainted and non-tainted temporaries. */ I32 po; for (po = AvMAX(PL_comppad); po > PL_padix_floor; po--) { if (PL_curpad[po] && !SvIMMORTAL(PL_curpad[po])) @@ -1689,13 +1714,21 @@ Perl_pad_tidy(pTHX_ padtidy_type type) ASSERT_CURPAD_ACTIVE("pad_tidy"); - /* If this CV has had any 'eval-capable' ops planted in it - * (ie it contains eval '...', //ee, /$var/ or /(?{..})/), Then any - * anon prototypes in the chain of CVs should be marked as cloneable, - * so that for example the eval's CV in C<< sub { eval '$x' } >> gets - * the right CvOUTSIDE. - * If running with -d, *any* sub may potentially have an eval - * executed within it. + /* If this CV has had any 'eval-capable' ops planted in it: + * i.e. it contains any of: + * + * * eval '...', + * * //ee, + * * use re 'eval'; /$var/ + * * /(?{..})/), + * + * Then any anon prototypes in the chain of CVs should be marked as + * cloneable, so that for example the eval's CV in + * + * sub { eval '$x' } + * + * gets the right CvOUTSIDE. If running with -d, *any* sub may + * potentially have an eval executed within it. */ if (PL_cv_has_eval || PL_perldb) { @@ -1707,8 +1740,8 @@ Perl_pad_tidy(pTHX_ padtidy_type type) DEBUG_Xv(PerlIO_printf(Perl_debug_log, "Pad clone on cv=0x%"UVxf"\n", PTR2UV(cv))); CvCLONE_on(cv); - CvHASEVAL_on(cv); } + CvHASEVAL_on(cv); } } @@ -1791,6 +1824,7 @@ void Perl_pad_free(pTHX_ PADOFFSET po) { dVAR; + SV *sv; ASSERT_CURPAD_LEGAL("pad_free"); if (!PL_curpad) return; @@ -1805,9 +1839,11 @@ Perl_pad_free(pTHX_ PADOFFSET po) PTR2UV(PL_comppad), PTR2UV(PL_curpad), (long)po) ); - if (PL_curpad[po] && PL_curpad[po] != &PL_sv_undef) { - SvFLAGS(PL_curpad[po]) &= ~SVs_PADTMP; /* also clears SVs_PADSTALE */ - } + + sv = PL_curpad[po]; + if (sv && sv != &PL_sv_undef && !SvPADMY(sv)) + SvFLAGS(sv) &= ~SVs_PADTMP; + if ((I32)po < PL_padix) PL_padix = po - 1; } @@ -1937,93 +1973,77 @@ the immediately surrounding code. =cut */ -CV * -Perl_cv_clone(pTHX_ CV *proto) +static CV *S_cv_clone(pTHX_ CV *proto, CV *cv, CV *outside); + +static void +S_cv_clone_pad(pTHX_ CV *proto, CV *cv, CV *outside, bool newcv) { dVAR; I32 ix; PADLIST* const protopadlist = CvPADLIST(proto); - const PAD *const protopad_name = *PadlistARRAY(protopadlist); + PAD *const protopad_name = *PadlistARRAY(protopadlist); const PAD *const protopad = PadlistARRAY(protopadlist)[1]; SV** const pname = AvARRAY(protopad_name); SV** const ppad = AvARRAY(protopad); const I32 fname = AvFILLp(protopad_name); const I32 fpad = AvFILLp(protopad); - CV* cv; SV** outpad; - CV* outside; long depth; - - PERL_ARGS_ASSERT_CV_CLONE; + bool subclones = FALSE; assert(!CvUNIQUE(proto)); /* Anonymous subs have a weak CvOUTSIDE pointer, so its value is not * reliable. The currently-running sub is always the one we need to * close over. + * For my subs, the currently-running sub may not be the one we want. + * We have to check whether it is a clone of CvOUTSIDE. * Note that in general for formats, CvOUTSIDE != find_runcv. * Since formats may be nested inside closures, CvOUTSIDE may point * to a prototype; we instead want the cloned parent who called us. */ - if (SvTYPE(proto) == SVt_PVCV) + if (!outside) { + if (CvWEAKOUTSIDE(proto)) outside = find_runcv(NULL); - else { + else { outside = CvOUTSIDE(proto); if ((CvCLONE(outside) && ! CvCLONED(outside)) || !CvPADLIST(outside) - || CvPADLIST(outside)->xpadl_id != protopadlist->xpadl_outid) { + || PadlistNAMES(CvPADLIST(outside)) + != protopadlist->xpadl_outid) { outside = find_runcv_where( - FIND_RUNCV_padid_eq, (IV)protopadlist->xpadl_outid, NULL + FIND_RUNCV_padid_eq, PTR2IV(protopadlist->xpadl_outid), NULL ); /* outside could be null */ } + } } depth = outside ? CvDEPTH(outside) : 0; - assert(depth || SvTYPE(proto) == SVt_PVFM); if (!depth) depth = 1; - assert(SvTYPE(proto) == SVt_PVFM || CvPADLIST(outside)); ENTER; SAVESPTR(PL_compcv); + PL_compcv = cv; + if (newcv) SAVEFREESV(cv); /* in case of fatal warnings */ - cv = PL_compcv = MUTABLE_CV(newSV_type(SvTYPE(proto))); - CvFLAGS(cv) = CvFLAGS(proto) & ~(CVf_CLONE|CVf_WEAKOUTSIDE|CVf_CVGV_RC - |CVf_SLABBED); - CvCLONED_on(cv); - - CvFILE(cv) = CvDYNFILE(proto) ? savepv(CvFILE(proto)) - : CvFILE(proto); - CvGV_set(cv,CvGV(proto)); - CvSTASH_set(cv, CvSTASH(proto)); - OP_REFCNT_LOCK; - CvROOT(cv) = OpREFCNT_inc(CvROOT(proto)); - OP_REFCNT_UNLOCK; - CvSTART(cv) = CvSTART(proto); if (CvHASEVAL(cv)) CvOUTSIDE(cv) = MUTABLE_CV(SvREFCNT_inc_simple(outside)); - CvOUTSIDE_SEQ(cv) = CvOUTSIDE_SEQ(proto); - - if (SvPOK(proto)) - sv_setpvn(MUTABLE_SV(cv), SvPVX_const(proto), SvCUR(proto)); - if (SvMAGIC(proto)) - mg_copy((SV *)proto, (SV *)cv, 0, 0); + SAVESPTR(PL_comppad_name); + PL_comppad_name = protopad_name; CvPADLIST(cv) = pad_new(padnew_CLONE|padnew_SAVE); - CvPADLIST(cv)->xpadl_id = protopadlist->xpadl_id; av_fill(PL_comppad, fpad); - for (ix = fname; ix > 0; ix--) - av_store(PL_comppad_name, ix, SvREFCNT_inc(pname[ix])); PL_curpad = AvARRAY(PL_comppad); outpad = outside && CvPADLIST(outside) ? AvARRAY(PadlistARRAY(CvPADLIST(outside))[depth]) : NULL; - assert(outpad || SvTYPE(cv) == SVt_PVFM); - if (outpad) CvPADLIST(cv)->xpadl_outid = CvPADLIST(outside)->xpadl_id; + if (outpad) + CvPADLIST(cv)->xpadl_outid = PadlistNAMES(CvPADLIST(outside)); for (ix = fpad; ix > 0; ix--) { SV* const namesv = (ix <= fname) ? pname[ix] : NULL; @@ -2035,9 +2055,7 @@ Perl_cv_clone(pTHX_ CV *proto) if (!outpad || !(sv = outpad[PARENT_PAD_INDEX(namesv)]) || ( SvPADSTALE(sv) && !SvPAD_STATE(namesv) && (!outside || !CvDEPTH(outside))) ) { - assert(SvTYPE(cv) == SVt_PVFM); - Perl_ck_warner(aTHX_ packWARN(WARN_CLOSURE), - "Variable \"%"SVf"\" is not available", namesv); + S_unavailable(aTHX_ namesv); sv = NULL; } else @@ -2046,7 +2064,33 @@ Perl_cv_clone(pTHX_ CV *proto) if (!sv) { const char sigil = SvPVX_const(namesv)[0]; if (sigil == '&') - sv = SvREFCNT_inc(ppad[ix]); + /* If there are state subs, we need to clone them, too. + But they may need to close over variables we have + not cloned yet. So we will have to do a second + pass. Furthermore, there may be state subs clos- + ing over other state subs’ entries, so we have + to put a stub here and then clone into it on the + second pass. */ + if (SvPAD_STATE(namesv) && !CvCLONED(ppad[ix])) { + assert(SvTYPE(ppad[ix]) == SVt_PVCV); + subclones = 1; + sv = newSV_type(SVt_PVCV); + } + else if (PadnameLEN(namesv)>1 && !PadnameIsOUR(namesv)) + { + /* my sub */ + /* Just provide a stub, but name it. It will be + upgrade to the real thing on scope entry. */ + sv = newSV_type(SVt_PVCV); + CvNAME_HEK_set( + sv, + share_hek(SvPVX_const(namesv)+1, + SvCUR(namesv) - 1 + * (SvUTF8(namesv) ? -1 : 1), + 0) + ); + } + else sv = SvREFCNT_inc(ppad[ix]); else if (sigil == '@') sv = MUTABLE_SV(newAV()); else if (sigil == '%') @@ -2055,7 +2099,7 @@ Perl_cv_clone(pTHX_ CV *proto) sv = newSV(0); SvPADMY_on(sv); /* reset the 'assign only once' flag on each state var */ - if (SvPAD_STATE(namesv)) + if (sigil != '&' && SvPAD_STATE(namesv)) SvPADSTALE_on(sv); } } @@ -2069,15 +2113,57 @@ Perl_cv_clone(pTHX_ CV *proto) PL_curpad[ix] = sv; } + if (subclones) + for (ix = fpad; ix > 0; ix--) { + SV* const namesv = (ix <= fname) ? pname[ix] : NULL; + if (namesv && namesv != &PL_sv_undef && !SvFAKE(namesv) + && SvPVX_const(namesv)[0] == '&' && SvPAD_STATE(namesv)) + S_cv_clone(aTHX_ (CV *)ppad[ix], (CV *)PL_curpad[ix], cv); + } + + if (newcv) SvREFCNT_inc_simple_void_NN(cv); + LEAVE; +} + +static CV * +S_cv_clone(pTHX_ CV *proto, CV *cv, CV *outside) +{ + dVAR; + const bool newcv = !cv; + + assert(!CvUNIQUE(proto)); + + if (!cv) cv = MUTABLE_CV(newSV_type(SvTYPE(proto))); + CvFLAGS(cv) = CvFLAGS(proto) & ~(CVf_CLONE|CVf_WEAKOUTSIDE|CVf_CVGV_RC + |CVf_SLABBED); + CvCLONED_on(cv); + + CvFILE(cv) = CvDYNFILE(proto) ? savepv(CvFILE(proto)) + : CvFILE(proto); + if (CvNAMED(proto)) + CvNAME_HEK_set(cv, share_hek_hek(CvNAME_HEK(proto))); + else CvGV_set(cv,CvGV(proto)); + CvSTASH_set(cv, CvSTASH(proto)); + OP_REFCNT_LOCK; + CvROOT(cv) = OpREFCNT_inc(CvROOT(proto)); + OP_REFCNT_UNLOCK; + CvSTART(cv) = CvSTART(proto); + CvOUTSIDE_SEQ(cv) = CvOUTSIDE_SEQ(proto); + + if (SvPOK(proto)) + sv_setpvn(MUTABLE_SV(cv), SvPVX_const(proto), SvCUR(proto)); + if (SvMAGIC(proto)) + mg_copy((SV *)proto, (SV *)cv, 0, 0); + + if (CvPADLIST(proto)) S_cv_clone_pad(aTHX_ proto, cv, outside, newcv); + DEBUG_Xv( PerlIO_printf(Perl_debug_log, "\nPad CV clone\n"); - if (outside) cv_dump(outside, "Outside"); + if (CvOUTSIDE(cv)) cv_dump(CvOUTSIDE(cv), "Outside"); cv_dump(proto, "Proto"); cv_dump(cv, "To"); ); - LEAVE; - if (CvCONST(cv)) { /* Constant sub () { $x } closing over $x - see lib/constant.pm: * The prototype was marked as a candiate for const-ization, @@ -2086,7 +2172,7 @@ Perl_cv_clone(pTHX_ CV *proto) */ SV* const const_sv = op_const_sv(CvSTART(cv), cv); if (const_sv) { - SvREFCNT_dec(cv); + SvREFCNT_dec_NN(cv); /* For this calling case, op_const_sv returns a *copy*, which we donate to newCONSTSUB. Yes, this is ugly, and should be killed. Need to fix how lib/constant.pm works to eliminate this. */ @@ -2100,6 +2186,24 @@ Perl_cv_clone(pTHX_ CV *proto) return cv; } +CV * +Perl_cv_clone(pTHX_ CV *proto) +{ + PERL_ARGS_ASSERT_CV_CLONE; + + if (!CvPADLIST(proto)) Perl_croak(aTHX_ "panic: no pad in cv_clone"); + return S_cv_clone(aTHX_ proto, NULL, NULL); +} + +/* Called only by pp_clonecv */ +CV * +Perl_cv_clone_into(pTHX_ CV *proto, CV *target) +{ + PERL_ARGS_ASSERT_CV_CLONE_INTO; + cv_undef(target); + return S_cv_clone(aTHX_ proto, target, NULL); +} + /* =for apidoc m|void|pad_fixup_inner_anons|PADLIST *padlist|CV *old_cv|CV *new_cv @@ -2125,14 +2229,22 @@ Perl_pad_fixup_inner_anons(pTHX_ PADLIST *padlist, CV *old_cv, CV *new_cv) for (ix = AvFILLp(comppad_name); ix > 0; ix--) { const SV * const namesv = namepad[ix]; - if (namesv && namesv != &PL_sv_undef + if (namesv && namesv != &PL_sv_undef && !SvPAD_STATE(namesv) && *SvPVX_const(namesv) == '&') { if (SvTYPE(curpad[ix]) == SVt_PVCV) { - CV * const innercv = MUTABLE_CV(curpad[ix]); - assert(CvWEAKOUTSIDE(innercv)); - assert(CvOUTSIDE(innercv) == old_cv); - CvOUTSIDE(innercv) = new_cv; + MAGIC * const mg = + SvMAGICAL(curpad[ix]) + ? mg_find(curpad[ix], PERL_MAGIC_proto) + : NULL; + CV * const innercv = MUTABLE_CV(mg ? mg->mg_obj : curpad[ix]); + if (CvOUTSIDE(innercv) == old_cv) { + if (!CvWEAKOUTSIDE(innercv)) { + SvREFCNT_dec(old_cv); + SvREFCNT_inc_simple_void_NN(new_cv); + } + CvOUTSIDE(innercv) = new_cv; + } } else { /* format reference */ SV * const rv = curpad[ix]; @@ -2365,7 +2477,7 @@ Perl_padlist_dup(pTHX_ PADLIST *srcpad, CLONE_PARAMS *param) #endif /* USE_ITHREADS */ PAD ** -Perl_padlist_store(pTHX_ register PADLIST *padlist, I32 key, PAD *val) +Perl_padlist_store(pTHX_ PADLIST *padlist, I32 key, PAD *val) { dVAR; PAD **ary;