/* mro.c
*
* Copyright (c) 2007 Brandon L Black
+ * Copyright (c) 2007, 2008 Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*/
/*
- * "Which order shall we go in?" said Frodo. "Eldest first, or quickest first?
- * You'll be last either way, Master Peregrin."
+ * 'Which order shall we go in?' said Frodo. 'Eldest first, or quickest first?
+ * You'll be last either way, Master Peregrin.'
+ *
+ * [p.101 of _The Lord of the Rings_, I/iii: "A Conspiracy Unmasked"]
*/
/*
#define PERL_IN_MRO_C
#include "perl.h"
-struct mro_alg {
- const char *name;
- AV *(*resolve)(pTHX_ HV* stash, I32 level);
-};
-
-/* First one is the default */
-static struct mro_alg mros[] = {
- {"dfs", S_mro_get_linear_isa_dfs},
- {"c3", S_mro_get_linear_isa_c3}
-};
-
-#define NUMBER_OF_MROS (sizeof(mros)/sizeof(struct mro_alg))
-
-static const struct mro_alg *
-S_get_mro_from_name(pTHX_ const char *const name) {
- const struct mro_alg *algo = mros;
- const struct mro_alg *const end = mros + NUMBER_OF_MROS;
- while (algo < end) {
- if(strEQ(name, algo->name))
- return algo;
- ++algo;
+static const struct mro_alg dfs_alg =
+ {S_mro_get_linear_isa_dfs, "dfs", 3, 0, 0};
+
+SV *
+Perl_mro_get_private_data(pTHX_ struct mro_meta *const smeta,
+ const struct mro_alg *const which)
+{
+ SV **data;
+ PERL_ARGS_ASSERT_MRO_GET_PRIVATE_DATA;
+
+ data = (SV **)Perl_hv_common(aTHX_ smeta->mro_linear_all, NULL,
+ which->name, which->length, which->kflags,
+ HV_FETCH_JUST_SV, NULL, which->hash);
+ if (!data)
+ return NULL;
+
+ /* If we've been asked to look up the private data for the current MRO, then
+ cache it. */
+ if (smeta->mro_which == which)
+ smeta->mro_linear_current = *data;
+
+ return *data;
+}
+
+SV *
+Perl_mro_set_private_data(pTHX_ struct mro_meta *const smeta,
+ const struct mro_alg *const which, SV *const data)
+{
+ PERL_ARGS_ASSERT_MRO_SET_PRIVATE_DATA;
+
+ if (!smeta->mro_linear_all) {
+ if (smeta->mro_which == which) {
+ /* If all we need to store is the current MRO's data, then don't use
+ memory on a hash with 1 element - store it direct, and signal
+ this by leaving the would-be-hash NULL. */
+ smeta->mro_linear_current = data;
+ return data;
+ } else {
+ HV *const hv = newHV();
+ /* Start with 2 buckets. It's unlikely we'll need more. */
+ HvMAX(hv) = 1;
+ smeta->mro_linear_all = hv;
+
+ if (smeta->mro_linear_current) {
+ /* If we were storing something directly, put it in the hash
+ before we lose it. */
+ Perl_mro_set_private_data(aTHX_ smeta, smeta->mro_which,
+ smeta->mro_linear_current);
+ }
+ }
+ }
+
+ /* We get here if we're storing more than one linearisation for this stash,
+ or the linearisation we are storing is not that if its current MRO. */
+
+ if (smeta->mro_which == which) {
+ /* If we've been asked to store the private data for the current MRO,
+ then cache it. */
+ smeta->mro_linear_current = data;
+ }
+
+ if (!Perl_hv_common(aTHX_ smeta->mro_linear_all, NULL,
+ which->name, which->length, which->kflags,
+ HV_FETCH_ISSTORE, data, which->hash)) {
+ Perl_croak(aTHX_ "panic: hv_store() failed in set_mro_private_data() "
+ "for '%.*s' %d", (int) which->length, which->name,
+ which->kflags);
+ }
+
+ return data;
+}
+
+const struct mro_alg *
+Perl_mro_get_from_name(pTHX_ SV *name) {
+ SV **data;
+
+ PERL_ARGS_ASSERT_MRO_GET_FROM_NAME;
+
+ data = (SV **)Perl_hv_common(aTHX_ PL_registered_mros, name, NULL, 0, 0,
+ HV_FETCH_JUST_SV, NULL, 0);
+ if (!data)
+ return NULL;
+ assert(SvTYPE(*data) == SVt_IV);
+ assert(SvIOK(*data));
+ return INT2PTR(const struct mro_alg *, SvUVX(*data));
+}
+
+void
+Perl_mro_register(pTHX_ const struct mro_alg *mro) {
+ SV *wrapper = newSVuv(PTR2UV(mro));
+
+ PERL_ARGS_ASSERT_MRO_REGISTER;
+
+
+ if (!Perl_hv_common(aTHX_ PL_registered_mros, NULL,
+ mro->name, mro->length, mro->kflags,
+ HV_FETCH_ISSTORE, wrapper, mro->hash)) {
+ SvREFCNT_dec(wrapper);
+ Perl_croak(aTHX_ "panic: hv_store() failed in mro_register() "
+ "for '%.*s' %d", (int) mro->length, mro->name, mro->kflags);
}
- return NULL;
}
struct mro_meta*
{
struct mro_meta* newmeta;
- assert(stash);
+ PERL_ARGS_ASSERT_MRO_META_INIT;
assert(HvAUX(stash));
assert(!(HvAUX(stash)->xhv_mro_meta));
Newxz(newmeta, 1, struct mro_meta);
HvAUX(stash)->xhv_mro_meta = newmeta;
newmeta->cache_gen = 1;
newmeta->pkg_gen = 1;
- newmeta->mro_which = mros;
+ newmeta->mro_which = &dfs_alg;
return newmeta;
}
{
struct mro_meta* newmeta;
- assert(smeta);
+ PERL_ARGS_ASSERT_MRO_META_DUP;
Newx(newmeta, 1, struct mro_meta);
Copy(smeta, newmeta, 1, struct mro_meta);
- if (newmeta->mro_linear_dfs)
- newmeta->mro_linear_dfs
- = (AV*) SvREFCNT_inc(sv_dup((SV*)newmeta->mro_linear_dfs, param));
- if (newmeta->mro_linear_c3)
- newmeta->mro_linear_c3
- = (AV*) SvREFCNT_inc(sv_dup((SV*)newmeta->mro_linear_c3, param));
+ if (newmeta->mro_linear_all) {
+ newmeta->mro_linear_all
+ = MUTABLE_HV(sv_dup_inc((const SV *)newmeta->mro_linear_all, param));
+ /* This is just acting as a shortcut pointer, and will be automatically
+ updated on the first get. */
+ newmeta->mro_linear_current = NULL;
+ } else if (newmeta->mro_linear_current) {
+ /* Only the current MRO is stored, so this owns the data. */
+ newmeta->mro_linear_current
+ = sv_dup_inc((const SV *)newmeta->mro_linear_current, param);
+ }
+
if (newmeta->mro_nextmethod)
newmeta->mro_nextmethod
- = (HV*) SvREFCNT_inc(sv_dup((SV*)newmeta->mro_nextmethod, param));
+ = MUTABLE_HV(sv_dup_inc((const SV *)newmeta->mro_nextmethod, param));
+ if (newmeta->isa)
+ newmeta->isa
+ = MUTABLE_HV(sv_dup_inc((const SV *)newmeta->isa, param));
return newmeta;
}
=cut
*/
static AV*
-S_mro_get_linear_isa_dfs(pTHX_ HV *stash, I32 level)
+S_mro_get_linear_isa_dfs(pTHX_ HV *stash, U32 level)
{
AV* retval;
GV** gvp;
AV* av;
const HEK* stashhek;
struct mro_meta* meta;
+ SV *our_name;
+ HV *stored = NULL;
- assert(stash);
+ PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA_DFS;
assert(HvAUX(stash));
- stashhek = HvNAME_HEK(stash);
+ stashhek
+ = HvAUX(stash)->xhv_name && HvENAME_HEK_NN(stash)
+ ? HvENAME_HEK_NN(stash)
+ : HvNAME_HEK(stash);
+
if (!stashhek)
Perl_croak(aTHX_ "Can't linearize anonymous symbol table");
meta = HvMROMETA(stash);
/* return cache if valid */
- if((retval = meta->mro_linear_dfs)) {
+ if((retval = MUTABLE_AV(MRO_GET_PRIVATE_DATA(meta, &dfs_alg)))) {
return retval;
}
/* not in cache, make a new one */
- retval = (AV*)sv_2mortal((SV *)newAV());
- av_push(retval, newSVhek(stashhek)); /* add ourselves at the top */
+ retval = MUTABLE_AV(sv_2mortal(MUTABLE_SV(newAV())));
+ /* We use this later in this function, but don't need a reference to it
+ beyond the end of this function, so reference count is fine. */
+ our_name = newSVhek(stashhek);
+ av_push(retval, our_name); /* add ourselves at the top */
/* fetch our @ISA */
gvp = (GV**)hv_fetchs(stash, "ISA", FALSE);
av = (gvp && (gv = *gvp) && isGV_with_GP(gv)) ? GvAV(gv) : NULL;
- if(av && AvFILLp(av) >= 0) {
+ /* "stored" is used to keep track of all of the classnames we have added to
+ the MRO so far, so we can do a quick exists check and avoid adding
+ duplicate classnames to the MRO as we go.
+ It's then retained to be re-used as a fast lookup for ->isa(), by adding
+ our own name and "UNIVERSAL" to it. */
- /* "stored" is used to keep track of all of the classnames
- we have added to the MRO so far, so we can do a quick
- exists check and avoid adding duplicate classnames to
- the MRO as we go. */
+ if(av && AvFILLp(av) >= 0) {
- HV* const stored = (HV*)sv_2mortal((SV*)newHV());
SV **svp = AvARRAY(av);
I32 items = AvFILLp(av) + 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)) {
- (void)hv_store_ent(stored, subsv, &PL_sv_undef, 0);
- av_push(retval, newSVsv(subsv));
+ if (stored) {
+ while(subrv_items--) {
+ SV *const subsv = *subrv_p++;
+ /* LVALUE fetch will create a new undefined SV if necessary
+ */
+ HE *const he = hv_fetch_ent(stored, subsv, 1, 0);
+ assert(he);
+ if(HeVAL(he) != &PL_sv_undef) {
+ /* It was newly created. Steal it for our new SV, and
+ replace it in the hash with the "real" thing. */
+ SV *const val = HeVAL(he);
+ HEK *const key = HeKEY_hek(he);
+
+ HeVAL(he) = &PL_sv_undef;
+ /* Save copying by making a shared hash key scalar. We
+ inline this here rather than calling
+ Perl_newSVpvn_share because we already have the
+ scalar, and we already have the hash key. */
+ assert(SvTYPE(val) == SVt_NULL);
+ sv_upgrade(val, SVt_PV);
+ SvPV_set(val, HEK_KEY(share_hek_hek(key)));
+ SvCUR_set(val, HEK_LEN(key));
+ SvREADONLY_on(val);
+ SvFAKE_on(val);
+ SvPOK_on(val);
+ if (HEK_UTF8(key))
+ SvUTF8_on(val);
+
+ av_push(retval, val);
+ }
}
- }
+ } else {
+ /* We are the first (or only) parent. We can short cut the
+ complexity above, because our @ISA is simply us prepended
+ to our parent's @ISA, and our ->isa cache is simply our
+ parent's, with our name added. */
+ /* newSVsv() is slow. This code is only faster if we can avoid
+ it by ensuring that SVs in the arrays are shared hash key
+ scalar SVs, because we can "copy" them very efficiently.
+ Although to be fair, we can't *ensure* this, as a reference
+ to the internal array is returned by mro::get_linear_isa(),
+ so we'll have to be defensive just in case someone faffed
+ with it. */
+ if (basestash) {
+ SV **svp;
+ stored = MUTABLE_HV(sv_2mortal((SV*)newHVhv(HvMROMETA(basestash)->isa)));
+ av_extend(retval, subrv_items);
+ AvFILLp(retval) = subrv_items;
+ svp = AvARRAY(retval);
+ while(subrv_items--) {
+ SV *const val = *subrv_p++;
+ *++svp = SvIsCOW_shared_hash(val)
+ ? newSVhek(SvSHARED_HEK_FROM_PV(SvPVX(val)))
+ : newSVsv(val);
+ }
+ } else {
+ /* They have no stash. So create ourselves an ->isa cache
+ as if we'd copied it from what theirs should be. */
+ stored = MUTABLE_HV(sv_2mortal(MUTABLE_SV(newHV())));
+ (void) hv_store(stored, "UNIVERSAL", 9, &PL_sv_undef, 0);
+ av_push(retval,
+ newSVhek(HeKEY_hek(hv_store_ent(stored, sv,
+ &PL_sv_undef, 0))));
+ }
+ }
}
+ } else {
+ /* We have no parents. */
+ stored = MUTABLE_HV(sv_2mortal(MUTABLE_SV(newHV())));
+ (void) hv_store(stored, "UNIVERSAL", 9, &PL_sv_undef, 0);
}
+ (void) hv_store_ent(stored, our_name, &PL_sv_undef, 0);
+
+ SvREFCNT_inc_simple_void_NN(stored);
+ SvTEMP_off(stored);
+ SvREADONLY_on(stored);
+
+ meta->isa = stored;
+
/* now that we're past the exception dangers, grab our own reference to
the AV we're about to use for the result. The reference owned by the
mortals' stack will be released soon, so everything will balance. */
and we do so by replacing it completely */
SvREADONLY_on(retval);
- meta->mro_linear_dfs = retval;
- return retval;
-}
-
-/*
-=for apidoc mro_get_linear_isa_c3
-
-Returns the C3 linearization of @ISA
-the given stash. The return value is a read-only AV*.
-C<level> should be 0 (it is used internally in this
-function's recursion).
-
-You are responsible for C<SvREFCNT_inc()> on the
-return value if you plan to store it anywhere
-semi-permanently (otherwise it might be deleted
-out from under you the next time the cache is
-invalidated).
-
-=cut
-*/
-
-static AV*
-S_mro_get_linear_isa_c3(pTHX_ HV* stash, I32 level)
-{
- AV* retval;
- GV** gvp;
- GV* gv;
- AV* isa;
- const HEK* stashhek;
- struct mro_meta* meta;
-
- assert(stash);
- assert(HvAUX(stash));
-
- stashhek = HvNAME_HEK(stash);
- if (!stashhek)
- Perl_croak(aTHX_ "Can't linearize anonymous symbol table");
-
- if (level > 100)
- Perl_croak(aTHX_ "Recursive inheritance detected in package '%s'",
- HEK_KEY(stashhek));
-
- meta = HvMROMETA(stash);
-
- /* return cache if valid */
- if((retval = meta->mro_linear_c3)) {
- return retval;
- }
-
- /* not in cache, make a new one */
-
- gvp = (GV**)hv_fetchs(stash, "ISA", FALSE);
- isa = (gvp && (gv = *gvp) && isGV_with_GP(gv)) ? GvAV(gv) : NULL;
-
- /* For a better idea how the rest of this works, see the much clearer
- pure perl version in Algorithm::C3 0.01:
- 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* const tails = (HV*)sv_2mortal((SV*)newHV());
- AV* const 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* const isa_item = *isa_ptr++;
- HV* const isa_item_stash = gv_stashsv(isa_item, 0);
- if(!isa_item_stash) {
- /* if no stash, make a temporary fake MRO
- containing just itself */
- AV* const isa_lin = newAV();
- av_push(isa_lin, newSVsv(isa_item));
- av_push(seqs, (SV*)isa_lin);
- }
- else {
- /* recursion */
- AV* const isa_lin = mro_get_linear_isa_c3(isa_item_stash, level + 1);
- av_push(seqs, SvREFCNT_inc_simple_NN((SV*)isa_lin));
- }
- }
- av_push(seqs, SvREFCNT_inc_simple_NN((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--) {
- AV* const seq = (AV*)*seqs_ptr++;
- I32 seq_items = AvFILLp(seq);
- if(seq_items > 0) {
- SV** seq_ptr = AvARRAY(seq) + 1;
- while(seq_items--) {
- SV* const seqitem = *seq_ptr++;
- /* LVALUE fetch will create a new undefined SV if necessary
- */
- HE* const he = hv_fetch_ent(tails, seqitem, 1, 0);
- if(he) {
- SV* const val = HeVAL(he);
- /* This will increment undef to 1, which is what we
- want for a newly created entry. */
- sv_inc(val);
- }
- }
- }
- }
-
- /* Initialize retval to build the return value in */
- retval = newAV();
- av_push(retval, newSVhek(stashhek)); /* us first */
-
- /* This loop won't terminate until we either finish building
- the MRO, or get an exception. */
- while(1) {
- SV* cand = NULL;
- SV* winner = NULL;
- int s;
-
- /* "foreach $seq (@seqs)" */
- SV** const avptr = AvARRAY(seqs);
- for(s = 0; s <= AvFILLp(seqs); s++) {
- SV** svp;
- AV * const seq = (AV*)(avptr[s]);
- SV* seqhead;
- if(!seq) continue; /* skip empty seqs */
- svp = av_fetch(seq, heads[s], 0);
- seqhead = *svp; /* seqhead = head of this seq */
- if(!winner) {
- HE* tail_entry;
- SV* val;
- /* 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))
- 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)) {
- /* 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 */
-
- const int new_head = ++heads[s];
- if(new_head > AvFILLp(seq)) {
- SvREFCNT_dec(avptr[s]);
- avptr[s] = NULL;
- }
- else {
- HE* tail_entry;
- SV* val;
- /* 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 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 */
-
- SvREFCNT_dec(retval);
- Safefree(heads);
-
- Perl_croak(aTHX_ "Inconsistent hierarchy during C3 merge of class '%s': "
- "merging failed on parent '%"SVf"'", HEK_KEY(stashhek), SVfARG(cand));
- }
- }
- }
- else { /* @ISA was undefined or empty */
- /* build a retval containing only ourselves */
- retval = newAV();
- av_push(retval, newSVhek(stashhek));
- }
-
- /* we don't want anyone modifying the cache entry but us,
- and we do so by replacing it completely */
- SvREADONLY_on(retval);
-
- meta->mro_linear_c3 = retval;
- return retval;
+ return MUTABLE_AV(Perl_mro_set_private_data(aTHX_ meta, &dfs_alg,
+ MUTABLE_SV(retval)));
}
/*
Perl_mro_get_linear_isa(pTHX_ HV *stash)
{
struct mro_meta* meta;
+ AV *isa;
- assert(stash);
+ PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA;
if(!SvOOK(stash))
Perl_croak(aTHX_ "Can't linearize anonymous symbol table");
meta = HvMROMETA(stash);
if (!meta->mro_which)
Perl_croak(aTHX_ "panic: invalid MRO!");
- return meta->mro_which->resolve(aTHX_ stash, 0);
+ isa = meta->mro_which->resolve(aTHX_ stash, 0);
+
+ if (!meta->isa) {
+ HV *const isa_hash = newHV();
+ /* Linearisation didn't build it for us, so do it here. */
+ SV *const *svp = AvARRAY(isa);
+ SV *const *const svp_end = svp + AvFILLp(isa) + 1;
+ const HEK *canon_name = HvENAME_HEK(stash);
+ if (!canon_name) canon_name = HvNAME_HEK(stash);
+
+ while (svp < svp_end) {
+ (void) hv_store_ent(isa_hash, *svp++, &PL_sv_undef, 0);
+ }
+
+ (void) hv_common(isa_hash, NULL, HEK_KEY(canon_name),
+ HEK_LEN(canon_name), HEK_FLAGS(canon_name),
+ HV_FETCH_ISSTORE, &PL_sv_undef,
+ HEK_HASH(canon_name));
+ (void) hv_store(isa_hash, "UNIVERSAL", 9, &PL_sv_undef, 0);
+
+ SvREADONLY_on(isa_hash);
+
+ meta->isa = isa_hash;
+ }
+
+ return isa;
}
/*
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
*/
void
-Perl_mro_isa_changed_in(pTHX_ HV* stash)
+Perl_mro_isa_changed_in3(pTHX_ HV* stash, const char *stashname,
+ STRLEN stashname_len)
{
dVAR;
HV* isarev;
SV** svp;
I32 items;
bool is_universal;
- struct mro_meta * meta;
+ struct mro_meta * meta = NULL;
+ HV *isa = NULL;
- const char * const stashname = HvNAME_get(stash);
- const STRLEN stashname_len = HvNAMELEN_get(stash);
+ 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 */);
if(!stashname)
Perl_croak(aTHX_ "Can't call mro_isa_changed_in() on anonymous symbol table");
- /* wipe out the cached linearizations for this stash */
- meta = HvMROMETA(stash);
- SvREFCNT_dec((SV*)meta->mro_linear_dfs);
- SvREFCNT_dec((SV*)meta->mro_linear_c3);
- meta->mro_linear_dfs = NULL;
- meta->mro_linear_c3 = NULL;
-
- /* Inc the package generation, since our @ISA changed */
- meta->pkg_gen++;
+ 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) {
+ /* 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++;
+ }
/* Wipe the global method cache if this package
is UNIVERSAL or one of its parents */
svp = hv_fetch(PL_isarev, stashname, stashname_len, 0);
- isarev = svp ? (HV*)*svp : NULL;
+ isarev = svp ? MUTABLE_HV(*svp) : NULL;
if((stashname_len == 9 && strEQ(stashname, "UNIVERSAL"))
|| (isarev && hv_exists(isarev, "UNIVERSAL", 9))) {
is_universal = TRUE;
}
else { /* Wipe the local method cache otherwise */
- meta->cache_gen++;
+ if(meta) meta->cache_gen++;
is_universal = FALSE;
}
/* wipe next::method cache too */
- if(meta->mro_nextmethod) hv_clear(meta->mro_nextmethod);
+ if(meta && meta->mro_nextmethod) hv_clear(meta->mro_nextmethod);
/* Iterate the isarev (classes that are our children),
- wiping out their linearization and method caches */
+ wiping out their linearization, method and isa caches
+ and upating PL_isarev. */
if(isarev) {
- hv_iterinit(isarev);
+ HV *isa_hashes = NULL;
+
+ /* We have to iterate through isarev twice to avoid a chicken and
+ * egg problem: if A inherits from B and both are in isarev, A might
+ * be processed before B and use B’s previous linearisation.
+ */
+
+ /* First iteration: Wipe everything, but stash away the isa hashes
+ * since we still need them for updating PL_isarev.
+ */
+
+ if(hv_iterinit(isarev)) {
+ /* Only create the hash if we need it; i.e., if isarev has
+ any elements. */
+ isa_hashes = (HV *)sv_2mortal((SV *)newHV());
+ }
while((iter = hv_iternext(isarev))) {
- SV* const revkey = hv_iterkeysv(iter);
- HV* revstash = gv_stashsv(revkey, 0);
+ I32 len;
+ const char* const revkey = hv_iterkey(iter, &len);
+ HV* revstash = gv_stashpvn(revkey, len, 0);
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 (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;
+ }
if(!is_universal)
revmeta->cache_gen++;
if(revmeta->mro_nextmethod)
hv_clear(revmeta->mro_nextmethod);
+
+ (void)
+ hv_store(
+ isa_hashes, (const char*)&revstash, sizeof(HV *),
+ revmeta->isa ? (SV *)revmeta->isa : &PL_sv_undef, 0
+ );
+ revmeta->isa = NULL;
+ }
+
+ /* Second pass: Update PL_isarev. We can just use isa_hashes to
+ * avoid another round of stash lookups. */
+
+ /* isarev might be deleted from PL_isarev during this loop, so hang
+ * on to it. */
+ SvREFCNT_inc_simple_void_NN(sv_2mortal((SV *)isarev));
+
+ if(isa_hashes) {
+ hv_iterinit(isa_hashes);
+ while((iter = hv_iternext(isa_hashes))) {
+ HV* const revstash = *(HV **)HEK_KEY(HeKEY_hek(iter));
+ 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;
+ items = AvFILLp(linear_mro);
+
+ namehek = HvENAME_HEK(revstash);
+ if (!namehek) namehek = HvNAME_HEK(revstash);
+
+ while (items--) {
+ SV* const sv = *svp++;
+ HV* mroisarev;
+
+ HE *he = hv_fetch_ent(PL_isarev, sv, TRUE, 0);
+
+ /* That fetch should not fail. But if it had to create
+ a new SV for us, then will need to upgrade it to an
+ HV (which sv_upgrade() can now do for us). */
+
+ mroisarev = MUTABLE_HV(HeVAL(he));
+
+ SvUPGRADE(MUTABLE_SV(mroisarev), SVt_PVHV);
+
+ /* 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. */
+
+ (void)
+ hv_store(
+ mroisarev, HEK_KEY(namehek), HEK_LEN(namehek),
+ &PL_sv_yes, 0
+ );
+ }
+
+ if((SV *)isa != &PL_sv_undef)
+ mro_clean_isarev(
+ isa, HEK_KEY(namehek), HEK_LEN(namehek),
+ HvMROMETA(revstash)->isa
+ );
+ }
}
}
- /* Now iterate our MRO (parents), and do a few things:
- 1) instantiate with the "fake" flag if they don't exist
- 2) flag them as universal if we are universal
- 3) Add everything from our isarev to their isarev
+ /* 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;
SV* const sv = *svp++;
HV* mroisarev;
- HE *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);
+ HE *he = hv_fetch_ent(PL_isarev, sv, TRUE, 0);
+
+ /* That fetch should not fail. But if it had to create a new SV for
+ us, then will need to upgrade it to an HV (which sv_upgrade() can
+ now do for us. */
+
+ mroisarev = MUTABLE_HV(HeVAL(he));
+
+ SvUPGRADE(MUTABLE_SV(mroisarev), SVt_PVHV);
/* 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
case where it doesn't exist. */
(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);
+}
+
+/* Deletes name from all the isarev entries listed in isa */
+STATIC void
+S_mro_clean_isarev(pTHX_ HV * const isa, const char * const name,
+ const STRLEN len, HV * const exceptions)
+{
+ HE* iter;
- if(isarev) {
- hv_iterinit(isarev);
- while((iter = hv_iternext(isarev))) {
- I32 revkeylen;
- char* const revkey = hv_iterkey(iter, &revkeylen);
- (void)hv_store(mroisarev, revkey, revkeylen, &PL_sv_yes, 0);
+ PERL_ARGS_ASSERT_MRO_CLEAN_ISAREV;
+
+ /* Delete our name from our former parents’ isarevs. */
+ if(isa && HvARRAY(isa) && hv_iterinit(isa)) {
+ SV **svp;
+ while((iter = hv_iternext(isa))) {
+ I32 klen;
+ const char * const key = hv_iterkey(iter, &klen);
+ if(exceptions && hv_exists(exceptions, key, klen)) continue;
+ svp = hv_fetch(PL_isarev, key, klen, 0);
+ if(svp) {
+ HV * const isarev = (HV *)*svp;
+ (void)hv_delete(isarev, name, len, G_DISCARD);
+ if(!HvARRAY(isarev) || !HvKEYS(isarev))
+ (void)hv_delete(PL_isarev, key, klen, G_DISCARD);
}
}
}
}
/*
+=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. 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.
+
+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.
+
+=cut
+*/
+void
+Perl_mro_package_moved(pTHX_ HV * const stash, HV * const oldstash,
+ const GV *gv, const char *newname,
+ I32 newname_len)
+{
+ HV *stashes;
+ HE* iter;
+
+ assert(stash || oldstash);
+ assert(gv || newname);
+
+ /* Determine the name 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)
+ *
+ * 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.
+ */
+ 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(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
+ 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.
+ */
+ 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;
+ }
+ }
+ }
+
+ /* 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;
+ }
+}
+
+void
+S_mro_gather_and_rename(pTHX_ HV * const stashes, HV *stash, HV *oldstash,
+ const char *name, I32 namlen)
+{
+ register XPVHV* xhv;
+ register HE *entry;
+ I32 riter = -1;
+ const bool stash_had_name = stash && HvENAME(stash);
+ HV *seen = NULL;
+ HV *isarev = NULL;
+ SV **svp;
+
+ PERL_ARGS_ASSERT_MRO_GATHER_AND_RENAME;
+
+ if(oldstash) {
+ /* Add to the big list. */
+ HE * const entry
+ = (HE *)
+ hv_common(
+ stashes, NULL, (const char *)&oldstash, sizeof(HV *), 0,
+ HV_FETCH_LVALUE|HV_FETCH_EMPTY_HE, NULL, 0
+ );
+ if(HeVAL(entry) == (SV *)oldstash) {
+ oldstash = NULL;
+ goto check_stash;
+ }
+ HeVAL(entry) = (SV *)oldstash;
+
+ /* 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);
+ }
+ }
+ }
+ 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. */
+
+ /* The stash needs mro_isa_changed_in called on it 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
+ * 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(
+ 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)
+ stash = NULL;
+ else HeVAL(entry) = stash_had_name ? &PL_sv_yes : (SV *)stash;
+ }
+
+ if(!stash && !oldstash)
+ /* Both stashes have been encountered already. */
+ return;
+
+ /* Add all the subclasses to the big list. */
+ if(
+ isarev
+ || (
+ (svp = hv_fetch(PL_isarev, name, namlen, 0))
+ && (isarev = MUTABLE_HV(*svp))
+ )
+ ) {
+ HE *iter;
+ 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);
+
+ if(!revstash) continue;
+ entry
+ = (HE *)
+ hv_common(
+ stashes, NULL, (const char *)&revstash, sizeof(HV *), 0,
+ HV_FETCH_LVALUE|HV_FETCH_EMPTY_HE, NULL, 0
+ );
+ HeVAL(entry) = (SV *)revstash;
+
+ }
+ }
+
+ if(
+ (!stash || !HvARRAY(stash)) && (!oldstash || !HvARRAY(oldstash))
+ ) return;
+
+ /* 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] == ':') {
+ HV * const oldsubstash = GvHV(HeVAL(entry));
+ SV ** const stashentry
+ = stash ? hv_fetch(stash, key, len, 0) : NULL;
+ HV *substash = NULL;
+
+ /* Avoid main::main::main::... */
+ if(oldsubstash == oldstash) continue;
+
+ if(
+ (
+ stashentry && *stashentry
+ && (substash = GvHV(*stashentry))
+ )
+ || (oldsubstash && HvENAME_get(oldsubstash))
+ )
+ {
+ /* 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
+ );
+ }
+ }
+
+ (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);
+
+ /* Iterate through the new stash, skipping $seen{$key} items,
+ calling mro_gather_and_rename(stashes, 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] == ':') {
+ HV *substash;
+
+ /* If this entry was seen when we iterated through the
+ oldstash, skip it. */
+ if(seen && hv_exists(seen, key, 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 *namesv;
+ const char *subname;
+ STRLEN subnamlen;
+
+ /* 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);
+ mro_gather_and_rename(
+ stashes, substash, NULL, subname, subnamlen
+ );
+ }
+ }
+ }
+ }
+ }
+}
+
+/*
=for apidoc mro_method_changed_in
Invalidates method caching on any child classes
void
Perl_mro_method_changed_in(pTHX_ HV *stash)
{
- const char * const stashname = HvNAME_get(stash);
- const STRLEN stashname_len = HvNAMELEN_get(stash);
+ const char * const stashname = HvENAME_get(stash);
+ const STRLEN stashname_len = HvENAMELEN_get(stash);
SV ** const svp = hv_fetch(PL_isarev, stashname, stashname_len, 0);
- HV * const isarev = svp ? (HV*)*svp : NULL;
+ HV * const isarev = svp ? MUTABLE_HV(*svp) : NULL;
+
+ PERL_ARGS_ASSERT_MRO_METHOD_CHANGED_IN;
if(!stashname)
Perl_croak(aTHX_ "Can't call mro_method_changed_in() on anonymous symbol table");
hv_iterinit(isarev);
while((iter = hv_iternext(isarev))) {
- SV* const revkey = hv_iterkeysv(iter);
- HV* const revstash = gv_stashsv(revkey, 0);
+ I32 len;
+ const char* const revkey = hv_iterkey(iter, &len);
+ HV* const revstash = gv_stashpvn(revkey, len, 0);
struct mro_meta* mrometa;
if(!revstash) continue;
}
}
-/* These two are static helpers for next::method and friends,
- and re-implement a bunch of the code from pp_caller() in
- a more efficient manner for this particular usage.
-*/
-
-STATIC I32
-__dopoptosub_at(const PERL_CONTEXT *cxstk, I32 startingblock) {
- I32 i;
- for (i = startingblock; i >= 0; i--) {
- if(CxTYPE((PERL_CONTEXT*)(&cxstk[i])) == CXt_SUB) return i;
- }
- return i;
-}
-
-#include "XSUB.h"
-
-XS(XS_mro_get_linear_isa);
-XS(XS_mro_set_mro);
-XS(XS_mro_get_mro);
-XS(XS_mro_get_isarev);
-XS(XS_mro_is_universal);
-XS(XS_mro_invalidate_method_caches);
-XS(XS_mro_method_changed_in);
-XS(XS_mro_get_pkg_gen);
-XS(XS_mro_nextcan);
-
void
-Perl_boot_core_mro(pTHX)
+Perl_mro_set_mro(pTHX_ struct mro_meta *const meta, SV *const name)
{
- dVAR;
- static const char file[] = __FILE__;
-
- newXSproto("mro::get_linear_isa", XS_mro_get_linear_isa, file, "$;$");
- newXSproto("mro::set_mro", XS_mro_set_mro, file, "$$");
- 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::invalidate_all_method_caches", XS_mro_invalidate_method_caches, file, "");
- newXSproto("mro::method_changed_in", XS_mro_method_changed_in, file, "$");
- newXSproto("mro::get_pkg_gen", XS_mro_get_pkg_gen, file, "$");
- newXS("mro::_nextcan", XS_mro_nextcan, file);
-}
-
-XS(XS_mro_get_linear_isa) {
- dVAR;
- dXSARGS;
- AV* RETVAL;
- HV* class_stash;
- SV* classname;
+ const struct mro_alg *const which = Perl_mro_get_from_name(aTHX_ name);
+
+ PERL_ARGS_ASSERT_MRO_SET_MRO;
- PERL_UNUSED_ARG(cv);
-
- if(items < 1 || items > 2)
- Perl_croak(aTHX_ "Usage: mro::get_linear_isa(classname [, type ])");
-
- classname = ST(0);
- class_stash = gv_stashsv(classname, 0);
-
- if(!class_stash) {
- /* No stash exists yet, give them just the classname */
- AV* isalin = newAV();
- av_push(isalin, newSVsv(classname));
- ST(0) = sv_2mortal(newRV_noinc((SV*)isalin));
- XSRETURN(1);
- }
- else if(items > 1) {
- const char* const which = SvPV_nolen(ST(1));
- const struct mro_alg *const algo = S_get_mro_from_name(aTHX_ which);
- if (!algo)
- Perl_croak(aTHX_ "Invalid mro name: '%s'", which);
- RETVAL = algo->resolve(aTHX_ class_stash, 0);
- }
- else {
- RETVAL = mro_get_linear_isa(class_stash);
- }
-
- ST(0) = newRV_inc((SV*)RETVAL);
- sv_2mortal(ST(0));
- XSRETURN(1);
-}
-
-XS(XS_mro_set_mro)
-{
- dVAR;
- dXSARGS;
- SV* classname;
- const char* whichstr;
- const struct mro_alg *which;
- HV* class_stash;
- struct mro_meta* meta;
-
- PERL_UNUSED_ARG(cv);
-
- if (items != 2)
- Perl_croak(aTHX_ "Usage: mro::set_mro(classname, type)");
-
- classname = ST(0);
- whichstr = SvPV_nolen(ST(1));
- class_stash = gv_stashsv(classname, GV_ADD);
- if(!class_stash) Perl_croak(aTHX_ "Cannot create class: '%"SVf"'!", SVfARG(classname));
- meta = HvMROMETA(class_stash);
-
- which = S_get_mro_from_name(aTHX_ whichstr);
if (!which)
- Perl_croak(aTHX_ "Invalid mro name: '%s'", whichstr);
+ Perl_croak(aTHX_ "Invalid mro name: '%"SVf"'", name);
if(meta->mro_which != which) {
- meta->mro_which = which;
+ if (meta->mro_linear_current && !meta->mro_linear_all) {
+ /* If we were storing something directly, put it in the hash before
+ we lose it. */
+ Perl_mro_set_private_data(aTHX_ meta, meta->mro_which,
+ MUTABLE_SV(meta->mro_linear_current));
+ }
+ meta->mro_which = which;
+ /* Scrub our cached pointer to the private data. */
+ meta->mro_linear_current = NULL;
/* Only affects local method cache, not
even child classes */
meta->cache_gen++;
if(meta->mro_nextmethod)
hv_clear(meta->mro_nextmethod);
}
-
- XSRETURN_EMPTY;
-}
-
-
-XS(XS_mro_get_mro)
-{
- dVAR;
- dXSARGS;
- SV* classname;
- HV* class_stash;
-
- PERL_UNUSED_ARG(cv);
-
- if (items != 1)
- Perl_croak(aTHX_ "Usage: mro::get_mro(classname)");
-
- classname = ST(0);
- class_stash = gv_stashsv(classname, 0);
-
- ST(0) = sv_2mortal(newSVpv(class_stash
- ? HvMROMETA(class_stash)->mro_which->name
- : "dfs", 0));
- XSRETURN(1);
-}
-
-XS(XS_mro_get_isarev)
-{
- dVAR;
- dXSARGS;
- SV* classname;
- HE* he;
- HV* isarev;
- AV* ret_array;
-
- PERL_UNUSED_ARG(cv);
-
- if (items != 1)
- Perl_croak(aTHX_ "Usage: mro::get_isarev(classname)");
-
- classname = ST(0);
-
- SP -= items;
-
-
- he = hv_fetch_ent(PL_isarev, classname, 0, 0);
- isarev = he ? (HV*)HeVAL(he) : NULL;
-
- ret_array = newAV();
- if(isarev) {
- HE* iter;
- hv_iterinit(isarev);
- while((iter = hv_iternext(isarev)))
- av_push(ret_array, newSVsv(hv_iterkeysv(iter)));
- }
- XPUSHs(sv_2mortal(newRV_noinc((SV*)ret_array)));
-
- PUTBACK;
- return;
}
-XS(XS_mro_is_universal)
-{
- dVAR;
- dXSARGS;
- SV* classname;
- HV* isarev;
- char* classname_pv;
- STRLEN classname_len;
- HE* he;
-
- PERL_UNUSED_ARG(cv);
-
- if (items != 1)
- Perl_croak(aTHX_ "Usage: mro::is_universal(classname)");
-
- classname = ST(0);
-
- classname_pv = SvPV(classname,classname_len);
-
- he = hv_fetch_ent(PL_isarev, classname, 0, 0);
- isarev = he ? (HV*)HeVAL(he) : NULL;
+#include "XSUB.h"
- if((classname_len == 9 && strEQ(classname_pv, "UNIVERSAL"))
- || (isarev && hv_exists(isarev, "UNIVERSAL", 9)))
- XSRETURN_YES;
- else
- XSRETURN_NO;
-}
+XS(XS_mro_method_changed_in);
-XS(XS_mro_invalidate_method_caches)
+void
+Perl_boot_core_mro(pTHX)
{
dVAR;
- dXSARGS;
-
- PERL_UNUSED_ARG(cv);
-
- if (items != 0)
- Perl_croak(aTHX_ "Usage: mro::invalidate_all_method_caches()");
+ static const char file[] = __FILE__;
- PL_sub_generation++;
+ Perl_mro_register(aTHX_ &dfs_alg);
- XSRETURN_EMPTY;
+ newXSproto("mro::method_changed_in", XS_mro_method_changed_in, file, "$");
}
XS(XS_mro_method_changed_in)
SV* classname;
HV* class_stash;
- PERL_UNUSED_ARG(cv);
-
if(items != 1)
- Perl_croak(aTHX_ "Usage: mro::method_changed_in(classname)");
+ croak_xs_usage(cv, "classname");
classname = ST(0);
XSRETURN_EMPTY;
}
-XS(XS_mro_get_pkg_gen)
-{
- dVAR;
- dXSARGS;
- SV* classname;
- HV* class_stash;
-
- PERL_UNUSED_ARG(cv);
-
- if(items != 1)
- Perl_croak(aTHX_ "Usage: mro::get_pkg_gen(classname)");
-
- classname = ST(0);
-
- class_stash = gv_stashsv(classname, 0);
-
- SP -= items;
-
- XPUSHs(sv_2mortal(newSViv(
- class_stash ? HvMROMETA(class_stash)->pkg_gen : 0
- )));
-
- PUTBACK;
- return;
-}
-
-XS(XS_mro_nextcan)
-{
- dVAR;
- dXSARGS;
- SV* self = ST(0);
- const I32 throw_nomethod = SvIVX(ST(1));
- register I32 cxix = cxstack_ix;
- register const PERL_CONTEXT *ccstack = cxstack;
- const PERL_SI *top_si = PL_curstackinfo;
- HV* selfstash;
- SV *stashname;
- const char *fq_subname;
- const char *subname;
- STRLEN stashname_len;
- STRLEN subname_len;
- SV* sv;
- GV** gvp;
- AV* linear_av;
- SV** linear_svp;
- const char *hvname;
- I32 entries;
- struct mro_meta* selfmeta;
- HV* nmcache;
- I32 i;
-
- PERL_UNUSED_ARG(cv);
-
- SP -= items;
-
- if(sv_isobject(self))
- selfstash = SvSTASH(SvRV(self));
- else
- selfstash = gv_stashsv(self, 0);
-
- assert(selfstash);
-
- hvname = HvNAME_get(selfstash);
- if (!hvname)
- Perl_croak(aTHX_ "Can't use anonymous symbol table for method lookup");
-
- /* This block finds the contextually-enclosing fully-qualified subname,
- much like looking at (caller($i))[3] until you find a real sub that
- isn't ANON, etc (also skips over pureperl next::method, etc) */
- for(i = 0; i < 2; i++) {
- cxix = __dopoptosub_at(ccstack, cxix);
- for (;;) {
- GV* cvgv;
- STRLEN fq_subname_len;
-
- /* we may be in a higher stacklevel, so dig down deeper */
- while (cxix < 0) {
- if(top_si->si_type == PERLSI_MAIN)
- Perl_croak(aTHX_ "next::method/next::can/maybe::next::method must be used in method context");
- top_si = top_si->si_prev;
- ccstack = top_si->si_cxstack;
- cxix = __dopoptosub_at(ccstack, top_si->si_cxix);
- }
-
- if(CxTYPE((PERL_CONTEXT*)(&ccstack[cxix])) != CXt_SUB
- || (PL_DBsub && GvCV(PL_DBsub) && ccstack[cxix].blk_sub.cv == GvCV(PL_DBsub))) {
- cxix = __dopoptosub_at(ccstack, cxix - 1);
- continue;
- }
-
- {
- const I32 dbcxix = __dopoptosub_at(ccstack, cxix - 1);
- if (PL_DBsub && GvCV(PL_DBsub) && dbcxix >= 0 && ccstack[dbcxix].blk_sub.cv == GvCV(PL_DBsub)) {
- if(CxTYPE((PERL_CONTEXT*)(&ccstack[dbcxix])) != CXt_SUB) {
- cxix = dbcxix;
- continue;
- }
- }
- }
-
- cvgv = CvGV(ccstack[cxix].blk_sub.cv);
-
- if(!isGV(cvgv)) {
- cxix = __dopoptosub_at(ccstack, cxix - 1);
- continue;
- }
-
- /* we found a real sub here */
- sv = sv_2mortal(newSV(0));
-
- gv_efullname3(sv, cvgv, NULL);
-
- fq_subname = SvPVX(sv);
- fq_subname_len = SvCUR(sv);
-
- subname = strrchr(fq_subname, ':');
- if(!subname)
- Perl_croak(aTHX_ "next::method/next::can/maybe::next::method cannot find enclosing method");
-
- subname++;
- subname_len = fq_subname_len - (subname - fq_subname);
- if(subname_len == 8 && strEQ(subname, "__ANON__")) {
- cxix = __dopoptosub_at(ccstack, cxix - 1);
- continue;
- }
- break;
- }
- cxix--;
- }
-
- /* If we made it to here, we found our context */
-
- /* Initialize the next::method cache for this stash
- if necessary */
- selfmeta = HvMROMETA(selfstash);
- if(!(nmcache = selfmeta->mro_nextmethod)) {
- nmcache = selfmeta->mro_nextmethod = newHV();
- }
- else { /* Use the cached coderef if it exists */
- HE* cache_entry = hv_fetch_ent(nmcache, sv, 0, 0);
- if (cache_entry) {
- SV* const val = HeVAL(cache_entry);
- if(val == &PL_sv_undef) {
- if(throw_nomethod)
- Perl_croak(aTHX_ "No next::method '%s' found for %s", subname, hvname);
- XSRETURN_EMPTY;
- }
- XPUSHs(sv_2mortal(newRV_inc(val)));
- XSRETURN(1);
- }
- }
-
- /* beyond here is just for cache misses, so perf isn't as critical */
-
- stashname_len = subname - fq_subname - 2;
- stashname = sv_2mortal(newSVpvn(fq_subname, stashname_len));
-
- linear_av = mro_get_linear_isa_c3(selfstash, 0); /* has ourselves at the top of the list */
-
- linear_svp = AvARRAY(linear_av);
- entries = AvFILLp(linear_av) + 1;
-
- /* Walk down our MRO, skipping everything up
- to the contextually enclosing class */
- while (entries--) {
- SV * const linear_sv = *linear_svp++;
- assert(linear_sv);
- if(sv_eq(linear_sv, stashname))
- break;
- }
-
- /* Now search the remainder of the MRO for the
- same method name as the contextually enclosing
- method */
- if(entries > 0) {
- while (entries--) {
- SV * const linear_sv = *linear_svp++;
- HV* curstash;
- GV* candidate;
- CV* cand_cv;
-
- assert(linear_sv);
- curstash = gv_stashsv(linear_sv, FALSE);
-
- if (!curstash) {
- if (ckWARN(WARN_SYNTAX))
- Perl_warner(aTHX_ packWARN(WARN_SYNTAX), "Can't locate package %"SVf" for @%s::ISA",
- (void*)linear_sv, hvname);
- continue;
- }
-
- assert(curstash);
-
- gvp = (GV**)hv_fetch(curstash, subname, subname_len, 0);
- if (!gvp) continue;
-
- candidate = *gvp;
- assert(candidate);
-
- if (SvTYPE(candidate) != SVt_PVGV)
- gv_init(candidate, curstash, subname, subname_len, TRUE);
-
- /* Notably, we only look for real entries, not method cache
- entries, because in C3 the method cache of a parent is not
- valid for the child */
- if (SvTYPE(candidate) == SVt_PVGV && (cand_cv = GvCV(candidate)) && !GvCVGEN(candidate)) {
- SvREFCNT_inc_simple_void_NN((SV*)cand_cv);
- (void)hv_store_ent(nmcache, newSVsv(sv), (SV*)cand_cv, 0);
- XPUSHs(sv_2mortal(newRV_inc((SV*)cand_cv)));
- XSRETURN(1);
- }
- }
- }
-
- (void)hv_store_ent(nmcache, newSVsv(sv), &PL_sv_undef, 0);
- if(throw_nomethod)
- Perl_croak(aTHX_ "No next::method '%s' found for %s", subname, hvname);
- XSRETURN_EMPTY;
-}
-
/*
* Local variables:
* c-indentation-style: bsd
https://perl5.git.perl.org / perl5.git / blobdiff