assert(HvAUX(stash));
stashhek
- = HvAUX(stash)->xhv_name && HvENAME_HEK_NN(stash)
+ = HvAUX(stash)->xhv_name_u.xhvnameu_name && HvENAME_HEK_NN(stash)
? HvENAME_HEK_NN(stash)
: HvNAME_HEK(stash);
when the @ISA of the given package has changed. Invoked
by the C<setisa> magic, should not need to invoke directly.
-=for apidoc mro_isa_changed_in3
-
-Takes the necessary steps (cache invalidations, mostly)
-when the @ISA of the given package has changed. Invoked
-by the C<setisa> magic, should not need to invoke directly.
-
-The stash can be passed as the first argument, or its name and length as
-the second and third (or both). If just the name is passed and the stash
-does not exist, then only the subclasses' method and isa caches will be
-invalidated.
-
=cut
*/
+
+/* Macro to avoid repeating the code five times. */
+#define CLEAR_LINEAR(mEta) \
+ if (mEta->mro_linear_all) { \
+ SvREFCNT_dec(MUTABLE_SV(mEta->mro_linear_all)); \
+ mEta->mro_linear_all = NULL; \
+ /* This is just acting as a shortcut pointer. */ \
+ mEta->mro_linear_current = NULL; \
+ } else if (mEta->mro_linear_current) { \
+ /* Only the current MRO is stored, so this owns the data. */ \
+ SvREFCNT_dec(mEta->mro_linear_current); \
+ mEta->mro_linear_current = NULL; \
+ }
+
void
-Perl_mro_isa_changed_in3(pTHX_ HV* stash, const char *stashname,
- STRLEN stashname_len)
+Perl_mro_isa_changed_in(pTHX_ HV* stash)
{
dVAR;
HV* isarev;
SV** svp;
I32 items;
bool is_universal;
- struct mro_meta * meta = NULL;
+ struct mro_meta * meta;
HV *isa = NULL;
- if(!stashname && stash) {
- stashname = HvENAME_get(stash);
- stashname_len = HvENAMELEN_get(stash);
- }
- else if(!stash)
- stash = gv_stashpvn(stashname, stashname_len, 0 /* don't add */);
+ const char * const stashname = HvENAME_get(stash);
+ const STRLEN stashname_len = HvENAMELEN_get(stash);
+
+ PERL_ARGS_ASSERT_MRO_ISA_CHANGED_IN;
if(!stashname)
Perl_croak(aTHX_ "Can't call mro_isa_changed_in() on anonymous symbol table");
- if(stash) {
- /* wipe out the cached linearizations for this stash */
- meta = HvMROMETA(stash);
- if (meta->mro_linear_all) {
- SvREFCNT_dec(MUTABLE_SV(meta->mro_linear_all));
- meta->mro_linear_all = NULL;
- /* This is just acting as a shortcut pointer. */
- meta->mro_linear_current = NULL;
- } else if (meta->mro_linear_current) {
- /* Only the current MRO is stored, so this owns the data. */
- SvREFCNT_dec(meta->mro_linear_current);
- meta->mro_linear_current = NULL;
- }
- if (meta->isa) {
+
+ /* wipe out the cached linearizations for this stash */
+ meta = HvMROMETA(stash);
+ CLEAR_LINEAR(meta);
+ if (meta->isa) {
/* Steal it for our own purposes. */
isa = (HV *)sv_2mortal((SV *)meta->isa);
meta->isa = NULL;
- }
-
- /* Inc the package generation, since our @ISA changed */
- meta->pkg_gen++;
}
+ /* Inc the package generation, since our @ISA changed */
+ meta->pkg_gen++;
+
/* Wipe the global method cache if this package
is UNIVERSAL or one of its parents */
is_universal = TRUE;
}
else { /* Wipe the local method cache otherwise */
- if(meta) meta->cache_gen++;
+ meta->cache_gen++;
is_universal = FALSE;
}
/* wipe next::method cache too */
- if(meta && meta->mro_nextmethod) hv_clear(meta->mro_nextmethod);
+ if(meta->mro_nextmethod) hv_clear(meta->mro_nextmethod);
/* Iterate the isarev (classes that are our children),
wiping out their linearization, method and isa caches
if(!revstash) continue;
revmeta = HvMROMETA(revstash);
- if (revmeta->mro_linear_all) {
- SvREFCNT_dec(MUTABLE_SV(revmeta->mro_linear_all));
- revmeta->mro_linear_all = NULL;
- /* This is just acting as a shortcut pointer. */
- revmeta->mro_linear_current = NULL;
- } else if (revmeta->mro_linear_current) {
- /* Only the current MRO is stored, so this owns the data. */
- SvREFCNT_dec(revmeta->mro_linear_current);
- revmeta->mro_linear_current = NULL;
- }
+ CLEAR_LINEAR(revmeta);
if(!is_universal)
revmeta->cache_gen++;
if(revmeta->mro_nextmethod)
HV * const isa = (HV *)HeVAL(iter);
const HEK *namehek;
- /* Re-calculate the linearisation, unless a previous iter-
- ation was for a subclass of this class. */
- if(!HvMROMETA(revstash)->isa)
- (void)mro_get_linear_isa(revstash);
-
/* We're starting at the 2nd element, skipping revstash */
linear_mro = mro_get_linear_isa(revstash);
svp = AvARRAY(linear_mro) + 1;
}
}
- /* Now iterate our MRO (parents), and:
- 1) Add ourselves and everything from our isarev to their isarev
- 2) Delete the parent’s entry from the (now temporary) isa hash
+ /* Now iterate our MRO (parents), adding ourselves and everything from
+ our isarev to their isarev.
*/
- /* This only applies if the stash exists. */
- if(!stash) goto clean_up_isarev;
-
/* We're starting at the 2nd element, skipping ourselves here */
linear_mro = mro_get_linear_isa(stash);
svp = AvARRAY(linear_mro) + 1;
(void)hv_store(mroisarev, stashname, stashname_len, &PL_sv_yes, 0);
}
- clean_up_isarev:
/* Delete our name from our former parents’ isarevs. */
if(isa && HvARRAY(isa))
mro_clean_isarev(isa, stashname, stashname_len, meta->isa);
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. C<newname> and C<newname_len> are the
-full name of the GV. If these last two arguments are omitted, they can be
-inferred from C<gv>. C<gv> can be omitted if C<newname> is given.
+that is actually being assigned to.
This can also be called with a null first argument to
indicate that C<oldstash> has been deleted.
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 *gv, const char *newname,
- I32 newname_len)
+ 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);
- assert(gv || newname);
- /* Determine the name of the location that stash was assigned to
+ /* 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
* *$globref = *frelp::;
* # calls mro_package_moved(%frelp::, %baz::, *$globref, NULL, 0)
*
- * If newname is not null, then we trust that the caller gave us the
- * right name. Otherwise, we get it from the gv. But if the gv is not
- * in the symbol table, then we just return.
+ * 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(!newname && gv) {
- SV * const namesv = sv_newmortal();
- STRLEN len;
- gv_fullname4(namesv, gv, NULL, 0);
- if(gv_fetchsv(namesv, GV_NOADD_NOINIT, SVt_PVGV) != gv) return;
- newname = SvPV_const(namesv, len);
- newname_len = len - 2; /* skip trailing :: */
+ if(!(flags & 1)) {
+ SV **svp;
+ if(
+ !GvSTASH(gv) || !HvENAME(GvSTASH(gv)) ||
+ !(svp = hv_fetch(GvSTASH(gv), GvNAME(gv), GvNAMELEN(gv), 0)) ||
+ *svp != (SV *)gv
+ ) return;
+ }
+ assert(SvOOK(GvSTASH(gv)));
+ assert(GvNAMELEN(gv) > 1);
+ assert(GvNAME(gv)[GvNAMELEN(gv) - 1] == ':');
+ assert(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 = newSVpvs_flags("", SVs_TEMP);
+ }
+ else {
+ namesv = sv_2mortal(newSVhek(*namep));
+ sv_catpvs(namesv, "::");
+ }
+ sv_catpvn(namesv, GvNAME(gv), GvNAMELEN(gv) - 2);
+ /* skip trailing :: */
+ }
+ else {
+ SV *aname;
+ namesv = sv_2mortal((SV *)newAV());
+ while (name_count--) {
+ if(HEK_LEN(*namep) == 4 && strnEQ(HEK_KEY(*namep), "main", 4)){
+ aname = newSVpvs(""); namep++;
+ }
+ else {
+ aname = newSVhek(*namep++);
+ sv_catpvs(aname, "::");
+ }
+ sv_catpvn(aname, GvNAME(gv), GvNAMELEN(gv) - 2);
+ /* skip trailing :: */
+ av_push((AV *)namesv, aname);
+ }
}
- if(newname_len < 0) newname_len = -newname_len;
/* Get a list of all the affected classes. */
/* We cannot simply pass them all to mro_isa_changed_in to avoid
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.
+ we do anything else. (And linearisations must be cleared, too.)
*/
stashes = (HV *) sv_2mortal((SV *)newHV());
- mro_gather_and_rename(stashes, stash, oldstash, newname, newname_len);
-
- /* Iterate through the stashes, wiping isa linearisations, but leaving
- the isa hash (which mro_isa_changed_in needs for adjusting the
- isarev hashes belonging to parent classes). */
- hv_iterinit(stashes);
- while((iter = hv_iternext(stashes))) {
- if(HeVAL(iter) != &PL_sv_yes && HvENAME(HeVAL(iter))) {
- struct mro_meta* meta;
- meta = HvMROMETA((HV *)HeVAL(iter));
- if (meta->mro_linear_all) {
- SvREFCNT_dec(MUTABLE_SV(meta->mro_linear_all));
- meta->mro_linear_all = NULL;
- /* This is just acting as a shortcut pointer. */
- meta->mro_linear_current = NULL;
- } else if (meta->mro_linear_current) {
- /* Only the current MRO is stored, so this owns the data. */
- SvREFCNT_dec(meta->mro_linear_current);
- meta->mro_linear_current = NULL;
- }
- }
- }
+ 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))) {
- if(HeVAL(iter) != &PL_sv_yes && HvENAME(HeVAL(iter)))
- mro_isa_changed_in((HV *)HeVAL(iter));
- /* We are not holding a refcount, so eliminate the pointer before
- * stashes is freed. */
- HeVAL(iter) = NULL;
+ 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
+ will have been overwritten without old entries being deleted
+ 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);
+ }
}
}
void
-S_mro_gather_and_rename(pTHX_ HV * const stashes, HV *stash, HV *oldstash,
- const char *name, I32 namlen)
+S_mro_gather_and_rename(pTHX_ HV * const stashes, HV * const seen_stashes,
+ HV *stash, HV *oldstash, SV *namesv)
{
register XPVHV* xhv;
register 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;
+ 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(
- stashes, NULL, (const char *)&oldstash, sizeof(HV *), 0,
- HV_FETCH_LVALUE, NULL, 0
+ seen_stashes, NULL, (const char *)&oldstash, sizeof(HV *), 0,
+ HV_FETCH_LVALUE|HV_FETCH_EMPTY_HE, NULL, 0
);
- if(HeVAL(entry) == (SV *)oldstash) {
+ if(HeVAL(entry) == &PL_sv_undef || HeVAL(entry) == &PL_sv_yes) {
oldstash = NULL;
goto check_stash;
}
- HeVAL(entry) = (SV *)oldstash;
+ 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(PL_stashcache)
- (void)
- hv_delete(PL_stashcache, name, namlen, G_DISCARD);
- hv_ename_delete(oldstash, name, namlen);
-
- /* 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
- * from PL_isarev, since we still need it. hv_delete mortifies it
- * for us, so sv_2mortal is not necessary. */
- if(HvENAME_HEK(oldstash) != enamehek) {
- const struct mro_meta * meta = HvMROMETA(oldstash);
- if(meta->isa && HvARRAY(meta->isa))
- mro_clean_isarev(meta->isa, name, namlen, NULL);
- isarev = (HV *)hv_delete(PL_isarev, name, namlen, 0);
- }
+ 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--) {
+ STRLEN len;
+ const char *name = SvPVx_const(*svp++, len);
+ if(PL_stashcache)
+ (void)hv_delete(PL_stashcache, name, len, G_DISCARD);
+ hv_ename_delete(oldstash, name, len, 0);
+
+ 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, NULL);
+ isarev = (HV *)hv_delete(PL_isarev, name, len, 0);
+ fetched_isarev=TRUE;
+ }
+ }
+ }
}
}
check_stash:
if(stash) {
- hv_ename_add(stash, name, namlen);
-
- /* Add it to the big list. We use the stash itself as the value if
- * it needs mro_isa_changed_in called on it. Otherwise we just use
- * &PL_sv_yes to indicate that we have seen it. */
+ if(SvTYPE(namesv) == SVt_PVAV) {
+ items = AvFILLp((AV *)namesv) + 1;
+ svp = AvARRAY((AV *)namesv);
+ }
+ else {
+ items = 1;
+ svp = &namesv;
+ }
+ while (items--) {
+ STRLEN len;
+ const char *name = SvPVx_const(*svp++, len);
+ hv_ename_add(stash, name, len, 0);
+ }
- /* The stash needs mro_isa_changed_in called on it if it was
+ /* 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 linerisation is now stale (the effective name
+ * 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].)
entry
= (HE *)
hv_common(
- stashes, NULL, (const char *)&stash, sizeof(HV *), 0,
- HV_FETCH_LVALUE, NULL, 0
+ 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) == (SV *)stash)
+ if(HeVAL(entry) == &PL_sv_yes || HeVAL(entry) == &PL_sv_no)
stash = NULL;
- else HeVAL(entry) = stash_had_name ? &PL_sv_yes : (SV *)stash;
+ 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)
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 */
+ char * const hvename = HvENAME(oldstash);
+ fetched_isarev = TRUE;
+ svp = hv_fetch(PL_isarev, hvename, HvENAMELEN_get(oldstash), 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
- || (
- (svp = hv_fetch(PL_isarev, name, namlen, 0))
- && (isarev = MUTABLE_HV(*svp))
- )
+ 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))) {
I32 len;
const char* const revkey = hv_iterkey(iter, &len);
HV* revstash = gv_stashpvn(revkey, len, 0);
+ struct mro_meta * meta;
if(!revstash) continue;
- entry
- = (HE *)
- hv_common(
- stashes, NULL, (const char *)&revstash, sizeof(HV *), 0,
- HV_FETCH_LVALUE, NULL, 0
- );
- HeVAL(entry) = (SV *)revstash;
-
+ 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(
- (!stash || !HvARRAY(stash)) && (!oldstash || !HvARRAY(oldstash))
- ) return;
+ 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. */
)
{
/* Add :: and the key (minus the trailing ::)
- to newname. */
- SV *namesv
- = newSVpvn_flags(name, namlen, SVs_TEMP);
- {
- const char *name;
- STRLEN namlen;
- sv_catpvs(namesv, "::");
- sv_catpvn(namesv, key, len-2);
- name = SvPV_const(namesv, namlen);
- mro_gather_and_rename(
- stashes, substash, oldsubstash, name, namlen
- );
+ 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++);
+ sv_catpvs(aname, "::");
+ sv_catpvn(aname, key, len-2);
+ av_push((AV *)subname, aname);
+ }
}
+ else {
+ subname = sv_2mortal(newSVsv(namesv));
+ sv_catpvs(subname, "::");
+ sv_catpvn(subname, key, len-2);
+ }
+ mro_gather_and_rename(
+ stashes, seen_stashes,
+ substash, oldsubstash, subname
+ );
}
(void)hv_store(seen, key, 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, entry, NULL, ...). */
+ calling mro_gather_and_rename(stashes,seen,entry,NULL, ...). */
while (++riter <= (I32)xhv->xhv_max) {
entry = (HvARRAY(stash))[riter];
substash = GvHV(HeVAL(entry));
if(substash) {
- SV *namesv;
- const char *subname;
- STRLEN subnamlen;
+ SV *subname;
/* Avoid checking main::main::main::... */
if(substash == stash) continue;
/* Add :: and the key (minus the trailing ::)
- to newname. */
- namesv
- = newSVpvn_flags(name, namlen, SVs_TEMP);
- sv_catpvs(namesv, "::");
- sv_catpvn(namesv, key, len-2);
- subname = SvPV_const(namesv, subnamlen);
+ 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++);
+ sv_catpvs(aname, "::");
+ sv_catpvn(aname, key, len-2);
+ av_push((AV *)subname, aname);
+ }
+ }
+ else {
+ subname = sv_2mortal(newSVsv(namesv));
+ sv_catpvs(subname, "::");
+ sv_catpvn(subname, key, len-2);
+ }
mro_gather_and_rename(
- stashes, substash, NULL, subname, subnamlen
+ stashes, seen_stashes,
+ substash, NULL, subname
);
}
}