Re: new C3 MRO patch

From: "Brandon Black" <blblack@gmail.com>
Message-ID: <84621a60704171114k29b0460el5b08ce5185d55ed5@mail.gmail.com>

p4raw-id: //depot/perl@30980

1 files changed, 1002 insertions, 0 deletions

diff --git a/mro.c b/mro.c
new file mode 100644
index 0000000000..87b5cb2423
--- /dev/null
+++ b/mro.c
@@ -0,0 +1,1002 @@
+/*    mro.c
+ *
+ *    Copyright (c) 2007 Brandon L Black
+ *
+ *    You may distribute under the terms of either the GNU General Public
+ *    License or the Artistic License, as specified in the README file.
+ *
+ */
+
+/*
+=head1 MRO Functions
+
+These functions are related to the method resolution order of perl classes
+
+=cut
+*/
+
+#include "EXTERN.h"
+#include "perl.h"
+
+struct mro_meta*
+Perl_mro_meta_init(pTHX_ HV* stash)
+{
+    void* newmeta;
+
+    assert(stash);
+    assert(HvAUX(stash));
+    assert(!(HvAUX(stash)->xhv_mro_meta));
+    Newxz(newmeta, sizeof(struct mro_meta), char);
+    HvAUX(stash)->xhv_mro_meta = (struct mro_meta*)newmeta;
+    ((struct mro_meta*)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;
+    }
+
+    return newmeta;
+}
+
+#if defined(USE_ITHREADS)
+
+/* for sv_dup on new threads */
+struct mro_meta*
+Perl_mro_meta_dup(pTHX_ struct mro_meta* smeta, CLONE_PARAMS* param)
+{
+    void* newmeta_void;
+    struct mro_meta* newmeta;
+
+    assert(smeta);
+
+    Newx(newmeta_void, sizeof(struct mro_meta), char);
+    newmeta = (struct mro_meta*)newmeta_void;
+
+    newmeta->mro_which       = smeta->mro_which;
+    newmeta->sub_generation  = smeta->sub_generation;
+    newmeta->is_universal    = smeta->is_universal;
+    newmeta->fake            = smeta->fake;
+    newmeta->mro_linear_dfs  = smeta->mro_linear_dfs
+        ? (AV*) SvREFCNT_inc(sv_dup((SV*)smeta->mro_linear_dfs, param))
+        : 0;
+    newmeta->mro_linear_c3   = smeta->mro_linear_c3
+        ? (AV*) SvREFCNT_inc(sv_dup((SV*)smeta->mro_linear_c3, param))
+        : 0;
+    newmeta->mro_isarev      = smeta->mro_isarev
+        ? (HV*) SvREFCNT_inc(sv_dup((SV*)smeta->mro_isarev, param))
+        : 0;
+    newmeta->mro_nextmethod  = smeta->mro_nextmethod
+        ? (HV*) SvREFCNT_inc(sv_dup((SV*)smeta->mro_nextmethod, param))
+        : 0;
+
+    return newmeta;
+}
+
+#endif /* USE_ITHREADS */
+
+/*
+=for apidoc mro_get_linear_isa_dfs
+
+Returns the Depth-First Search 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).
+
+=cut
+*/
+AV*
+Perl_mro_get_linear_isa_dfs(pTHX_ HV *stash, I32 level)
+{
+    AV* retval;
+    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;
+
+    assert(stash);
+    assert(HvAUX(stash));
+
+    stashname = HvNAME_get(stash);
+    if (!stashname)
+      Perl_croak(aTHX_
+                 "Can't linearize anonymous symbol table");
+
+    if (level > 100)
+        Perl_croak(aTHX_ "Recursive inheritance detected in package '%s'",
+              stashname);
+
+    meta = HvMROMETA(stash);
+    if((retval = meta->mro_linear_dfs)) {
+        /* return cache if valid */
+        return retval;
+    }
+
+    /* not in cache, make a new one */
+    retval = newAV();
+    av_push(retval, newSVpv(stashname, 0)); /* add ourselves at the top */
+
+    gvp = (GV**)hv_fetchs(stash, "ISA", FALSE);
+    av = (gvp && (gv = *gvp) && isGV_with_GP(gv)) ? GvAV(gv) : NULL;
+
+    if(av) {
+        HV* stored = (HV*)sv_2mortal((SV*)newHV());
+        svp = AvARRAY(av);
+        items = AvFILLp(av) + 1;
+        while (items--) {
+            SV* const sv = *svp++;
+            HV* const basestash = gv_stashsv(sv, 0);
+
+            if (!basestash) {
+                if(!hv_exists_ent(stored, sv, 0)) {
+                    av_push(retval, newSVsv(sv));
+                    hv_store_ent(stored, sv, &PL_sv_undef, 0);
+                }
+            }
+            else {
+                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);
+                    }
+                }
+            }
+        }
+    }
+
+    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).
+
+=cut
+*/
+
+AV*
+Perl_mro_get_linear_isa_c3(pTHX_ HV* stash, I32 level)
+{
+    AV* retval;
+    GV** gvp;
+    GV* gv;
+    AV* isa;
+    const char* stashname;
+    STRLEN stashname_len;
+    struct mro_meta* meta;
+
+    assert(stash);
+    assert(HvAUX(stash));
+
+    stashname = HvNAME_get(stash);
+    stashname_len = HvNAMELEN_get(stash);
+    if (!stashname)
+      Perl_croak(aTHX_
+                 "Can't linearize anonymous symbol table");
+
+    if (level > 100)
+        Perl_croak(aTHX_ "Recursive inheritance detected in package '%s'",
+              stashname);
+
+    meta = HvMROMETA(stash);
+    if((retval = meta->mro_linear_c3)) {
+        /* return cache if valid */
+        return retval;
+    }
+
+    /* not in cache, make a new one */
+
+    retval = newAV();
+    av_push(retval, newSVpvn(stashname, stashname_len)); /* us first */
+
+    gvp = (GV**)hv_fetchs(stash, "ISA", FALSE);
+    isa = (gvp && (gv = *gvp) && isGV_with_GP(gv)) ? GvAV(gv) : NULL;
+
+    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 items = AvFILLp(isa) + 1;
+        SV** isa_ptr = AvARRAY(isa);
+        while(items--) {
+            AV* isa_lin;
+            SV* isa_item = *isa_ptr++;
+            HV* isa_item_stash = gv_stashsv(isa_item, 0);
+            if(!isa_item_stash) {
+                isa_lin = 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*)av_make(AvFILLp(isa)+1, AvARRAY(isa)));
+
+        seqs_ptr = AvARRAY(seqs);
+        seqs_items = AvFILLp(seqs) + 1;
+        while(seqs_items--) {
+            AV* seq = (AV*)*seqs_ptr++;
+            I32 seq_items = AvFILLp(seq);
+            if(seq_items > 0) {
+                SV** seq_ptr = AvARRAY(seq) + 1;
+                while(seq_items--) {
+                    SV* seqitem = *seq_ptr++;
+                    HE* he = hv_fetch_ent(tails, seqitem, 0, 0);
+                    if(!he) {
+                        hv_store_ent(tails, seqitem, newSViv(1), 0);
+                    }
+                    else {
+                        SV* val = HeVAL(he);
+                        sv_inc(val);
+                    }
+                }
+            }
+        }
+
+        while(1) {
+            SV* seqhead = NULL;
+            SV* cand = NULL;
+            SV* winner = NULL;
+            SV* val;
+            HE* tail_entry;
+            AV* seq;
+            SV** avptr = AvARRAY(seqs);
+            items = AvFILLp(seqs)+1;
+            while(items--) {
+                SV** svp;
+                seq = (AV*)*avptr++;
+                if(AvFILLp(seq) < 0) continue;
+                svp = av_fetch(seq, 0, 0);
+                seqhead = *svp;
+                if(!winner) {
+                    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);
+                }
+                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);
+                }
+            }
+            if(!cand) break;
+            if(!winner) {
+                SvREFCNT_dec(retval);
+                Perl_croak(aTHX_ "Inconsistent hierarchy during C3 merge of class '%s': "
+                    "merging failed on parent '%"SVf"'", stashname, SVfARG(cand));
+            }
+        }
+    }
+
+    SvREADONLY_on(retval);
+    meta->mro_linear_c3 = retval;
+    return retval;
+}
+
+/*
+=for apidoc mro_get_linear_isa
+
+Returns either C<mro_get_linear_isa_c3> or
+C<mro_get_linear_isa_dfs> for the given stash,
+dependant upon which MRO is in effect
+for that stash.  The return value is a
+read-only AV*.
+
+=cut
+*/
+AV*
+Perl_mro_get_linear_isa(pTHX_ HV *stash)
+{
+    struct mro_meta* meta;
+    assert(stash);
+    assert(HvAUX(stash));
+
+    meta = HvMROMETA(stash);
+    if(meta->mro_which == MRO_DFS) {
+        return mro_get_linear_isa_dfs(stash, 0);
+    } else if(meta->mro_which == MRO_C3) {
+        return mro_get_linear_isa_c3(stash, 0);
+    } else {
+        Perl_croak(aTHX_ "Internal error: invalid MRO!");
+    }
+}
+
+/*
+=for apidoc mro_isa_changed_in
+
+Takes the neccesary 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.
+
+=cut
+*/
+void
+Perl_mro_isa_changed_in(pTHX_ HV* stash)
+{
+    dVAR;
+    HV* isarev;
+    AV* linear_mro;
+    HE* iter;
+    SV** svp;
+    I32 items;
+    struct mro_meta* meta;
+    char* stashname;
+
+    stashname = HvNAME_get(stash);
+
+    /* 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;
+
+    /* Wipe the global method cache if this package
+       is UNIVERSAL or one of its parents */
+    if(meta->is_universal)
+        PL_sub_generation++;
+
+    /* Wipe the local method cache otherwise */
+    else
+        meta->sub_generation++;
+
+    /* 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)) {
+        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);
+            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(revmeta->mro_nextmethod)
+                hv_clear(revmeta->mro_nextmethod);
+        }
+    }
+
+    /* we're starting at the 2nd element, skipping ourselves here */
+    linear_mro = mro_get_linear_isa(stash);
+    svp = AvARRAY(linear_mro) + 1;
+    items = AvFILLp(linear_mro);
+    while (items--) {
+        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;
+        }
+
+        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);
+
+        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);
+            }
+        }
+    }
+}
+
+/*
+=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.
+
+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 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.
+
+If you're doing such a thing from pure perl, use
+C<mro::method_changed_in(classname)>, which
+just calls this.
+
+=cut
+*/
+void
+Perl_mro_method_changed_in(pTHX_ HV *stash)
+{
+    struct mro_meta* meta = HvMROMETA(stash);
+    HV* isarev;
+    HE* iter;
+
+    /* If stash is UNIVERSAL, or one of UNIVERSAL's parents,
+       invalidate all method caches globally */
+    if(meta->is_universal) {
+        PL_sub_generation++;
+        return;
+    }
+
+    /* else, invalidate the method caches of all child classes,
+       but not itself */
+    if((isarev = meta->mro_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++;
+            if(mrometa->mro_nextmethod)
+                hv_clear(mrometa->mro_nextmethod);
+        }
+    }
+}
+
+/* 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;
+}
+
+STATIC SV*
+__nextcan(pTHX_ SV* self, I32 throw_nomethod)
+{
+    register I32 cxix;
+    register const PERL_CONTEXT *ccstack = cxstack;
+    const PERL_SI *top_si = PL_curstackinfo;
+    HV* selfstash;
+    GV* cvgv;
+    SV *stashname;
+    const char *fq_subname;
+    const char *subname;
+    STRLEN fq_subname_len;
+    STRLEN stashname_len;
+    STRLEN subname_len;
+    SV* sv;
+    GV** gvp;
+    AV* linear_av;
+    SV** linear_svp;
+    SV* linear_sv;
+    HV* curstash;
+    GV* candidate = NULL;
+    CV* cand_cv = NULL;
+    const char *hvname;
+    I32 items;
+    struct mro_meta* selfmeta;
+    HV* nmcache;
+    HE* cache_entry;
+
+    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");
+
+    cxix = __dopoptosub_at(cxstack, cxstack_ix);
+
+    /* 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 */
+    for (;;) {
+        /* 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;
+    }
+
+    /* If we made it to here, we found our context */
+
+    selfmeta = HvMROMETA(selfstash);
+    if(!(nmcache = selfmeta->mro_nextmethod)) {
+        nmcache = selfmeta->mro_nextmethod = newHV();
+    }
+
+    if((cache_entry = hv_fetch_ent(nmcache, sv, 0, 0))) {
+        SV* val = HeVAL(cache_entry);
+        if(val == &PL_sv_undef) {
+            if(throw_nomethod)
+                Perl_croak(aTHX_ "No next::method '%s' found for %s", subname, hvname);
+        }
+        return val;
+    }
+
+    /* 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);
+    items = AvFILLp(linear_av) + 1;
+
+    while (items--) {
+        linear_sv = *linear_svp++;
+        assert(linear_sv);
+        if(sv_eq(linear_sv, stashname))
+            break;
+    }
+
+    if(items > 0) {
+        while (items--) {
+            linear_sv = *linear_svp++;
+            assert(linear_sv);
+            curstash = gv_stashsv(linear_sv, FALSE);
+
+            if (!curstash || (HvMROMETA(curstash)->fake && !HvFILL(curstash))) {
+                if (ckWARN(WARN_MISC))
+                    Perl_warner(aTHX_ packWARN(WARN_MISC), "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);
+            if (SvTYPE(candidate) == SVt_PVGV && (cand_cv = GvCV(candidate)) && !GvCVGEN(candidate)) {
+                SvREFCNT_inc_simple_void_NN((SV*)cand_cv);
+                hv_store_ent(nmcache, newSVsv(sv), (SV*)cand_cv, 0);
+                return (SV*)cand_cv;
+            }
+        }
+    }
+
+    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);
+    return &PL_sv_undef;
+}
+
+#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_get_global_sub_generation);
+XS(XS_mro_invalidate_all_method_caches);
+XS(XS_mro_get_sub_generation);
+XS(XS_mro_method_changed_in);
+XS(XS_next_can);
+XS(XS_next_method);
+XS(XS_maybe_next_method);
+
+void
+Perl_boot_core_mro(pTHX)
+{
+    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::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::method_changed_in", XS_mro_method_changed_in, file, "$");
+    newXS("next::can", XS_next_can, file);
+    newXS("next::method", XS_next_method, file);
+    newXS("maybe::next::method", XS_maybe_next_method, file);
+}
+
+XS(XS_mro_get_linear_isa) {
+    dVAR;
+    dXSARGS;
+    AV* RETVAL;
+    HV* class_stash;
+    SV* classname;
+
+    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) Perl_croak(aTHX_ "No such class: '%"SVf"'!", SVfARG(classname));
+
+    if(items > 1) {
+        char* which = SvPV_nolen(ST(1));
+        if(strEQ(which, "dfs"))
+            RETVAL = mro_get_linear_isa_dfs(class_stash, 0);
+        else if(strEQ(which, "c3"))
+            RETVAL = mro_get_linear_isa_c3(class_stash, 0);
+        else
+            Perl_croak(aTHX_ "Invalid mro name: '%s'", which);
+    }
+    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;
+    char* whichstr;
+    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);
+
+    if(strEQ(whichstr, "dfs"))
+        which = MRO_DFS;
+    else if(strEQ(whichstr, "c3"))
+        which = MRO_C3;
+    else
+        Perl_croak(aTHX_ "Invalid mro name: '%s'", whichstr);
+
+    if(meta->mro_which != which) {
+        meta->mro_which = which;
+        /* Only affects local method cache, not
+           even child classes */
+        meta->sub_generation++;
+        if(meta->mro_nextmethod)
+            hv_clear(meta->mro_nextmethod);
+    }
+
+    XSRETURN_EMPTY;
+}
+
+
+XS(XS_mro_get_mro)
+{
+    dVAR;
+    dXSARGS;
+    SV* classname;
+    HV* class_stash;
+    struct mro_meta* meta;
+
+    PERL_UNUSED_ARG(cv);
+
+    if (items != 1)
+       Perl_croak(aTHX_ "Usage: mro::get_mro(classname)");
+
+    classname = ST(0);
+    class_stash = gv_stashsv(classname, 0);
+    if(!class_stash) Perl_croak(aTHX_ "No such class: '%"SVf"'!", SVfARG(classname));
+    meta = HvMROMETA(class_stash);
+
+    if(meta->mro_which == MRO_DFS)
+        ST(0) = sv_2mortal(newSVpvn("dfs", 3));
+    else
+        ST(0) = sv_2mortal(newSVpvn("c3", 2));
+
+    XSRETURN(1);
+}
+
+XS(XS_mro_get_isarev)
+{
+    dVAR;
+    dXSARGS;
+    SV* classname;
+    HV* class_stash;
+    HV* isarev;
+
+    PERL_UNUSED_ARG(cv);
+
+    if (items != 1)
+       Perl_croak(aTHX_ "Usage: mro::get_isarev(classname)");
+
+    classname = ST(0);
+
+    class_stash = gv_stashsv(classname, 0);
+    if(!class_stash) Perl_croak(aTHX_ "No such class: '%"SVf"'!", SVfARG(classname));
+
+    SP -= items;
+   
+    if((isarev = HvMROMETA(class_stash)->mro_isarev)) {
+        HE* iter;
+        hv_iterinit(isarev);
+        while((iter = hv_iternext(isarev)))
+            XPUSHs(hv_iterkeysv(iter));
+    }
+
+    PUTBACK;
+    return;
+}
+
+XS(XS_mro_is_universal)
+{
+    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);
+    if(!class_stash) Perl_croak(aTHX_ "No such class: '%"SVf"'!", SVfARG(classname));
+
+    HvMROMETA(class_stash)->is_universal
+        ? XSRETURN_YES
+        : 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)
+{
+    dVAR;
+    dXSARGS;
+
+    PERL_UNUSED_ARG(cv);
+
+    if (items != 0)
+        Perl_croak(aTHX_ "Usage: mro::invalidate_all_method_caches()");
+
+    PL_sub_generation++;
+
+    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;
+    dXSARGS;
+    SV* classname;
+    HV* class_stash;
+
+    PERL_UNUSED_ARG(cv);
+
+    if(items != 1)
+        Perl_croak(aTHX_ "Usage: mro::method_changed_in(classname)");
+    
+    classname = ST(0);
+
+    class_stash = gv_stashsv(classname, 0);
+    if(!class_stash) Perl_croak(aTHX_ "No such class: '%"SVf"'!", SVfARG(classname));
+
+    mro_method_changed_in(class_stash);
+
+    XSRETURN_EMPTY;
+}
+
+XS(XS_next_can)
+{
+    dVAR;
+    dXSARGS;
+    SV* self = ST(0);
+    SV* methcv = __nextcan(aTHX_ self, 0);
+
+    PERL_UNUSED_ARG(cv);
+    PERL_UNUSED_VAR(items);
+
+    if(methcv == &PL_sv_undef) {
+        ST(0) = &PL_sv_undef;
+    }
+    else {
+        ST(0) = sv_2mortal(newRV_inc(methcv));
+    }
+
+    XSRETURN(1);
+}
+
+XS(XS_next_method)
+{
+    dMARK;
+    dAX;
+    SV* self = ST(0);
+    SV* methcv = __nextcan(aTHX_ self, 1);
+
+    PERL_UNUSED_ARG(cv);
+
+    PL_markstack_ptr++;
+    call_sv(methcv, GIMME_V);
+}
+
+XS(XS_maybe_next_method)
+{
+    dMARK;
+    dAX;
+    SV* self = ST(0);
+    SV* methcv = __nextcan(aTHX_ self, 0);
+
+    PERL_UNUSED_ARG(cv);
+
+    if(methcv == &PL_sv_undef) {
+        ST(0) = &PL_sv_undef;
+        XSRETURN(1);
+    }
+
+    PL_markstack_ptr++;
+    call_sv(methcv, GIMME_V);
+}
+
+/*
+ * Local variables:
+ * c-indentation-style: bsd
+ * c-basic-offset: 4
+ * indent-tabs-mode: t
+ * End:
+ *
+ * ex: set ts=8 sts=4 sw=4 noet:
+ */