}
LEAVE;
- PL_sub_generation++;
+ mro_method_changed_in(GvSTASH(gv)); /* sub Foo::bar($) { (shift) } sub ASDF::baz($); *ASDF::baz = \&Foo::bar */
CvGV(GvCV(gv)) = gv;
CvFILE_set_from_cop(GvCV(gv), PL_curcop);
CvSTASH(GvCV(gv)) = PL_curstash;
The argument C<level> should be either 0 or -1. If C<level==0>, as a
side-effect creates a glob with the given C<name> in the given C<stash>
which in the case of success contains an alias for the subroutine, and sets
-up caching info for this glob. Similarly for all the searched stashes.
+up caching info for this glob.
This function grants C<"SUPER"> token as a postfix of the stash name. The
GV returned from C<gv_fetchmeth> may be a method cache entry, which is not
=cut
*/
+/* NOTE: No support for tied ISA */
+
GV *
Perl_gv_fetchmeth(pTHX_ HV *stash, const char *name, STRLEN len, I32 level)
{
dVAR;
- AV* av;
- GV* topgv;
- GV* gv;
GV** gvp;
- CV* cv;
+ AV* linear_av;
+ SV** linear_svp;
+ SV* linear_sv;
+ HV* cstash;
+ GV* candidate = NULL;
+ CV* cand_cv = NULL;
+ CV* old_cv;
+ GV* topgv = NULL;
const char *hvname;
- HV* lastchance = NULL;
+ I32 create = (level >= 0) ? 1 : 0;
+ I32 items;
+ STRLEN packlen;
+ U32 topgen_cmp;
/* UNIVERSAL methods should be callable without a stash */
if (!stash) {
- level = -1; /* probably appropriate */
+ create = 0; /* probably appropriate */
if(!(stash = gv_stashpvs("UNIVERSAL", 0)))
return 0;
}
+ assert(stash);
+
hvname = HvNAME_get(stash);
if (!hvname)
- Perl_croak(aTHX_
- "Can't use anonymous symbol table for method lookup");
+ Perl_croak(aTHX_ "Can't use anonymous symbol table for method lookup");
- if ((level > 100) || (level < -100))
- Perl_croak(aTHX_ "Recursive inheritance detected while looking for method '%s' in package '%s'",
- name, hvname);
+ assert(hvname);
+ assert(name);
DEBUG_o( Perl_deb(aTHX_ "Looking for method %s in package %s\n",name,hvname) );
- gvp = (GV**)hv_fetch(stash, name, len, (level >= 0));
- if (!gvp)
- topgv = NULL;
- else {
- topgv = *gvp;
- if (SvTYPE(topgv) != SVt_PVGV)
- gv_init(topgv, stash, name, len, TRUE);
- if ((cv = GvCV(topgv))) {
- /* If genuine method or valid cache entry, use it */
- if (!GvCVGEN(topgv) || GvCVGEN(topgv) == PL_sub_generation)
- return topgv;
- /* Stale cached entry: junk it */
- SvREFCNT_dec(cv);
- GvCV(topgv) = cv = NULL;
- GvCVGEN(topgv) = 0;
- }
- else if (GvCVGEN(topgv) == PL_sub_generation)
- return 0; /* cache indicates sub doesn't exist */
+ topgen_cmp = HvMROMETA(stash)->cache_gen + PL_sub_generation;
+
+ /* check locally for a real method or a cache entry */
+ gvp = (GV**)hv_fetch(stash, name, len, create);
+ if(gvp) {
+ topgv = *gvp;
+ assert(topgv);
+ if (SvTYPE(topgv) != SVt_PVGV)
+ gv_init(topgv, stash, name, len, TRUE);
+ if ((cand_cv = GvCV(topgv))) {
+ /* If genuine method or valid cache entry, use it */
+ if (!GvCVGEN(topgv) || GvCVGEN(topgv) == topgen_cmp) {
+ return topgv;
+ }
+ else {
+ /* stale cache entry, junk it and move on */
+ SvREFCNT_dec(cand_cv);
+ GvCV(topgv) = cand_cv = NULL;
+ GvCVGEN(topgv) = 0;
+ }
+ }
+ else if (GvCVGEN(topgv) == topgen_cmp) {
+ /* cache indicates no such method definitively */
+ return 0;
+ }
}
- gvp = (GV**)hv_fetchs(stash, "ISA", FALSE);
- av = (gvp && (gv = *gvp) && isGV_with_GP(gv)) ? GvAV(gv) : NULL;
-
- /* create and re-create @.*::SUPER::ISA on demand */
- if (!av || !SvMAGIC(av)) {
- STRLEN packlen = HvNAMELEN_get(stash);
-
- if (packlen >= 7 && strEQ(hvname + packlen - 7, "::SUPER")) {
- HV* basestash;
-
- packlen -= 7;
- basestash = gv_stashpvn(hvname, packlen, GV_ADD);
- gvp = (GV**)hv_fetchs(basestash, "ISA", FALSE);
- if (gvp && (gv = *gvp) && isGV_with_GP(gv) && (av = GvAV(gv))) {
- gvp = (GV**)hv_fetchs(stash, "ISA", TRUE);
- if (!gvp || !(gv = *gvp))
- Perl_croak(aTHX_ "Cannot create %s::ISA", hvname);
- if (SvTYPE(gv) != SVt_PVGV)
- gv_init(gv, stash, "ISA", 3, TRUE);
- SvREFCNT_dec(GvAV(gv));
- GvAV(gv) = (AV*)SvREFCNT_inc_simple(av);
- }
- }
+ packlen = HvNAMELEN_get(stash);
+ if (packlen >= 7 && strEQ(hvname + packlen - 7, "::SUPER")) {
+ HV* basestash;
+ packlen -= 7;
+ basestash = gv_stashpvn(hvname, packlen, GV_ADD);
+ linear_av = mro_get_linear_isa(basestash);
}
-
- if (av) {
- SV** svp = AvARRAY(av);
- /* NOTE: No support for tied ISA */
- I32 items = AvFILLp(av) + 1;
- while (items--) {
- SV* const sv = *svp++;
- HV* const basestash = gv_stashsv(sv, 0);
- if (!basestash) {
- if (ckWARN(WARN_MISC))
- Perl_warner(aTHX_ packWARN(WARN_MISC), "Can't locate package %"SVf" for @%s::ISA",
- SVfARG(sv), hvname);
- continue;
- }
- gv = gv_fetchmeth(basestash, name, len,
- (level >= 0) ? level + 1 : level - 1);
- if (gv)
- goto gotcha;
- }
+ else {
+ linear_av = mro_get_linear_isa(stash); /* has ourselves at the top of the list */
}
- /* if at top level, try UNIVERSAL */
+ linear_svp = AvARRAY(linear_av) + 1; /* skip over self */
+ items = AvFILLp(linear_av); /* no +1, to skip over self */
+ while (items--) {
+ linear_sv = *linear_svp++;
+ assert(linear_sv);
+ cstash = gv_stashsv(linear_sv, 0);
+
+ if (!cstash) {
+ if (ckWARN(WARN_SYNTAX))
+ Perl_warner(aTHX_ packWARN(WARN_SYNTAX), "Can't locate package %"SVf" for @%s::ISA",
+ SVfARG(linear_sv), hvname);
+ continue;
+ }
- if (level == 0 || level == -1) {
- lastchance = gv_stashpvs("UNIVERSAL", 0);
+ assert(cstash);
+
+ gvp = (GV**)hv_fetch(cstash, name, len, 0);
+ if (!gvp) continue;
+ candidate = *gvp;
+ assert(candidate);
+ if (SvTYPE(candidate) != SVt_PVGV) gv_init(candidate, cstash, name, len, TRUE);
+ if (SvTYPE(candidate) == SVt_PVGV && (cand_cv = GvCV(candidate)) && !GvCVGEN(candidate)) {
+ /*
+ * Found real method, cache method in topgv if:
+ * 1. topgv has no synonyms (else inheritance crosses wires)
+ * 2. method isn't a stub (else AUTOLOAD fails spectacularly)
+ */
+ if (topgv && (GvREFCNT(topgv) == 1) && (CvROOT(cand_cv) || CvXSUB(cand_cv))) {
+ if ((old_cv = GvCV(topgv))) SvREFCNT_dec(old_cv);
+ SvREFCNT_inc_simple_void_NN(cand_cv);
+ GvCV(topgv) = cand_cv;
+ GvCVGEN(topgv) = topgen_cmp;
+ }
+ return candidate;
+ }
+ }
- if (lastchance) {
- if ((gv = gv_fetchmeth(lastchance, name, len,
- (level >= 0) ? level + 1 : level - 1)))
- {
- gotcha:
- /*
- * Cache method in topgv if:
- * 1. topgv has no synonyms (else inheritance crosses wires)
- * 2. method isn't a stub (else AUTOLOAD fails spectacularly)
- */
- if (topgv &&
- GvREFCNT(topgv) == 1 &&
- (cv = GvCV(gv)) &&
- (CvROOT(cv) || CvXSUB(cv)))
- {
- if ((cv = GvCV(topgv)))
- SvREFCNT_dec(cv);
- GvCV(topgv) = (CV*)SvREFCNT_inc(GvCV(gv));
- GvCVGEN(topgv) = PL_sub_generation;
- }
- return gv;
- }
- else if (topgv && GvREFCNT(topgv) == 1) {
- /* cache the fact that the method is not defined */
- GvCVGEN(topgv) = PL_sub_generation;
- }
- }
+ /* Check UNIVERSAL without caching */
+ if(level == 0 || level == -1) {
+ candidate = gv_fetchmeth(NULL, name, len, 1);
+ if(candidate) {
+ cand_cv = GvCV(candidate);
+ if (topgv && (GvREFCNT(topgv) == 1) && (CvROOT(cand_cv) || CvXSUB(cand_cv))) {
+ if ((old_cv = GvCV(topgv))) SvREFCNT_dec(old_cv);
+ SvREFCNT_inc_simple_void_NN(cand_cv);
+ GvCV(topgv) = cand_cv;
+ GvCVGEN(topgv) = topgen_cmp;
+ }
+ return candidate;
+ }
+ }
+
+ if (topgv && GvREFCNT(topgv) == 1) {
+ /* cache the fact that the method is not defined */
+ GvCVGEN(topgv) = topgen_cmp;
}
return 0;
=cut
*/
+STATIC HV*
+S_gv_get_super_pkg(pTHX_ const char* name, I32 namelen)
+{
+ AV* superisa;
+ GV** gvp;
+ GV* gv;
+ HV* stash;
+
+ stash = gv_stashpvn(name, namelen, 0);
+ if(stash) return stash;
+
+ /* If we must create it, give it an @ISA array containing
+ the real package this SUPER is for, so that it's tied
+ into the cache invalidation code correctly */
+ stash = gv_stashpvn(name, namelen, GV_ADD);
+ gvp = (GV**)hv_fetchs(stash, "ISA", TRUE);
+ gv = *gvp;
+ gv_init(gv, stash, "ISA", 3, TRUE);
+ superisa = GvAVn(gv);
+ GvMULTI_on(gv);
+ sv_magic((SV*)superisa, (SV*)gv, PERL_MAGIC_isa, NULL, 0);
+ av_push(superisa, newSVpv(CopSTASHPV(PL_curcop), 0));
+
+ return stash;
+}
+
GV *
Perl_gv_fetchmethod_autoload(pTHX_ HV *stash, const char *name, I32 autoload)
{
SV * const tmpstr = sv_2mortal(Perl_newSVpvf(aTHX_ "%s::SUPER",
CopSTASHPV(PL_curcop)));
/* __PACKAGE__::SUPER stash should be autovivified */
- stash = gv_stashpvn(SvPVX_const(tmpstr), SvCUR(tmpstr), GV_ADD);
+ stash = gv_get_super_pkg(SvPVX_const(tmpstr), SvCUR(tmpstr));
DEBUG_o( Perl_deb(aTHX_ "Treating %s as %s::%s\n",
origname, HvNAME_get(stash), name) );
}
if (!stash && (nsplit - origname) >= 7 &&
strnEQ(nsplit - 7, "::SUPER", 7) &&
gv_stashpvn(origname, nsplit - origname - 7, 0))
- stash = gv_stashpvn(origname, nsplit - origname, GV_ADD);
+ stash = gv_get_super_pkg(origname, nsplit - origname);
}
ostash = stash;
}
if (*name == '!')
require_tie_mod(gv, "!", newSVpvs("Errno"), "TIEHASH", 1);
else if (*name == '-' || *name == '+')
- require_tie_mod(gv, name, newSVpvs("Tie::Hash::NamedCapture"), "FETCH", 0);
+ require_tie_mod(gv, name, newSVpvs("Tie::Hash::NamedCapture"), "TIEHASH", 0);
}
}
return gv;
break;
case '\015': /* $^MATCH */
if (strEQ(name2, "ATCH"))
- goto ro_magicalize;
+ goto magicalize;
case '\017': /* $^OPEN */
if (strEQ(name2, "PEN"))
goto magicalize;
break;
case '\020': /* $^PREMATCH $^POSTMATCH */
if (strEQ(name2, "REMATCH") || strEQ(name2, "OSTMATCH"))
- goto ro_magicalize;
+ goto magicalize;
case '\024': /* ${^TAINT} */
if (strEQ(name2, "AINT"))
goto ro_magicalize;
case '8':
case '9':
{
- /* ensures variable is only digits */
- /* ${"1foo"} fails this test (and is thus writeable) */
- /* added by japhy, but borrowed from is_gv_magical */
+ /* Ensures that we have an all-digit variable, ${"1foo"} fails
+ this test */
+ /* This snippet is taken from is_gv_magical */
const char *end = name + len;
while (--end > name) {
- if (!isDIGIT(*end)) return gv;
+ if (!isDIGIT(*end)) return gv;
}
- goto ro_magicalize;
+ goto magicalize;
}
}
}
sv_type == SVt_PVIO
) { break; }
PL_sawampersand = TRUE;
- goto ro_magicalize;
+ goto magicalize;
case ':':
sv_setpv(GvSVn(gv),PL_chopset);
SvREADONLY_on(av);
if (sv_type == SVt_PVHV || sv_type == SVt_PVGV)
- require_tie_mod(gv, name, newSVpvs("Tie::Hash::NamedCapture"), "FETCH", 0);
+ require_tie_mod(gv, name, newSVpvs("Tie::Hash::NamedCapture"), "TIEHASH", 0);
break;
}
case '*':
case '#':
- if (sv_type == SVt_PV && ckWARN2(WARN_DEPRECATED, WARN_SYNTAX))
+ if (sv_type == SVt_PV && ckWARN2_d(WARN_DEPRECATED, WARN_SYNTAX))
Perl_warner(aTHX_ packWARN2(WARN_DEPRECATED, WARN_SYNTAX),
"$%c is no longer supported", *name);
break;
}
goto magicalize;
case '\023': /* $^S */
+ ro_magicalize:
+ SvREADONLY_on(GvSVn(gv));
+ /* FALL THROUGH */
case '1':
case '2':
case '3':
case '7':
case '8':
case '9':
- ro_magicalize:
- SvREADONLY_on(GvSVn(gv));
- /* FALL THROUGH */
case '[':
case '^':
case '~':
if (SvTYPE(gv) != SVt_PVGV || GvMULTI(gv))
continue;
file = GvFILE(gv);
- /* performance hack: if filename is absolute and it's a standard
- * module, don't bother warning */
-#ifdef MACOS_TRADITIONAL
-# define LIB_COMPONENT ":lib:"
-#else
-# define LIB_COMPONENT "/lib/"
-#endif
- if (file
- && PERL_FILE_IS_ABSOLUTE(file)
- && (instr(file, LIB_COMPONENT) || instr(file, ".pm")))
- {
- continue;
- }
CopLINE_set(PL_curcop, GvLINE(gv));
#ifdef USE_ITHREADS
CopFILE(PL_curcop) = (char *)file; /* set for warning */
gp->gp_refcnt++;
if (gp->gp_cv) {
if (gp->gp_cvgen) {
- /* multi-named GPs cannot be used for method cache */
+ /* If the GP they asked for a reference to contains
+ a method cache entry, clear it first, so that we
+ don't infect them with our cached entry */
SvREFCNT_dec(gp->gp_cv);
gp->gp_cv = NULL;
gp->gp_cvgen = 0;
}
- else {
- /* Adding a new name to a subroutine invalidates method cache */
- PL_sub_generation++;
- }
}
return gp;
}
pTHX__FORMAT pTHX__VALUE);
return;
}
- if (gp->gp_cv) {
- /* Deleting the name of a subroutine invalidates method cache */
- PL_sub_generation++;
- }
if (--gp->gp_refcnt > 0) {
if (gp->gp_egv == gv)
gp->gp_egv = 0;
if (gp->gp_hv && SvTYPE(gp->gp_hv) == SVt_PVHV) {
const char *hvname = HvNAME_get(gp->gp_hv);
if (PL_stashcache && hvname)
- hv_delete(PL_stashcache, hvname, HvNAMELEN_get(gp->gp_hv),
+ (void)hv_delete(PL_stashcache, hvname, HvNAMELEN_get(gp->gp_hv),
G_DISCARD);
SvREFCNT_dec(gp->gp_hv);
}
dVAR;
MAGIC* const mg = mg_find((SV*)stash, PERL_MAGIC_overload_table);
AMT amt;
+ const struct mro_meta* stash_meta = HvMROMETA(stash);
+ U32 newgen;
+ newgen = PL_sub_generation + stash_meta->pkg_gen + stash_meta->cache_gen;
if (mg) {
const AMT * const amtp = (AMT*)mg->mg_ptr;
if (amtp->was_ok_am == PL_amagic_generation
- && amtp->was_ok_sub == PL_sub_generation) {
+ && amtp->was_ok_sub == newgen) {
return (bool)AMT_OVERLOADED(amtp);
}
sv_unmagic((SV*)stash, PERL_MAGIC_overload_table);
Zero(&amt,1,AMT);
amt.was_ok_am = PL_amagic_generation;
- amt.was_ok_sub = PL_sub_generation;
+ amt.was_ok_sub = newgen;
amt.fallback = AMGfallNO;
amt.flags = 0;
dVAR;
MAGIC *mg;
AMT *amtp;
+ U32 newgen;
+ struct mro_meta* stash_meta;
if (!stash || !HvNAME_get(stash))
return NULL;
+
+ stash_meta = HvMROMETA(stash);
+ newgen = PL_sub_generation + stash_meta->pkg_gen + stash_meta->cache_gen;
+
mg = mg_find((SV*)stash, PERL_MAGIC_overload_table);
if (!mg) {
do_update:
assert(mg);
amtp = (AMT*)mg->mg_ptr;
if ( amtp->was_ok_am != PL_amagic_generation
- || amtp->was_ok_sub != PL_sub_generation )
+ || amtp->was_ok_sub != newgen )
goto do_update;
if (AMT_AMAGIC(amtp)) {
CV * const ret = amtp->table[id];
https://perl5.git.perl.org / perl5.git / blobdiff