X-Git-Url: https://perl5.git.perl.org/perl5.git/blobdiff_plain/7f73a9f140198d1b3d1c2f2b62d4fd14dc5667c3..f9e705e84896ce390b7b030e30d69a681032f6b1:/pad.c diff --git a/pad.c b/pad.c index 58a37e6..3b52c20 100644 --- a/pad.c +++ b/pad.c @@ -1,6 +1,6 @@ /* pad.c * - * Copyright (C) 2002, 2003, 2004, 2005 by Larry Wall and others + * Copyright (C) 2002, 2003, 2004, 2005, 2006, by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. @@ -74,10 +74,10 @@ in PL_op->op_targ), wasting a name SV for them doesn't make sense. The SVs in the names AV have their PV being the name of the variable. NV+1..IV inclusive is a range of cop_seq numbers for which the name is valid. For typed lexicals name SV is SVt_PVMG and SvSTASH points at the -type. For C lexicals, the type is SVt_PVGV, and GvSTASH points at the -stash of the associated global (so that duplicate C delarations in the -same package can be detected). SvCUR is sometimes hijacked to -store the generation number during compilation. +type. For C lexicals, the type is also SVt_PVGV, with the MAGIC slot +pointing at the stash of the associated global (so that duplicate C +declarations in the same package can be detected). SvCUR is sometimes +hijacked to store the generation number during compilation. If SvFAKE is set on the name SV, then that slot in the frame AV is a REFCNT'ed reference to a lexical from "outside". In this case, @@ -109,11 +109,17 @@ to be generated in evals, such as #include "EXTERN.h" #define PERL_IN_PAD_C #include "perl.h" +#include "keywords.h" #define PAD_MAX 999999999 - +#ifdef PERL_MAD +void pad_peg(const char* s) { + static int pegcnt; + pegcnt++; +} +#endif /* =for apidoc pad_new @@ -132,6 +138,7 @@ can be OR'ed together: PADLIST * Perl_pad_new(pTHX_ int flags) { + dVAR; AV *padlist, *padname, *pad; ASSERT_CURPAD_LEGAL("pad_new"); @@ -179,7 +186,7 @@ Perl_pad_new(pTHX_ int flags) AvREIFY_only(a0); } else { - av_store(pad, 0, Nullsv); + av_store(pad, 0, NULL); } AvREAL_off(padlist); @@ -228,12 +235,14 @@ taken) void Perl_pad_undef(pTHX_ CV* cv) { + dVAR; I32 ix; const PADLIST * const padlist = CvPADLIST(cv); + pad_peg("pad_undef"); if (!padlist) return; - if (!SvREFCNT(CvPADLIST(cv))) /* may be during global destruction */ + if (SvIS_FREED(padlist)) /* may be during global destruction */ return; DEBUG_X(PerlIO_printf(Perl_debug_log, @@ -262,50 +271,48 @@ Perl_pad_undef(pTHX_ CV* cv) CV * const innercv = (CV*)curpad[ix]; U32 inner_rc = SvREFCNT(innercv); assert(inner_rc); - namepad[ix] = Nullsv; + namepad[ix] = NULL; SvREFCNT_dec(namesv); if (SvREFCNT(comppad) < 2) { /* allow for /(?{ sub{} })/ */ - curpad[ix] = Nullsv; + curpad[ix] = NULL; SvREFCNT_dec(innercv); inner_rc--; } - if (inner_rc /* in use, not just a prototype */ - && CvOUTSIDE(innercv) == cv) - { + + /* in use, not just a prototype */ + if (inner_rc && (CvOUTSIDE(innercv) == cv)) { assert(CvWEAKOUTSIDE(innercv)); /* don't relink to grandfather if he's being freed */ if (outercv && SvREFCNT(outercv)) { CvWEAKOUTSIDE_off(innercv); CvOUTSIDE(innercv) = outercv; CvOUTSIDE_SEQ(innercv) = seq; - (void)SvREFCNT_inc(outercv); + SvREFCNT_inc_simple_void_NN(outercv); } else { - CvOUTSIDE(innercv) = Nullcv; + CvOUTSIDE(innercv) = NULL; } - } - } } } ix = AvFILLp(padlist); while (ix >= 0) { - SV* const sv = AvARRAY(padlist)[ix--]; - if (!sv) - continue; - if (sv == (SV*)PL_comppad_name) - PL_comppad_name = Nullav; - else if (sv == (SV*)PL_comppad) { - PL_comppad = Null(PAD*); - PL_curpad = Null(SV**); + const SV* const sv = AvARRAY(padlist)[ix--]; + if (sv) { + if (sv == (SV*)PL_comppad_name) + PL_comppad_name = NULL; + else if (sv == (SV*)PL_comppad) { + PL_comppad = NULL; + PL_curpad = NULL; + } } SvREFCNT_dec(sv); } SvREFCNT_dec((SV*)CvPADLIST(cv)); - CvPADLIST(cv) = Null(PADLIST*); + CvPADLIST(cv) = NULL; } @@ -319,7 +326,7 @@ offset. If C is valid, the name is for a typed lexical; set the name's stash to that value. If C is valid, it's an our lexical, set the name's -GvSTASH to that value +OURSTASH to that value If fake, it means we're cloning an existing entry @@ -327,25 +334,29 @@ If fake, it means we're cloning an existing entry */ PADOFFSET -Perl_pad_add_name(pTHX_ const char *name, HV* typestash, HV* ourstash, bool fake) +Perl_pad_add_name(pTHX_ const char *name, HV* typestash, HV* ourstash, bool fake, bool state) { + dVAR; const PADOFFSET offset = pad_alloc(OP_PADSV, SVs_PADMY); - SV* const namesv = NEWSV(1102, 0); + SV* const namesv = newSV(0); ASSERT_CURPAD_ACTIVE("pad_add_name"); - sv_upgrade(namesv, ourstash ? SVt_PVGV : typestash ? SVt_PVMG : SVt_PVNV); + sv_upgrade(namesv, (ourstash || typestash) ? SVt_PVMG : SVt_PVNV); sv_setpv(namesv, name); if (typestash) { - SvFLAGS(namesv) |= SVpad_TYPED; - SvSTASH_set(namesv, (HV*)SvREFCNT_inc((SV*) typestash)); + SvPAD_TYPED_on(namesv); + SvSTASH_set(namesv, (HV*)SvREFCNT_inc_simple_NN((SV*)typestash)); } if (ourstash) { - SvFLAGS(namesv) |= SVpad_OUR; - GvSTASH(namesv) = ourstash; - Perl_sv_add_backref(aTHX_ (SV*)ourstash, namesv); + SvPAD_OUR_on(namesv); + OURSTASH_set(namesv, ourstash); + SvREFCNT_inc_simple_void_NN(ourstash); + } + else if (state) { + SvPAD_STATE_on(namesv); } av_store(PL_comppad_name, offset, namesv); @@ -386,21 +397,29 @@ Perl_pad_add_name(pTHX_ const char *name, HV* typestash, HV* ourstash, bool fake Allocate a new my or tmp pad entry. For a my, simply push a null SV onto the end of PL_comppad, but for a tmp, scan the pad from PL_padix upwards -for a slot which has no name and and no active value. +for a slot which has no name and no active value. =cut */ /* XXX DAPM integrate alloc(), add_name() and add_anon(), * or at least rationalise ??? */ - +/* And flag whether the incoming name is UTF8 or 8 bit? + Could do this either with the +ve/-ve hack of the HV code, or expanding + the flag bits. Either way, this makes proper Unicode safe pad support. + Also could change the sv structure to make the NV a union with 2 U32s, + so that SvCUR() could stop being overloaded in pad SVs. + NWC +*/ PADOFFSET Perl_pad_alloc(pTHX_ I32 optype, U32 tmptype) { + dVAR; SV *sv; I32 retval; + PERL_UNUSED_ARG(optype); ASSERT_CURPAD_ACTIVE("pad_alloc"); if (AvARRAY(PL_comppad) != PL_curpad) @@ -412,7 +431,7 @@ Perl_pad_alloc(pTHX_ I32 optype, U32 tmptype) retval = AvFILLp(PL_comppad); } else { - SV ** const names = AvARRAY(PL_comppad_name); + SV * const * const names = AvARRAY(PL_comppad_name); const SSize_t names_fill = AvFILLp(PL_comppad_name); for (;;) { /* @@ -456,8 +475,10 @@ Add an anon code entry to the current compiling pad PADOFFSET Perl_pad_add_anon(pTHX_ SV* sv, OPCODE op_type) { + dVAR; PADOFFSET ix; - SV* const name = NEWSV(1106, 0); + SV* const name = newSV(0); + pad_peg("add_anon"); sv_upgrade(name, SVt_PVNV); sv_setpvn(name, "&", 1); SvIV_set(name, -1); @@ -497,6 +518,7 @@ C indicates that the name to check is an 'our' declaration void Perl_pad_check_dup(pTHX_ const char *name, bool is_our, const HV *ourstash) { + dVAR; SV **svp; PADOFFSET top, off; @@ -517,11 +539,11 @@ Perl_pad_check_dup(pTHX_ const char *name, bool is_our, const HV *ourstash) && (SvIVX(sv) == PAD_MAX || SvIVX(sv) == 0) && strEQ(name, SvPVX_const(sv))) { - if (is_our && (SvFLAGS(sv) & SVpad_OUR)) + if (is_our && (SvPAD_OUR(sv))) break; /* "our" masking "our" */ Perl_warner(aTHX_ packWARN(WARN_MISC), "\"%s\" variable %s masks earlier declaration in same %s", - (is_our ? "our" : "my"), + (is_our ? "our" : PL_in_my == KEY_my ? "my" : "state"), name, (SvIVX(sv) == PAD_MAX ? "scope" : "statement")); --off; @@ -536,12 +558,12 @@ Perl_pad_check_dup(pTHX_ const char *name, bool is_our, const HV *ourstash) && sv != &PL_sv_undef && !SvFAKE(sv) && (SvIVX(sv) == PAD_MAX || SvIVX(sv) == 0) - && ((SvFLAGS(sv) & SVpad_OUR) && GvSTASH(sv) == ourstash) + && OURSTASH(sv) == ourstash && strEQ(name, SvPVX_const(sv))) { Perl_warner(aTHX_ packWARN(WARN_MISC), "\"our\" variable %s redeclared", name); - if (off <= PL_comppad_name_floor) + if ((I32)off <= PL_comppad_name_floor) Perl_warner(aTHX_ packWARN(WARN_MISC), "\t(Did you mean \"local\" instead of \"our\"?)\n"); break; @@ -566,15 +588,17 @@ Returns the offset in the current pad, or NOT_IN_PAD on failure. PADOFFSET Perl_pad_findmy(pTHX_ const char *name) { + dVAR; SV *out_sv; int out_flags; I32 offset; const AV *nameav; SV **name_svp; - offset = pad_findlex(name, PL_compcv, PL_cop_seqmax, 1, - Null(SV**), &out_sv, &out_flags); - if (offset != NOT_IN_PAD) + pad_peg("pad_findmy"); + offset = pad_findlex(name, PL_compcv, PL_cop_seqmax, 1, + NULL, &out_sv, &out_flags); + if ((PADOFFSET)offset != NOT_IN_PAD) return offset; /* look for an our that's being introduced; this allows @@ -584,10 +608,10 @@ Perl_pad_findmy(pTHX_ const char *name) nameav = (AV*)AvARRAY(CvPADLIST(PL_compcv))[0]; name_svp = AvARRAY(nameav); for (offset = AvFILLp(nameav); offset > 0; offset--) { - const SV *namesv = name_svp[offset]; + const SV * const namesv = name_svp[offset]; if (namesv && namesv != &PL_sv_undef && !SvFAKE(namesv) - && (SvFLAGS(namesv) & SVpad_OUR) + && (SvPAD_OUR(namesv)) && strEQ(SvPVX_const(namesv), name) && U_32(SvNVX(namesv)) == PAD_MAX /* min */ ) @@ -604,10 +628,11 @@ Perl_pad_findmy(pTHX_ const char *name) PADOFFSET Perl_find_rundefsvoffset(pTHX) { + dVAR; SV *out_sv; int out_flags; return pad_findlex("$_", find_runcv(NULL), PL_curcop->cop_seq, 1, - Null(SV**), &out_sv, &out_flags); + NULL, &out_sv, &out_flags); } /* @@ -650,6 +675,7 @@ STATIC PADOFFSET S_pad_findlex(pTHX_ const char *name, const CV* cv, U32 seq, int warn, SV** out_capture, SV** out_name_sv, int *out_flags) { + dVAR; I32 offset, new_offset; SV *new_capture; SV **new_capturep; @@ -665,11 +691,11 @@ S_pad_findlex(pTHX_ const char *name, const CV* cv, U32 seq, int warn, if (padlist) { /* not an undef CV */ I32 fake_offset = 0; - const AV *nameav = (AV*)AvARRAY(padlist)[0]; - SV **name_svp = AvARRAY(nameav); + const AV * const nameav = (AV*)AvARRAY(padlist)[0]; + SV * const * const name_svp = AvARRAY(nameav); for (offset = AvFILLp(nameav); offset > 0; offset--) { - const SV *namesv = name_svp[offset]; + const SV * const namesv = name_svp[offset]; if (namesv && namesv != &PL_sv_undef && strEQ(SvPVX_const(namesv), name)) { @@ -719,8 +745,8 @@ S_pad_findlex(pTHX_ const char *name, const CV* cv, U32 seq, int warn, if (out_capture) { /* our ? */ - if ((SvFLAGS(*out_name_sv) & SVpad_OUR)) { - *out_capture = Nullsv; + if (SvPAD_OUR(*out_name_sv)) { + *out_capture = NULL; return offset; } @@ -732,7 +758,7 @@ S_pad_findlex(pTHX_ const char *name, const CV* cv, U32 seq, int warn, if (warn && ckWARN(WARN_CLOSURE)) Perl_warner(aTHX_ packWARN(WARN_CLOSURE), "Variable \"%s\" is not available", name); - *out_capture = Nullsv; + *out_capture = NULL; } /* real value */ @@ -771,7 +797,7 @@ S_pad_findlex(pTHX_ const char *name, const CV* cv, U32 seq, int warn, if (ckWARN(WARN_CLOSURE)) Perl_warner(aTHX_ packWARN(WARN_CLOSURE), "Variable \"%s\" is not available", name); - *out_capture = Nullsv; + *out_capture = NULL; } } if (!*out_capture) { @@ -792,17 +818,17 @@ S_pad_findlex(pTHX_ const char *name, const CV* cv, U32 seq, int warn, if (!CvOUTSIDE(cv)) return NOT_IN_PAD; - + /* out_capture non-null means caller wants us to capture lex; in * addition we capture ourselves unless it's an ANON/format */ new_capturep = out_capture ? out_capture : - CvLATE(cv) ? Null(SV**) : &new_capture; + CvLATE(cv) ? NULL : &new_capture; offset = pad_findlex(name, CvOUTSIDE(cv), CvOUTSIDE_SEQ(cv), 1, new_capturep, out_name_sv, out_flags); - if (offset == NOT_IN_PAD) + if ((PADOFFSET)offset == NOT_IN_PAD) return NOT_IN_PAD; - + /* found in an outer CV. Add appropriate fake entry to this pad */ /* don't add new fake entries (via eval) to CVs that we have already @@ -820,19 +846,19 @@ S_pad_findlex(pTHX_ const char *name, const CV* cv, U32 seq, int warn, new_offset = pad_add_name( SvPVX_const(*out_name_sv), - (SvFLAGS(*out_name_sv) & SVpad_TYPED) - ? SvSTASH(*out_name_sv) : Nullhv, - (SvFLAGS(*out_name_sv) & SVpad_OUR) - ? GvSTASH(*out_name_sv) : Nullhv, - 1 /* fake */ + SvPAD_TYPED(*out_name_sv) + ? SvSTASH(*out_name_sv) : NULL, + OURSTASH(*out_name_sv), + 1, /* fake */ + 0 /* not a state variable */ ); new_namesv = AvARRAY(PL_comppad_name)[new_offset]; SvIV_set(new_namesv, *out_flags); SvNV_set(new_namesv, (NV)0); - if (SvFLAGS(new_namesv) & SVpad_OUR) { - /* do nothing */ + if (SvPAD_OUR(new_namesv)) { + NOOP; /* do nothing */ } else if (CvLATE(cv)) { /* delayed creation - just note the offset within parent pad */ @@ -851,12 +877,13 @@ S_pad_findlex(pTHX_ const char *name, const CV* cv, U32 seq, int warn, PL_comppad_name = ocomppad_name; PL_comppad = ocomppad; - PL_curpad = ocomppad ? AvARRAY(ocomppad) : Null(SV **); + PL_curpad = ocomppad ? AvARRAY(ocomppad) : NULL; } return new_offset; } - + +#ifdef DEBUGGING /* =for apidoc pad_sv @@ -870,6 +897,7 @@ Use macro PAD_SV instead of calling this function directly. SV * Perl_pad_sv(pTHX_ PADOFFSET po) { + dVAR; ASSERT_CURPAD_ACTIVE("pad_sv"); if (!po) @@ -891,10 +919,10 @@ Use the macro PAD_SETSV() rather than calling this function directly. =cut */ -#ifdef DEBUGGING void Perl_pad_setsv(pTHX_ PADOFFSET po, SV* sv) { + dVAR; ASSERT_CURPAD_ACTIVE("pad_setsv"); DEBUG_X(PerlIO_printf(Perl_debug_log, @@ -924,6 +952,7 @@ Update the pad compilation state variables on entry to a new block void Perl_pad_block_start(pTHX_ int full) { + dVAR; ASSERT_CURPAD_ACTIVE("pad_block_start"); SAVEI32(PL_comppad_name_floor); PL_comppad_name_floor = AvFILLp(PL_comppad_name); @@ -952,6 +981,7 @@ Perl_pad_block_start(pTHX_ int full) U32 Perl_intro_my(pTHX) { + dVAR; SV **svp; I32 i; @@ -993,8 +1023,9 @@ lexicals in this scope and warn of any lexicals that never got introduced. void Perl_pad_leavemy(pTHX) { + dVAR; I32 off; - SV ** const svp = AvARRAY(PL_comppad_name); + SV * const * const svp = AvARRAY(PL_comppad_name); PL_pad_reset_pending = FALSE; @@ -1005,7 +1036,8 @@ Perl_pad_leavemy(pTHX) if (sv && sv != &PL_sv_undef && !SvFAKE(sv) && ckWARN_d(WARN_INTERNAL)) Perl_warner(aTHX_ packWARN(WARN_INTERNAL), - "%"SVf" never introduced", sv); + "%"SVf" never introduced", + (void*)sv); } } /* "Deintroduce" my variables that are leaving with this scope. */ @@ -1038,6 +1070,7 @@ new one. void Perl_pad_swipe(pTHX_ PADOFFSET po, bool refadjust) { + dVAR; ASSERT_CURPAD_LEGAL("pad_swipe"); if (!PL_curpad) return; @@ -1059,7 +1092,7 @@ Perl_pad_swipe(pTHX_ PADOFFSET po, bool refadjust) /* if pad tmps aren't shared between ops, then there's no need to * create a new tmp when an existing op is freed */ #ifdef USE_BROKEN_PAD_RESET - PL_curpad[po] = NEWSV(1107,0); + PL_curpad[po] = newSV(0); SvPADTMP_on(PL_curpad[po]); #else PL_curpad[po] = &PL_sv_undef; @@ -1086,6 +1119,7 @@ Mark all the current temporaries for reuse void Perl_pad_reset(pTHX) { + dVAR; #ifdef USE_BROKEN_PAD_RESET if (AvARRAY(PL_comppad) != PL_curpad) Perl_croak(aTHX_ "panic: pad_reset curpad"); @@ -1157,10 +1191,10 @@ Perl_pad_tidy(pTHX_ padtidy_type type) /* extend curpad to match namepad */ if (AvFILLp(PL_comppad_name) < AvFILLp(PL_comppad)) - av_store(PL_comppad_name, AvFILLp(PL_comppad), Nullsv); + av_store(PL_comppad_name, AvFILLp(PL_comppad), NULL); if (type == padtidy_SUBCLONE) { - SV ** const namep = AvARRAY(PL_comppad_name); + SV * const * const namep = AvARRAY(PL_comppad_name); PADOFFSET ix; for (ix = AvFILLp(PL_comppad); ix > 0; ix--) { @@ -1173,12 +1207,12 @@ Perl_pad_tidy(pTHX_ padtidy_type type) * pad are anonymous subs. * The rest are created anew during cloning. */ - if (!((namesv = namep[ix]) != Nullsv && + if (!((namesv = namep[ix]) != NULL && namesv != &PL_sv_undef && *SvPVX_const(namesv) == '&')) { SvREFCNT_dec(PL_curpad[ix]); - PL_curpad[ix] = Nullsv; + PL_curpad[ix] = NULL; } } } @@ -1215,7 +1249,7 @@ Perl_pad_tidy(pTHX_ padtidy_type type) /* =for apidoc pad_free -Free the SV at offet po in the current pad. +Free the SV at offset po in the current pad. =cut */ @@ -1224,6 +1258,7 @@ Free the SV at offet po in the current pad. void Perl_pad_free(pTHX_ PADOFFSET po) { + dVAR; ASSERT_CURPAD_LEGAL("pad_free"); if (!PL_curpad) return; @@ -1268,6 +1303,7 @@ Dump the contents of a padlist void Perl_do_dump_pad(pTHX_ I32 level, PerlIO *file, PADLIST *padlist, int full) { + dVAR; const AV *pad_name; const AV *pad; SV **pname; @@ -1289,7 +1325,7 @@ Perl_do_dump_pad(pTHX_ I32 level, PerlIO *file, PADLIST *padlist, int full) for (ix = 1; ix <= AvFILLp(pad_name); ix++) { const SV *namesv = pname[ix]; if (namesv && namesv == &PL_sv_undef) { - namesv = Nullsv; + namesv = NULL; } if (namesv) { if (SvFAKE(namesv)) @@ -1339,6 +1375,7 @@ dump the contents of a CV STATIC void S_cv_dump(pTHX_ const CV *cv, const char *title) { + dVAR; const CV * const outside = CvOUTSIDE(cv); AV* const padlist = CvPADLIST(cv); @@ -1413,14 +1450,14 @@ Perl_cv_clone(pTHX_ CV *proto) ENTER; SAVESPTR(PL_compcv); - cv = PL_compcv = (CV*)NEWSV(1104, 0); + cv = PL_compcv = (CV*)newSV(0); sv_upgrade((SV *)cv, SvTYPE(proto)); CvFLAGS(cv) = CvFLAGS(proto) & ~(CVf_CLONE|CVf_WEAKOUTSIDE); CvCLONED_on(cv); #ifdef USE_ITHREADS - CvFILE(cv) = CvXSUB(proto) ? CvFILE(proto) - : savepv(CvFILE(proto)); + CvFILE(cv) = CvISXSUB(proto) ? CvFILE(proto) + : savepv(CvFILE(proto)); #else CvFILE(cv) = CvFILE(proto); #endif @@ -1430,7 +1467,7 @@ Perl_cv_clone(pTHX_ CV *proto) CvROOT(cv) = OpREFCNT_inc(CvROOT(proto)); OP_REFCNT_UNLOCK; CvSTART(cv) = CvSTART(proto); - CvOUTSIDE(cv) = (CV*)SvREFCNT_inc(outside); + CvOUTSIDE(cv) = (CV*)SvREFCNT_inc_simple(outside); CvOUTSIDE_SEQ(cv) = CvOUTSIDE_SEQ(proto); if (SvPOK(proto)) @@ -1447,8 +1484,8 @@ Perl_cv_clone(pTHX_ CV *proto) outpad = AvARRAY(AvARRAY(CvPADLIST(outside))[depth]); for (ix = fpad; ix > 0; ix--) { - SV* const namesv = (ix <= fname) ? pname[ix] : Nullsv; - SV *sv = Nullsv; + SV* const namesv = (ix <= fname) ? pname[ix] : NULL; + SV *sv = NULL; if (namesv && namesv != &PL_sv_undef) { /* lexical */ if (SvFAKE(namesv)) { /* lexical from outside? */ sv = outpad[(I32)SvNVX(namesv)]; @@ -1458,11 +1495,11 @@ Perl_cv_clone(pTHX_ CV *proto) if (ckWARN(WARN_CLOSURE)) Perl_warner(aTHX_ packWARN(WARN_CLOSURE), "Variable \"%s\" is not available", SvPVX_const(namesv)); - sv = Nullsv; + sv = NULL; } else { assert(!SvPADSTALE(sv)); - sv = SvREFCNT_inc(sv); + SvREFCNT_inc_simple_void_NN(sv); } } if (!sv) { @@ -1474,15 +1511,15 @@ Perl_cv_clone(pTHX_ CV *proto) else if (sigil == '%') sv = (SV*)newHV(); else - sv = NEWSV(0, 0); + sv = newSV(0); SvPADMY_on(sv); } } else if (IS_PADGV(ppad[ix]) || IS_PADCONST(ppad[ix])) { - sv = SvREFCNT_inc(ppad[ix]); + sv = SvREFCNT_inc_NN(ppad[ix]); } else { - sv = NEWSV(0, 0); + sv = newSV(0); SvPADTMP_on(sv); } PL_curpad[ix] = sv; @@ -1503,10 +1540,10 @@ Perl_cv_clone(pTHX_ CV *proto) * so try to grab the current const value, and if successful, * turn into a const sub: */ - SV* const_sv = op_const_sv(CvSTART(cv), cv); + SV* const const_sv = op_const_sv(CvSTART(cv), cv); if (const_sv) { SvREFCNT_dec(cv); - cv = newCONSTSUB(CvSTASH(proto), Nullch, const_sv); + cv = newCONSTSUB(CvSTASH(proto), NULL, const_sv); } else { CvCONST_off(cv); @@ -1530,13 +1567,16 @@ moved to a pre-existing CV struct. void Perl_pad_fixup_inner_anons(pTHX_ PADLIST *padlist, CV *old_cv, CV *new_cv) { + dVAR; I32 ix; AV * const comppad_name = (AV*)AvARRAY(padlist)[0]; AV * const comppad = (AV*)AvARRAY(padlist)[1]; SV ** const namepad = AvARRAY(comppad_name); SV ** const curpad = AvARRAY(comppad); + PERL_UNUSED_ARG(old_cv); + for (ix = AvFILLp(comppad_name); ix > 0; ix--) { - const SV *namesv = namepad[ix]; + const SV * const namesv = namepad[ix]; if (namesv && namesv != &PL_sv_undef && *SvPVX_const(namesv) == '&') { @@ -1562,16 +1602,14 @@ the new pad an @_ in slot zero. void Perl_pad_push(pTHX_ PADLIST *padlist, int depth) { - if (depth <= AvFILLp(padlist)) - return; - - { - SV** svp = AvARRAY(padlist); - AV *newpad = newAV(); - SV **oldpad = AvARRAY(svp[depth-1]); + dVAR; + if (depth > AvFILLp(padlist)) { + SV** const svp = AvARRAY(padlist); + AV* const newpad = newAV(); + SV** const oldpad = AvARRAY(svp[depth-1]); I32 ix = AvFILLp((AV*)svp[1]); const I32 names_fill = AvFILLp((AV*)svp[0]); - SV** names = AvARRAY(svp[0]); + SV** const names = AvARRAY(svp[0]); AV *av; for ( ;ix > 0; ix--) { @@ -1588,17 +1626,17 @@ Perl_pad_push(pTHX_ PADLIST *padlist, int depth) else if (sigil == '%') sv = (SV*)newHV(); else - sv = NEWSV(0, 0); + sv = newSV(0); av_store(newpad, ix, sv); SvPADMY_on(sv); } } else if (IS_PADGV(oldpad[ix]) || IS_PADCONST(oldpad[ix])) { - av_store(newpad, ix, SvREFCNT_inc(oldpad[ix])); + av_store(newpad, ix, SvREFCNT_inc_NN(oldpad[ix])); } else { /* save temporaries on recursion? */ - SV *sv = NEWSV(0, 0); + SV * const sv = newSV(0); av_store(newpad, ix, sv); SvPADTMP_on(sv); } @@ -1617,11 +1655,12 @@ Perl_pad_push(pTHX_ PADLIST *padlist, int depth) HV * Perl_pad_compname_type(pTHX_ const PADOFFSET po) { - SV** const av = av_fetch(PL_comppad_name, po, FALSE); - if ( SvFLAGS(*av) & SVpad_TYPED ) { + dVAR; + SV* const * const av = av_fetch(PL_comppad_name, po, FALSE); + if ( SvPAD_TYPED(*av) ) { return SvSTASH(*av); } - return Nullhv; + return NULL; } /*