void Perl_sv_catpvn_mg(pTHX_ SV *sv, const char *ptr, STRLEN len) { PERL_ARGS_ASSERT_SV_CATPVN_MG; sv_catpvn_flags(sv,ptr,len,SV_GMAGIC|SV_SMAGIC); }
void Perl_sv_catpvn(pTHX_ SV *dsv, const char* sstr, STRLEN slen) { PERL_ARGS_ASSERT_SV_CATPVN; sv_catpvn_flags(dsv, sstr, slen, SV_GMAGIC); }
void Perl_sv_catpvn(pTHX_ SV *dsv, const char* sstr, STRLEN slen) { sv_catpvn_flags(dsv, sstr, slen, SV_GMAGIC); }
STATIC void S_mro_gather_and_rename(pTHX_ HV * const stashes, HV * const seen_stashes, HV *stash, HV *oldstash, SV *namesv) { XPVHV* xhv; HE *entry; I32 riter = -1; I32 items = 0; const bool stash_had_name = stash && HvENAME(stash); bool fetched_isarev = FALSE; HV *seen = NULL; HV *isarev = NULL; SV **svp = NULL; PERL_ARGS_ASSERT_MRO_GATHER_AND_RENAME; /* We use the seen_stashes hash to keep track of which packages have been encountered so far. This must be separate from the main list of stashes, as we need to distinguish between stashes being assigned and stashes being replaced/deleted. (A nested stash can be on both sides of an assignment. We cannot simply skip iterating through a stash on the right if we have seen it on the left, as it will not get its ename assigned to it.) To avoid allocating extra SVs, instead of a bitfield we can make bizarre use of immortals: &PL_sv_undef: seen on the left (oldstash) &PL_sv_no : seen on the right (stash) &PL_sv_yes : seen on both sides */ if(oldstash) { /* Add to the big list. */ struct mro_meta * meta; HE * const entry = (HE *) hv_common( seen_stashes, NULL, (const char *)&oldstash, sizeof(HV *), 0, HV_FETCH_LVALUE|HV_FETCH_EMPTY_HE, NULL, 0 ); if(HeVAL(entry) == &PL_sv_undef || HeVAL(entry) == &PL_sv_yes) { oldstash = NULL; goto check_stash; } HeVAL(entry) = HeVAL(entry) == &PL_sv_no ? &PL_sv_yes : &PL_sv_undef; meta = HvMROMETA(oldstash); (void) hv_store( stashes, (const char *)&oldstash, sizeof(HV *), meta->isa ? SvREFCNT_inc_simple_NN((SV *)meta->isa) : &PL_sv_yes, 0 ); CLEAR_LINEAR(meta); /* Update the effective name. */ if(HvENAME_get(oldstash)) { const HEK * const enamehek = HvENAME_HEK(oldstash); if(SvTYPE(namesv) == SVt_PVAV) { items = AvFILLp((AV *)namesv) + 1; svp = AvARRAY((AV *)namesv); } else { items = 1; svp = &namesv; } while (items--) { const U32 name_utf8 = SvUTF8(*svp); STRLEN len; const char *name = SvPVx_const(*svp, len); if(PL_stashcache) { DEBUG_o(Perl_deb(aTHX_ "mro_gather_and_rename clearing PL_stashcache for '%"SVf"'\n", SVfARG(*svp))); (void)hv_delete(PL_stashcache, name, name_utf8 ? -(I32)len : (I32)len, G_DISCARD); } ++svp; hv_ename_delete(oldstash, name, len, name_utf8); if (!fetched_isarev) { /* If the name deletion caused a name change, then we * are not going to call mro_isa_changed_in with this * name (and not at all if it has become anonymous) so * we need to delete old isarev entries here, both * those in the superclasses and this class's own list * of subclasses. We simply delete the latter from * PL_isarev, since we still need it. hv_delete morti- * fies it for us, so sv_2mortal is not necessary. */ if(HvENAME_HEK(oldstash) != enamehek) { if(meta->isa && HvARRAY(meta->isa)) mro_clean_isarev(meta->isa, name, len, 0, 0, name_utf8 ? HVhek_UTF8 : 0); isarev = (HV *)hv_delete(PL_isarev, name, name_utf8 ? -(I32)len : (I32)len, 0); fetched_isarev=TRUE; } } } } } check_stash: if(stash) { if(SvTYPE(namesv) == SVt_PVAV) { items = AvFILLp((AV *)namesv) + 1; svp = AvARRAY((AV *)namesv); } else { items = 1; svp = &namesv; } while (items--) { const U32 name_utf8 = SvUTF8(*svp); STRLEN len; const char *name = SvPVx_const(*svp++, len); hv_ename_add(stash, name, len, name_utf8); } /* Add it to the big list if it needs * mro_isa_changed_in called on it. That happens if it was * detached from the symbol table (so it had no HvENAME) before * being assigned to the spot named by the 'name' variable, because * its cached isa linearisation is now stale (the effective name * having changed), and subclasses will then use that cache when * mro_package_moved calls mro_isa_changed_in. (See * [perl #77358].) * * If it did have a name, then its previous name is still * used in isa caches, and there is no need for * mro_package_moved to call mro_isa_changed_in. */ entry = (HE *) hv_common( seen_stashes, NULL, (const char *)&stash, sizeof(HV *), 0, HV_FETCH_LVALUE|HV_FETCH_EMPTY_HE, NULL, 0 ); if(HeVAL(entry) == &PL_sv_yes || HeVAL(entry) == &PL_sv_no) stash = NULL; else { HeVAL(entry) = HeVAL(entry) == &PL_sv_undef ? &PL_sv_yes : &PL_sv_no; if(!stash_had_name) { struct mro_meta * const meta = HvMROMETA(stash); (void) hv_store( stashes, (const char *)&stash, sizeof(HV *), meta->isa ? SvREFCNT_inc_simple_NN((SV *)meta->isa) : &PL_sv_yes, 0 ); CLEAR_LINEAR(meta); } } } if(!stash && !oldstash) /* Both stashes have been encountered already. */ return; /* Add all the subclasses to the big list. */ if(!fetched_isarev) { /* If oldstash is not null, then we can use its HvENAME to look up the isarev hash, since all its subclasses will be listed there. It will always have an HvENAME. It the HvENAME was removed above, then fetch_isarev will be true, and this code will not be reached. If oldstash is null, then this is an empty spot with no stash in it, so subclasses could be listed in isarev hashes belonging to any of the names, so we have to check all of them. */ assert(!oldstash || HvENAME(oldstash)); if (oldstash) { /* Extra variable to avoid a compiler warning */ const HEK * const hvename = HvENAME_HEK(oldstash); fetched_isarev = TRUE; svp = hv_fetchhek(PL_isarev, hvename, 0); if (svp) isarev = MUTABLE_HV(*svp); } else if(SvTYPE(namesv) == SVt_PVAV) { items = AvFILLp((AV *)namesv) + 1; svp = AvARRAY((AV *)namesv); } else { items = 1; svp = &namesv; } } if( isarev || !fetched_isarev ) { while (fetched_isarev || items--) { HE *iter; if (!fetched_isarev) { HE * const he = hv_fetch_ent(PL_isarev, *svp++, 0, 0); if (!he || !(isarev = MUTABLE_HV(HeVAL(he)))) continue; } hv_iterinit(isarev); while((iter = hv_iternext(isarev))) { HV* revstash = gv_stashsv(hv_iterkeysv(iter), 0); struct mro_meta * meta; if(!revstash) continue; meta = HvMROMETA(revstash); (void) hv_store( stashes, (const char *)&revstash, sizeof(HV *), meta->isa ? SvREFCNT_inc_simple_NN((SV *)meta->isa) : &PL_sv_yes, 0 ); CLEAR_LINEAR(meta); } if (fetched_isarev) break; } } /* This is partly based on code in hv_iternext_flags. We are not call- ing that here, as we want to avoid resetting the hash iterator. */ /* Skip the entire loop if the hash is empty. */ if(oldstash && HvUSEDKEYS(oldstash)) { xhv = (XPVHV*)SvANY(oldstash); seen = (HV *) sv_2mortal((SV *)newHV()); /* Iterate through entries in the oldstash, adding them to the list, meanwhile doing the equivalent of $seen{$key} = 1. */ while (++riter <= (I32)xhv->xhv_max) { entry = (HvARRAY(oldstash))[riter]; /* Iterate through the entries in this list */ for(; entry; entry = HeNEXT(entry)) { const char* key; I32 len; /* If this entry is not a glob, ignore it. Try the next. */ if (!isGV(HeVAL(entry))) continue; key = hv_iterkey(entry, &len); if ((len > 1 && key[len-2] == ':' && key[len-1] == ':') || (len == 1 && key[0] == ':')) { HV * const oldsubstash = GvHV(HeVAL(entry)); SV ** const stashentry = stash ? hv_fetch(stash, key, HeUTF8(entry) ? -(I32)len : (I32)len, 0) : NULL; HV *substash = NULL; /* Avoid main::main::main::... */ if(oldsubstash == oldstash) continue; if( ( stashentry && *stashentry && isGV(*stashentry) && (substash = GvHV(*stashentry)) ) || (oldsubstash && HvENAME_get(oldsubstash)) ) { /* Add :: and the key (minus the trailing ::) to each name. */ SV *subname; if(SvTYPE(namesv) == SVt_PVAV) { SV *aname; items = AvFILLp((AV *)namesv) + 1; svp = AvARRAY((AV *)namesv); subname = sv_2mortal((SV *)newAV()); while (items--) { aname = newSVsv(*svp++); if (len == 1) sv_catpvs(aname, ":"); else { sv_catpvs(aname, "::"); sv_catpvn_flags( aname, key, len-2, HeUTF8(entry) ? SV_CATUTF8 : SV_CATBYTES ); } av_push((AV *)subname, aname); } } else { subname = sv_2mortal(newSVsv(namesv)); if (len == 1) sv_catpvs(subname, ":"); else { sv_catpvs(subname, "::"); sv_catpvn_flags( subname, key, len-2, HeUTF8(entry) ? SV_CATUTF8 : SV_CATBYTES ); } } mro_gather_and_rename( stashes, seen_stashes, substash, oldsubstash, subname ); } (void)hv_store(seen, key, HeUTF8(entry) ? -(I32)len : (I32)len, &PL_sv_yes, 0); } } } } /* Skip the entire loop if the hash is empty. */ if (stash && HvUSEDKEYS(stash)) { xhv = (XPVHV*)SvANY(stash); riter = -1; /* Iterate through the new stash, skipping $seen{$key} items, calling mro_gather_and_rename(stashes,seen,entry,NULL, ...). */ while (++riter <= (I32)xhv->xhv_max) { entry = (HvARRAY(stash))[riter]; /* Iterate through the entries in this list */ for(; entry; entry = HeNEXT(entry)) { const char* key; I32 len; /* If this entry is not a glob, ignore it. Try the next. */ if (!isGV(HeVAL(entry))) continue; key = hv_iterkey(entry, &len); if ((len > 1 && key[len-2] == ':' && key[len-1] == ':') || (len == 1 && key[0] == ':')) { HV *substash; /* If this entry was seen when we iterated through the oldstash, skip it. */ if(seen && hv_exists(seen, key, HeUTF8(entry) ? -(I32)len : (I32)len)) continue; /* We get here only if this stash has no corresponding entry in the stash being replaced. */ substash = GvHV(HeVAL(entry)); if(substash) { SV *subname; /* Avoid checking main::main::main::... */ if(substash == stash) continue; /* Add :: and the key (minus the trailing ::) to each name. */ if(SvTYPE(namesv) == SVt_PVAV) { SV *aname; items = AvFILLp((AV *)namesv) + 1; svp = AvARRAY((AV *)namesv); subname = sv_2mortal((SV *)newAV()); while (items--) { aname = newSVsv(*svp++); if (len == 1) sv_catpvs(aname, ":"); else { sv_catpvs(aname, "::"); sv_catpvn_flags( aname, key, len-2, HeUTF8(entry) ? SV_CATUTF8 : SV_CATBYTES ); } av_push((AV *)subname, aname); } } else { subname = sv_2mortal(newSVsv(namesv)); if (len == 1) sv_catpvs(subname, ":"); else { sv_catpvs(subname, "::"); sv_catpvn_flags( subname, key, len-2, HeUTF8(entry) ? SV_CATUTF8 : SV_CATBYTES ); } } mro_gather_and_rename( stashes, seen_stashes, substash, NULL, subname ); } } } } } }
/* =for apidoc mro_package_moved Call this function to signal to a stash that it has been assigned to another spot in the stash hierarchy. C<stash> is the stash that has been assigned. C<oldstash> is the stash it replaces, if any. C<gv> is the glob that is actually being assigned to. This can also be called with a null first argument to indicate that C<oldstash> has been deleted. This function invalidates isa caches on the old stash, on all subpackages nested inside it, and on the subclasses of all those, including non-existent packages that have corresponding entries in C<stash>. It also sets the effective names (C<HvENAME>) on all the stashes as appropriate. If the C<gv> is present and is not in the symbol table, then this function simply returns. This checked will be skipped if C<flags & 1>. =cut */ void Perl_mro_package_moved(pTHX_ HV * const stash, HV * const oldstash, const GV * const gv, U32 flags) { SV *namesv; HEK **namep; I32 name_count; HV *stashes; HE* iter; PERL_ARGS_ASSERT_MRO_PACKAGE_MOVED; assert(stash || oldstash); /* Determine the name(s) of the location that stash was assigned to * or from which oldstash was removed. * * We cannot reliably use the name in oldstash, because it may have * been deleted from the location in the symbol table that its name * suggests, as in this case: * * $globref = \*foo::bar::; * Symbol::delete_package("foo"); * *$globref = \%baz::; * *$globref = *frelp::; * # calls mro_package_moved(%frelp::, %baz::, *$globref, NULL, 0) * * So we get it from the gv. But, since the gv may no longer be in the * symbol table, we check that first. The only reliable way to tell is * to see whether its stash has an effective name and whether the gv * resides in that stash under its name. That effective name may be * different from what gv_fullname4 would use. * If flags & 1, the caller has asked us to skip the check. */ if(!(flags & 1)) { SV **svp; if( !GvSTASH(gv) || !HvENAME(GvSTASH(gv)) || !(svp = hv_fetchhek(GvSTASH(gv), GvNAME_HEK(gv), 0)) || *svp != (SV *)gv ) return; } assert(SvOOK(GvSTASH(gv))); assert(GvNAMELEN(gv)); assert(GvNAME(gv)[GvNAMELEN(gv) - 1] == ':'); assert(GvNAMELEN(gv) == 1 || GvNAME(gv)[GvNAMELEN(gv) - 2] == ':'); name_count = HvAUX(GvSTASH(gv))->xhv_name_count; if (!name_count) { name_count = 1; namep = &HvAUX(GvSTASH(gv))->xhv_name_u.xhvnameu_name; } else { namep = HvAUX(GvSTASH(gv))->xhv_name_u.xhvnameu_names; if (name_count < 0) ++namep, name_count = -name_count - 1; } if (name_count == 1) { if (HEK_LEN(*namep) == 4 && strnEQ(HEK_KEY(*namep), "main", 4)) { namesv = GvNAMELEN(gv) == 1 ? newSVpvs_flags(":", SVs_TEMP) : newSVpvs_flags("", SVs_TEMP); } else { namesv = sv_2mortal(newSVhek(*namep)); if (GvNAMELEN(gv) == 1) sv_catpvs(namesv, ":"); else sv_catpvs(namesv, "::"); } if (GvNAMELEN(gv) != 1) { sv_catpvn_flags( namesv, GvNAME(gv), GvNAMELEN(gv) - 2, /* skip trailing :: */ GvNAMEUTF8(gv) ? SV_CATUTF8 : SV_CATBYTES ); } } else { SV *aname; namesv = sv_2mortal((SV *)newAV()); while (name_count--) { if(HEK_LEN(*namep) == 4 && strnEQ(HEK_KEY(*namep), "main", 4)) { aname = GvNAMELEN(gv) == 1 ? newSVpvs(":") : newSVpvs(""); namep++; } else { aname = newSVhek(*namep++); if (GvNAMELEN(gv) == 1) sv_catpvs(aname, ":"); else sv_catpvs(aname, "::"); } if (GvNAMELEN(gv) != 1) { sv_catpvn_flags( aname, GvNAME(gv), GvNAMELEN(gv) - 2, /* skip trailing :: */ GvNAMEUTF8(gv) ? SV_CATUTF8 : SV_CATBYTES ); } av_push((AV *)namesv, aname); } } /* Get a list of all the affected classes. */ /* We cannot simply pass them all to mro_isa_changed_in to avoid the list, as that function assumes that only one package has changed. It does not work with: @foo::ISA = qw( B B::B ); *B:: = delete $::{"A::"}; as neither B nor B::B can be updated before the other, since they will reset caches on foo, which will see either B or B::B with the wrong name. The names must be set on *all* affected stashes before we do anything else. (And linearisations must be cleared, too.) */ stashes = (HV *) sv_2mortal((SV *)newHV()); mro_gather_and_rename( stashes, (HV *) sv_2mortal((SV *)newHV()), stash, oldstash, namesv ); /* Once the caches have been wiped on all the classes, call mro_isa_changed_in on each. */ hv_iterinit(stashes); while((iter = hv_iternext(stashes))) { HV * const stash = *(HV **)HEK_KEY(HeKEY_hek(iter)); if(HvENAME(stash)) { /* We have to restore the original meta->isa (that mro_gather_and_rename set aside for us) this way, in case one class in this list is a superclass of a another class that we have already encountered. In such a case, meta->isa from PL_isarev. */ struct mro_meta * const meta = HvMROMETA(stash); if(meta->isa != (HV *)HeVAL(iter)) { SvREFCNT_dec(meta->isa); meta->isa = HeVAL(iter) == &PL_sv_yes ? NULL : (HV *)HeVAL(iter); HeVAL(iter) = NULL; /* We donated our reference count. */ } mro_isa_changed_in(stash); } } }