assert(!(HvAUX(stash)->xhv_mro_meta));
Newxz(newmeta, 1, struct mro_meta);
HvAUX(stash)->xhv_mro_meta = newmeta;
- newmeta->sub_generation = 1;
-
- /* Manually flag UNIVERSAL as being universal.
- This happens early in perl booting (when universal.c
- does the newXS calls for UNIVERSAL::*), and infects
- other packages as they are added to UNIVERSAL's MRO
- */
- if(HvNAMELEN_get(stash) == 9
- && strEQ(HEK_KEY(HvAUX(stash)->xhv_name), "UNIVERSAL")) {
- HvMROMETA(stash)->is_universal = 1;
- }
+ newmeta->cache_gen = 1;
return newmeta;
}
if (newmeta->mro_linear_c3)
newmeta->mro_linear_c3
= (AV*) SvREFCNT_inc(sv_dup((SV*)newmeta->mro_linear_c3, param));
- if (newmeta->mro_isarev)
- newmeta->mro_isarev
- = (HV*) SvREFCNT_inc(sv_dup((SV*)newmeta->mro_isarev, param));
if (newmeta->mro_nextmethod)
newmeta->mro_nextmethod
= (HV*) SvREFCNT_inc(sv_dup((SV*)newmeta->mro_nextmethod, param));
GV** gvp;
GV* gv;
AV* av;
- SV** svp;
- I32 items;
- AV* subrv;
- SV** subrv_p;
- I32 subrv_items;
const char* stashname;
struct mro_meta* meta;
the MRO as we go. */
HV* stored = (HV*)sv_2mortal((SV*)newHV());
- svp = AvARRAY(av);
- items = AvFILLp(av) + 1;
+ SV **svp = AvARRAY(av);
+ I32 items = AvFILLp(av) + 1;
/* foreach(@ISA) */
while (items--) {
SV* const sv = *svp++;
HV* const basestash = gv_stashsv(sv, 0);
+ SV *const *subrv_p;
+ I32 subrv_items;
if (!basestash) {
/* if no stash exists for this @ISA member,
simply add it to the MRO and move on */
- if(!hv_exists_ent(stored, sv, 0)) {
- av_push(retval, newSVsv(sv));
- hv_store_ent(stored, sv, &PL_sv_undef, 0);
- }
+ subrv_p = &sv;
+ subrv_items = 1;
}
else {
/* otherwise, recurse into ourselves for the MRO
of this @ISA member, and append their MRO to ours */
- subrv = mro_get_linear_isa_dfs(basestash, level + 1);
- subrv_p = AvARRAY(subrv);
- subrv_items = AvFILLp(subrv) + 1;
- while(subrv_items--) {
- SV* subsv = *subrv_p++;
- if(!hv_exists_ent(stored, subsv, 0)) {
- av_push(retval, newSVsv(subsv));
- hv_store_ent(stored, subsv, &PL_sv_undef, 0);
- }
- }
+ const AV *const subrv
+ = mro_get_linear_isa_dfs(basestash, level + 1);
+
+ subrv_p = AvARRAY(subrv);
+ subrv_items = AvFILLp(subrv) + 1;
+ }
+ while(subrv_items--) {
+ SV *const subsv = *subrv_p++;
+ if(!hv_exists_ent(stored, subsv, 0)) {
+ hv_store_ent(stored, subsv, &PL_sv_undef, 0);
+ av_push(retval, newSVsv(subsv));
+ }
}
}
}
http://search.cpan.org/src/STEVAN/Algorithm-C3-0.01/lib/Algorithm/C3.pm
(later versions go about it differently than this code for speed reasons)
*/
+
if(isa && AvFILLp(isa) >= 0) {
SV** seqs_ptr;
I32 seqs_items;
HV* tails = (HV*)sv_2mortal((SV*)newHV());
AV* seqs = (AV*)sv_2mortal((SV*)newAV());
+ I32* heads;
+
+ /* This builds @seqs, which is an array of arrays.
+ The members of @seqs are the MROs of
+ the members of @ISA, followed by @ISA itself.
+ */
I32 items = AvFILLp(isa) + 1;
SV** isa_ptr = AvARRAY(isa);
while(items--) {
SV* isa_item = *isa_ptr++;
HV* isa_item_stash = gv_stashsv(isa_item, 0);
if(!isa_item_stash) {
- isa_lin = newAV();
+ /* if no stash, make a temporary fake MRO
+ containing just itself */
+ isa_lin = (AV*)sv_2mortal((SV*)newAV());
av_push(isa_lin, newSVsv(isa_item));
}
else {
isa_lin = mro_get_linear_isa_c3(isa_item_stash, level + 1); /* recursion */
}
- av_push(seqs, (SV*)av_make(AvFILLp(isa_lin)+1, AvARRAY(isa_lin)));
+ av_push(seqs, (SV*)isa_lin);
}
- av_push(seqs, (SV*)av_make(AvFILLp(isa)+1, AvARRAY(isa)));
-
+ av_push(seqs, (SV*)isa);
+
+ /* This builds "heads", which as an array of integer array
+ indices, one per seq, which point at the virtual "head"
+ of the seq (initially zero) */
+ Newxz(heads, AvFILLp(seqs)+1, I32);
+
+ /* This builds %tails, which has one key for every class
+ mentioned in the tail of any sequence in @seqs (tail meaning
+ everything after the first class, the "head"). The value
+ is how many times this key appears in the tails of @seqs.
+ */
seqs_ptr = AvARRAY(seqs);
seqs_items = AvFILLp(seqs) + 1;
while(seqs_items--) {
}
}
+ /* This loop won't terminate until we either finish building
+ the MRO, or get an exception. */
while(1) {
SV* seqhead = NULL;
SV* cand = NULL;
SV* val;
HE* tail_entry;
AV* seq;
+ int s;
+
+ /* "foreach $seq (@seqs)" */
SV** avptr = AvARRAY(seqs);
- items = AvFILLp(seqs)+1;
- while(items--) {
+ for(s = 0; s <= AvFILLp(seqs); s++) {
SV** svp;
- seq = (AV*)*avptr++;
- if(AvFILLp(seq) < 0) continue;
- svp = av_fetch(seq, 0, 0);
- seqhead = *svp;
+ seq = (AV*)(avptr[s]);
+ if(!seq) continue; /* skip empty seqs */
+ svp = av_fetch(seq, heads[s], 0);
+ seqhead = *svp; /* seqhead = head of this seq */
if(!winner) {
+ /* if we haven't found a winner for this round yet,
+ and this seqhead is not in tails (or the count
+ for it in tails has dropped to zero), then this
+ seqhead is our new winner, and is added to the
+ final MRO immediately */
cand = seqhead;
if((tail_entry = hv_fetch_ent(tails, cand, 0, 0))
&& (val = HeVAL(tail_entry))
- && (SvIVx(val) > 0))
+ && (SvIVX(val) > 0))
continue;
winner = newSVsv(cand);
av_push(retval, winner);
+ /* note however that even when we find a winner,
+ we continue looping over @seqs to do housekeeping */
}
if(!sv_cmp(seqhead, winner)) {
-
- /* this is basically shift(@seq) in void context */
- SvREFCNT_dec(*AvARRAY(seq));
- *AvARRAY(seq) = &PL_sv_undef;
- AvARRAY(seq) = AvARRAY(seq) + 1;
- AvMAX(seq)--;
- AvFILLp(seq)--;
-
- if(AvFILLp(seq) < 0) continue;
- svp = av_fetch(seq, 0, 0);
- seqhead = *svp;
- tail_entry = hv_fetch_ent(tails, seqhead, 0, 0);
- val = HeVAL(tail_entry);
- sv_dec(val);
+ /* Once we have a winner (including the iteration
+ where we first found him), inc the head ptr
+ for any seq which had the winner as a head,
+ NULL out any seq which is now empty,
+ and adjust tails for consistency */
+
+ int new_head = ++heads[s];
+ if(new_head > AvFILLp(seq)) {
+ avptr[s] = NULL;
+ }
+ else {
+ /* Because we know this new seqhead used to be
+ a tail, we can assume it is in tails and has
+ a positive value, which we need to dec */
+ svp = av_fetch(seq, new_head, 0);
+ seqhead = *svp;
+ tail_entry = hv_fetch_ent(tails, seqhead, 0, 0);
+ val = HeVAL(tail_entry);
+ sv_dec(val);
+ }
}
}
- if(!cand) break;
+
+ /* if we found no candidates, we are done building the MRO.
+ !cand means no seqs have any entries left to check */
+ if(!cand) {
+ Safefree(heads);
+ break;
+ }
+
+ /* If we had candidates, but nobody won, then the @ISA
+ hierarchy is not C3-incompatible */
if(!winner) {
+ /* we have to do some cleanup before we croak */
+ SV** svp = AvARRAY(seqs);
+ items = AvFILLp(seqs) + 1;
+ while (items--)
+ *svp++ = NULL;
+
SvREFCNT_dec(retval);
+ Safefree(heads);
+
Perl_croak(aTHX_ "Inconsistent hierarchy during C3 merge of class '%s': "
"merging failed on parent '%"SVf"'", stashname, SVfARG(cand));
}
} else {
Perl_croak(aTHX_ "panic: invalid MRO!");
}
+ return NULL; /* NOT REACHED */
}
/*
I32 items;
struct mro_meta* meta;
char* stashname;
+ STRLEN stashname_len;
+ bool is_universal = FALSE;
stashname = HvNAME_get(stash);
+ stashname_len = HvNAMELEN_get(stash);
/* wipe out the cached linearizations for this stash */
meta = HvMROMETA(stash);
/* Wipe the global method cache if this package
is UNIVERSAL or one of its parents */
- if(meta->is_universal)
+
+ svp = hv_fetch(PL_isarev, stashname, stashname_len, 0);
+ isarev = svp ? (HV*)*svp : NULL;
+
+ if((stashname_len == 9 && strEQ(stashname, "UNIVERSAL"))
+ || (isarev && hv_exists(isarev, "UNIVERSAL", 9))) {
PL_sub_generation++;
+ is_universal = TRUE;
+ }
/* Wipe the local method cache otherwise */
else
- meta->sub_generation++;
+ meta->cache_gen++;
/* wipe next::method cache too */
if(meta->mro_nextmethod) hv_clear(meta->mro_nextmethod);
/* Iterate the isarev (classes that are our children),
wiping out their linearization and method caches */
- if((isarev = meta->mro_isarev)) {
+ if(isarev) {
hv_iterinit(isarev);
while((iter = hv_iternext(isarev))) {
SV* revkey = hv_iterkeysv(iter);
HV* revstash = gv_stashsv(revkey, 0);
- struct mro_meta* revmeta = HvMROMETA(revstash);
+ struct mro_meta* revmeta;
+
+ if(!revstash) continue;
+ revmeta = HvMROMETA(revstash);
SvREFCNT_dec((SV*)revmeta->mro_linear_dfs);
SvREFCNT_dec((SV*)revmeta->mro_linear_c3);
revmeta->mro_linear_dfs = NULL;
revmeta->mro_linear_c3 = NULL;
- if(!meta->is_universal)
- revmeta->sub_generation++;
+ if(!is_universal)
+ revmeta->cache_gen++;
if(revmeta->mro_nextmethod)
hv_clear(revmeta->mro_nextmethod);
}
items = AvFILLp(linear_mro);
while (items--) {
+ HE* he;
SV* const sv = *svp++;
- struct mro_meta* mrometa;
HV* mroisarev;
- HV* mrostash = gv_stashsv(sv, 0);
- if(!mrostash) {
- mrostash = gv_stashsv(sv, GV_ADD);
- /*
- We created the package on the fly, so
- that we could store isarev information.
- This flag lets gv_fetchmeth know about it,
- so that it can still generate the very useful
- "Can't locate package Foo for @Bar::ISA" warning.
- */
- HvMROMETA(mrostash)->fake = 1;
+ he = hv_fetch_ent(PL_isarev, sv, 0, 0);
+ if(!he) {
+ he = hv_store_ent(PL_isarev, sv, (SV*)newHV(), 0);
}
+ mroisarev = (HV*)HeVAL(he);
- mrometa = HvMROMETA(mrostash);
- mroisarev = mrometa->mro_isarev;
-
- /* is_universal is viral */
- if(meta->is_universal)
- mrometa->is_universal = 1;
-
- if(!mroisarev)
- mroisarev = mrometa->mro_isarev = newHV();
-
- if(!hv_exists(mroisarev, stashname, strlen(stashname)))
- hv_store(mroisarev, stashname, strlen(stashname), &PL_sv_yes, 0);
+ /* This hash only ever contains PL_sv_yes. Storing it over itself is
+ almost as cheap as calling hv_exists, so on aggregate we expect to
+ save time by not making two calls to the common HV code for the
+ case where it doesn't exist. */
+
+ hv_store(mroisarev, stashname, stashname_len, &PL_sv_yes, 0);
if(isarev) {
hv_iterinit(isarev);
while((iter = hv_iternext(isarev))) {
- SV* revkey = hv_iterkeysv(iter);
- if(!hv_exists_ent(mroisarev, revkey, 0))
- hv_store_ent(mroisarev, revkey, &PL_sv_yes, 0);
+ I32 revkeylen;
+ char* revkey = hv_iterkey(iter, &revkeylen);
+ hv_store(mroisarev, revkey, revkeylen, &PL_sv_yes, 0);
}
}
}
/*
=for apidoc mro_method_changed_in
-Like C<mro_isa_changed_in>, but invalidates method
-caching on any child classes of the given stash, so
-that they might notice the changes in this one.
+Invalidates method caching on any child classes
+of the given stash, so that they might notice
+the changes in this one.
Ideally, all instances of C<PL_sub_generation++> in
-the perl source should be replaced by calls to this.
-Some already are, but some are more difficult to
-replace.
+perl source outside of C<mro.c> should be
+replaced by calls to this.
-Perl has always had problems with method caches
-getting out of sync when one directly manipulates
-stashes via things like C<%{Foo::} = %{Bar::}> or
-C<${Foo::}{bar} = ...> or the equivalent. If
-you do this in core or XS code, call this afterwards
-on the destination stash to get things back in sync.
+Perl automatically handles most of the common
+ways a method might be redefined. However, there
+are a few ways you could change a method in a stash
+without the cache code noticing, in which case you
+need to call this method afterwards:
-If you're doing such a thing from pure perl, use
-C<mro::method_changed_in(classname)>, which
-just calls this.
+1) Directly manipulating the stash HV entries from
+XS code.
+
+2) Assigning a reference to a readonly scalar
+constant into a stash entry in order to create
+a constant subroutine (like constant.pm
+does).
+
+This same method is available from pure perl
+via, C<mro::method_changed_in(classname)>.
=cut
*/
void
Perl_mro_method_changed_in(pTHX_ HV *stash)
{
- struct mro_meta* meta = HvMROMETA(stash);
+ SV** svp;
HV* isarev;
HE* iter;
+ char* stashname;
+ STRLEN stashname_len;
+
+ stashname = HvNAME_get(stash);
+ stashname_len = HvNAMELEN_get(stash);
+
+ svp = hv_fetch(PL_isarev, stashname, stashname_len, 0);
+ isarev = svp ? (HV*)*svp : NULL;
/* If stash is UNIVERSAL, or one of UNIVERSAL's parents,
invalidate all method caches globally */
- if(meta->is_universal) {
+ if((stashname_len == 9 && strEQ(stashname, "UNIVERSAL"))
+ || (isarev && hv_exists(isarev, "UNIVERSAL", 9))) {
PL_sub_generation++;
return;
}
/* else, invalidate the method caches of all child classes,
but not itself */
- if((isarev = meta->mro_isarev)) {
+ if(isarev) {
hv_iterinit(isarev);
while((iter = hv_iternext(isarev))) {
SV* revkey = hv_iterkeysv(iter);
HV* revstash = gv_stashsv(revkey, 0);
- struct mro_meta* mrometa = HvMROMETA(revstash);
- mrometa->sub_generation++;
+ struct mro_meta* mrometa;
+
+ if(!revstash) continue;
+ mrometa = HvMROMETA(revstash);
+ mrometa->cache_gen++;
if(mrometa->mro_nextmethod)
hv_clear(mrometa->mro_nextmethod);
}
assert(linear_sv);
curstash = gv_stashsv(linear_sv, FALSE);
- if (!curstash || (HvMROMETA(curstash)->fake && !HvFILL(curstash))) {
+ if (!curstash) {
if (ckWARN(WARN_SYNTAX))
Perl_warner(aTHX_ packWARN(WARN_SYNTAX), "Can't locate package %"SVf" for @%s::ISA",
(void*)linear_sv, hvname);
XS(XS_mro_get_mro);
XS(XS_mro_get_isarev);
XS(XS_mro_is_universal);
-XS(XS_mro_get_global_sub_generation);
-XS(XS_mro_invalidate_all_method_caches);
-XS(XS_mro_get_sub_generation);
+XS(XS_mro_invalidate_method_caches);
XS(XS_mro_method_changed_in);
XS(XS_next_can);
XS(XS_next_method);
newXSproto("mro::get_mro", XS_mro_get_mro, file, "$");
newXSproto("mro::get_isarev", XS_mro_get_isarev, file, "$");
newXSproto("mro::is_universal", XS_mro_is_universal, file, "$");
- newXSproto("mro::get_global_sub_generation", XS_mro_get_global_sub_generation, file, "");
- newXSproto("mro::invalidate_all_method_caches", XS_mro_invalidate_all_method_caches, file, "");
- newXSproto("mro::get_sub_generation", XS_mro_get_sub_generation, file, "$");
+ newXSproto("mro::invalidate_all_method_caches", XS_mro_invalidate_method_caches, file, "");
newXSproto("mro::method_changed_in", XS_mro_method_changed_in, file, "$");
newXS("next::can", XS_next_can, file);
newXS("next::method", XS_next_method, file);
meta->mro_which = which;
/* Only affects local method cache, not
even child classes */
- meta->sub_generation++;
+ meta->cache_gen++;
if(meta->mro_nextmethod)
hv_clear(meta->mro_nextmethod);
}
dXSARGS;
SV* classname;
HV* class_stash;
+ SV** svp;
HV* isarev;
+ char* stashname;
+ STRLEN stashname_len;
PERL_UNUSED_ARG(cv);
if(!class_stash) Perl_croak(aTHX_ "No such class: '%"SVf"'!", SVfARG(classname));
SP -= items;
-
- if((isarev = HvMROMETA(class_stash)->mro_isarev)) {
+
+ stashname = HvNAME_get(class_stash);
+ stashname_len = HvNAMELEN_get(class_stash);
+ svp = hv_fetch(PL_isarev, stashname, stashname_len, 0);
+ isarev = svp ? (HV*)*svp : NULL;
+ if(isarev) {
HE* iter;
hv_iterinit(isarev);
while((iter = hv_iternext(isarev)))
dXSARGS;
SV* classname;
HV* class_stash;
+ HV* isarev;
+ char* stashname;
+ STRLEN stashname_len;
+ SV** svp;
PERL_UNUSED_ARG(cv);
if (items != 1)
- Perl_croak(aTHX_ "Usage: mro::get_mro(classname)");
+ Perl_croak(aTHX_ "Usage: mro::is_universal(classname)");
classname = ST(0);
class_stash = gv_stashsv(classname, 0);
if(!class_stash) Perl_croak(aTHX_ "No such class: '%"SVf"'!", SVfARG(classname));
- if (HvMROMETA(class_stash)->is_universal)
+ stashname = HvNAME_get(class_stash);
+ stashname_len = HvNAMELEN_get(class_stash);
+
+ svp = hv_fetch(PL_isarev, stashname, stashname_len, 0);
+ isarev = svp ? (HV*)*svp : NULL;
+
+ if((stashname_len == 9 && strEQ(stashname, "UNIVERSAL"))
+ || (isarev && hv_exists(isarev, "UNIVERSAL", 9)))
XSRETURN_YES;
else
XSRETURN_NO;
}
-XS(XS_mro_get_global_sub_generation)
-{
- dVAR;
- dXSARGS;
-
- PERL_UNUSED_ARG(cv);
-
- if (items != 0)
- Perl_croak(aTHX_ "Usage: mro::get_global_sub_generation()");
-
- ST(0) = sv_2mortal(newSViv(PL_sub_generation));
- XSRETURN(1);
-}
-
-XS(XS_mro_invalidate_all_method_caches)
+XS(XS_mro_invalidate_method_caches)
{
dVAR;
dXSARGS;
XSRETURN_EMPTY;
}
-XS(XS_mro_get_sub_generation)
-{
- dVAR;
- dXSARGS;
- SV* classname;
- HV* class_stash;
-
- PERL_UNUSED_ARG(cv);
-
- if(items != 1)
- Perl_croak(aTHX_ "Usage: mro::get_sub_generation(classname)");
-
- classname = ST(0);
- class_stash = gv_stashsv(classname, 0);
- if(!class_stash) Perl_croak(aTHX_ "No such class: '%"SVf"'!", SVfARG(classname));
-
- ST(0) = sv_2mortal(newSViv(HvMROMETA(class_stash)->sub_generation));
- XSRETURN(1);
-}
-
XS(XS_mro_method_changed_in)
{
dVAR;
projects / p5sagit/p5-mst-13.2.git / blobdiff