STATIC HE*
S_new_he(pTHX)
{
dVAR;
HE* he;
void ** const root = &PL_body_roots[HE_SVSLOT];
if (!*root)
S_more_he(aTHX);
he = (HE*) *root;
assert(he);
*root = HeNEXT(he);
return he;
}
/*
* similar to hv_fetch_ent, but takes string key and key len rather than SV
* also skips magic and utf8 fu, since we are only dealing with internal tables
*/
HE *modperl_perl_hv_fetch_he(pTHX_ HV *hv,
register char *key,
register I32 klen,
register U32 hash)
{
register XPVHV *xhv;
register HE *entry;
xhv = (XPVHV *)SvANY(hv);
if (!HvARRAY(hv)) {
return 0;
}
#ifdef HvREHASH
if (HvREHASH(hv)) {
PERL_HASH_INTERNAL(hash, key, klen);
}
else
#endif
if (!hash) {
PERL_HASH(hash, key, klen);
}
entry = ((HE**)HvARRAY(hv))[hash & (I32)xhv->xhv_max];
for (; entry; entry = HeNEXT(entry)) {
if (HeHASH(entry) != hash) {
continue;
}
if (HeKLEN(entry) != klen) {
continue;
}
if (HeKEY(entry) != key && memNE(HeKEY(entry), key, klen)) {
continue;
}
return entry;
}
return 0;
}
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
);
}
}
}
}
}
}
