No evident need for 'for' loop in assignment from $args{filename}.
[perl.git] / mro.c
1 /*    mro.c
2  *
3  *    Copyright (c) 2007 Brandon L Black
4  *    Copyright (c) 2007, 2008 Larry Wall and others
5  *
6  *    You may distribute under the terms of either the GNU General Public
7  *    License or the Artistic License, as specified in the README file.
8  *
9  */
10
11 /*
12  * 'Which order shall we go in?' said Frodo.  'Eldest first, or quickest first?
13  *  You'll be last either way, Master Peregrin.'
14  *
15  *     [p.101 of _The Lord of the Rings_, I/iii: "A Conspiracy Unmasked"]
16  */
17
18 /*
19 =head1 MRO Functions
20
21 These functions are related to the method resolution order of perl classes
22
23 =cut
24 */
25
26 #include "EXTERN.h"
27 #define PERL_IN_MRO_C
28 #include "perl.h"
29
30 static const struct mro_alg dfs_alg =
31     {S_mro_get_linear_isa_dfs, "dfs", 3, 0, 0};
32
33 SV *
34 Perl_mro_get_private_data(pTHX_ struct mro_meta *const smeta,
35                           const struct mro_alg *const which)
36 {
37     SV **data;
38     PERL_ARGS_ASSERT_MRO_GET_PRIVATE_DATA;
39
40     data = (SV **)Perl_hv_common(aTHX_ smeta->mro_linear_all, NULL,
41                                  which->name, which->length, which->kflags,
42                                  HV_FETCH_JUST_SV, NULL, which->hash);
43     if (!data)
44         return NULL;
45
46     /* If we've been asked to look up the private data for the current MRO, then
47        cache it.  */
48     if (smeta->mro_which == which)
49         smeta->mro_linear_current = *data;
50
51     return *data;
52 }
53
54 SV *
55 Perl_mro_set_private_data(pTHX_ struct mro_meta *const smeta,
56                           const struct mro_alg *const which, SV *const data)
57 {
58     PERL_ARGS_ASSERT_MRO_SET_PRIVATE_DATA;
59
60     if (!smeta->mro_linear_all) {
61         if (smeta->mro_which == which) {
62             /* If all we need to store is the current MRO's data, then don't use
63                memory on a hash with 1 element - store it direct, and signal
64                this by leaving the would-be-hash NULL.  */
65             smeta->mro_linear_current = data;
66             return data;
67         } else {
68             HV *const hv = newHV();
69             /* Start with 2 buckets. It's unlikely we'll need more. */
70             HvMAX(hv) = 1;      
71             smeta->mro_linear_all = hv;
72
73             if (smeta->mro_linear_current) {
74                 /* If we were storing something directly, put it in the hash
75                    before we lose it. */
76                 Perl_mro_set_private_data(aTHX_ smeta, smeta->mro_which, 
77                                           smeta->mro_linear_current);
78             }
79         }
80     }
81
82     /* We get here if we're storing more than one linearisation for this stash,
83        or the linearisation we are storing is not that if its current MRO.  */
84
85     if (smeta->mro_which == which) {
86         /* If we've been asked to store the private data for the current MRO,
87            then cache it.  */
88         smeta->mro_linear_current = data;
89     }
90
91     if (!Perl_hv_common(aTHX_ smeta->mro_linear_all, NULL,
92                         which->name, which->length, which->kflags,
93                         HV_FETCH_ISSTORE, data, which->hash)) {
94         Perl_croak(aTHX_ "panic: hv_store() failed in set_mro_private_data() "
95                    "for '%.*s' %d", (int) which->length, which->name,
96                    which->kflags);
97     }
98
99     return data;
100 }
101
102 const struct mro_alg *
103 Perl_mro_get_from_name(pTHX_ SV *name) {
104     SV **data;
105
106     PERL_ARGS_ASSERT_MRO_GET_FROM_NAME;
107
108     data = (SV **)Perl_hv_common(aTHX_ PL_registered_mros, name, NULL, 0, 0,
109                                  HV_FETCH_JUST_SV, NULL, 0);
110     if (!data)
111         return NULL;
112     assert(SvTYPE(*data) == SVt_IV);
113     assert(SvIOK(*data));
114     return INT2PTR(const struct mro_alg *, SvUVX(*data));
115 }
116
117 void
118 Perl_mro_register(pTHX_ const struct mro_alg *mro) {
119     SV *wrapper = newSVuv(PTR2UV(mro));
120
121     PERL_ARGS_ASSERT_MRO_REGISTER;
122
123     
124     if (!Perl_hv_common(aTHX_ PL_registered_mros, NULL,
125                         mro->name, mro->length, mro->kflags,
126                         HV_FETCH_ISSTORE, wrapper, mro->hash)) {
127         SvREFCNT_dec(wrapper);
128         Perl_croak(aTHX_ "panic: hv_store() failed in mro_register() "
129                    "for '%.*s' %d", (int) mro->length, mro->name, mro->kflags);
130     }
131 }
132
133 struct mro_meta*
134 Perl_mro_meta_init(pTHX_ HV* stash)
135 {
136     struct mro_meta* newmeta;
137
138     PERL_ARGS_ASSERT_MRO_META_INIT;
139     assert(HvAUX(stash));
140     assert(!(HvAUX(stash)->xhv_mro_meta));
141     Newxz(newmeta, 1, struct mro_meta);
142     HvAUX(stash)->xhv_mro_meta = newmeta;
143     newmeta->cache_gen = 1;
144     newmeta->pkg_gen = 1;
145     newmeta->mro_which = &dfs_alg;
146
147     return newmeta;
148 }
149
150 #if defined(USE_ITHREADS)
151
152 /* for sv_dup on new threads */
153 struct mro_meta*
154 Perl_mro_meta_dup(pTHX_ struct mro_meta* smeta, CLONE_PARAMS* param)
155 {
156     struct mro_meta* newmeta;
157
158     PERL_ARGS_ASSERT_MRO_META_DUP;
159
160     Newx(newmeta, 1, struct mro_meta);
161     Copy(smeta, newmeta, 1, struct mro_meta);
162
163     if (newmeta->mro_linear_all) {
164         newmeta->mro_linear_all
165             = MUTABLE_HV(sv_dup_inc((const SV *)newmeta->mro_linear_all, param));
166         /* This is just acting as a shortcut pointer, and will be automatically
167            updated on the first get.  */
168         newmeta->mro_linear_current = NULL;
169     } else if (newmeta->mro_linear_current) {
170         /* Only the current MRO is stored, so this owns the data.  */
171         newmeta->mro_linear_current
172             = sv_dup_inc((const SV *)newmeta->mro_linear_current, param);
173     }
174
175     if (newmeta->mro_nextmethod)
176         newmeta->mro_nextmethod
177             = MUTABLE_HV(sv_dup_inc((const SV *)newmeta->mro_nextmethod, param));
178     if (newmeta->isa)
179         newmeta->isa
180             = MUTABLE_HV(sv_dup_inc((const SV *)newmeta->isa, param));
181
182     return newmeta;
183 }
184
185 #endif /* USE_ITHREADS */
186
187 /*
188 =for apidoc mro_get_linear_isa_dfs
189
190 Returns the Depth-First Search linearization of @ISA
191 the given stash.  The return value is a read-only AV*.
192 C<level> should be 0 (it is used internally in this
193 function's recursion).
194
195 You are responsible for C<SvREFCNT_inc()> on the
196 return value if you plan to store it anywhere
197 semi-permanently (otherwise it might be deleted
198 out from under you the next time the cache is
199 invalidated).
200
201 =cut
202 */
203 static AV*
204 S_mro_get_linear_isa_dfs(pTHX_ HV *stash, U32 level)
205 {
206     AV* retval;
207     GV** gvp;
208     GV* gv;
209     AV* av;
210     const HEK* stashhek;
211     struct mro_meta* meta;
212     SV *our_name;
213     HV *stored = NULL;
214
215     PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA_DFS;
216     assert(HvAUX(stash));
217
218     stashhek
219      = HvAUX(stash)->xhv_name_u.xhvnameu_name && HvENAME_HEK_NN(stash)
220         ? HvENAME_HEK_NN(stash)
221         : HvNAME_HEK(stash);
222
223     if (!stashhek)
224       Perl_croak(aTHX_ "Can't linearize anonymous symbol table");
225
226     if (level > 100)
227         Perl_croak(aTHX_ "Recursive inheritance detected in package '%s'",
228                    HEK_KEY(stashhek));
229
230     meta = HvMROMETA(stash);
231
232     /* return cache if valid */
233     if((retval = MUTABLE_AV(MRO_GET_PRIVATE_DATA(meta, &dfs_alg)))) {
234         return retval;
235     }
236
237     /* not in cache, make a new one */
238
239     retval = MUTABLE_AV(sv_2mortal(MUTABLE_SV(newAV())));
240     /* We use this later in this function, but don't need a reference to it
241        beyond the end of this function, so reference count is fine.  */
242     our_name = newSVhek(stashhek);
243     av_push(retval, our_name); /* add ourselves at the top */
244
245     /* fetch our @ISA */
246     gvp = (GV**)hv_fetchs(stash, "ISA", FALSE);
247     av = (gvp && (gv = *gvp) && isGV_with_GP(gv)) ? GvAV(gv) : NULL;
248
249     /* "stored" is used to keep track of all of the classnames we have added to
250        the MRO so far, so we can do a quick exists check and avoid adding
251        duplicate classnames to the MRO as we go.
252        It's then retained to be re-used as a fast lookup for ->isa(), by adding
253        our own name and "UNIVERSAL" to it.  */
254
255     if(av && AvFILLp(av) >= 0) {
256
257         SV **svp = AvARRAY(av);
258         I32 items = AvFILLp(av) + 1;
259
260         /* foreach(@ISA) */
261         while (items--) {
262             SV* const sv = *svp++;
263             HV* const basestash = gv_stashsv(sv, 0);
264             SV *const *subrv_p;
265             I32 subrv_items;
266
267             if (!basestash) {
268                 /* if no stash exists for this @ISA member,
269                    simply add it to the MRO and move on */
270                 subrv_p = &sv;
271                 subrv_items = 1;
272             }
273             else {
274                 /* otherwise, recurse into ourselves for the MRO
275                    of this @ISA member, and append their MRO to ours.
276                    The recursive call could throw an exception, which
277                    has memory management implications here, hence the use of
278                    the mortal.  */
279                 const AV *const subrv
280                     = mro_get_linear_isa_dfs(basestash, level + 1);
281
282                 subrv_p = AvARRAY(subrv);
283                 subrv_items = AvFILLp(subrv) + 1;
284             }
285             if (stored) {
286                 while(subrv_items--) {
287                     SV *const subsv = *subrv_p++;
288                     /* LVALUE fetch will create a new undefined SV if necessary
289                      */
290                     HE *const he = hv_fetch_ent(stored, subsv, 1, 0);
291                     assert(he);
292                     if(HeVAL(he) != &PL_sv_undef) {
293                         /* It was newly created.  Steal it for our new SV, and
294                            replace it in the hash with the "real" thing.  */
295                         SV *const val = HeVAL(he);
296                         HEK *const key = HeKEY_hek(he);
297
298                         HeVAL(he) = &PL_sv_undef;
299                         /* Save copying by making a shared hash key scalar. We
300                            inline this here rather than calling
301                            Perl_newSVpvn_share because we already have the
302                            scalar, and we already have the hash key.  */
303                         assert(SvTYPE(val) == SVt_NULL);
304                         sv_upgrade(val, SVt_PV);
305                         SvPV_set(val, HEK_KEY(share_hek_hek(key)));
306                         SvCUR_set(val, HEK_LEN(key));
307                         SvREADONLY_on(val);
308                         SvFAKE_on(val);
309                         SvPOK_on(val);
310                         if (HEK_UTF8(key))
311                             SvUTF8_on(val);
312
313                         av_push(retval, val);
314                     }
315                 }
316             } else {
317                 /* We are the first (or only) parent. We can short cut the
318                    complexity above, because our @ISA is simply us prepended
319                    to our parent's @ISA, and our ->isa cache is simply our
320                    parent's, with our name added.  */
321                 /* newSVsv() is slow. This code is only faster if we can avoid
322                    it by ensuring that SVs in the arrays are shared hash key
323                    scalar SVs, because we can "copy" them very efficiently.
324                    Although to be fair, we can't *ensure* this, as a reference
325                    to the internal array is returned by mro::get_linear_isa(),
326                    so we'll have to be defensive just in case someone faffed
327                    with it.  */
328                 if (basestash) {
329                     SV **svp;
330                     stored = MUTABLE_HV(sv_2mortal((SV*)newHVhv(HvMROMETA(basestash)->isa)));
331                     av_extend(retval, subrv_items);
332                     AvFILLp(retval) = subrv_items;
333                     svp = AvARRAY(retval);
334                     while(subrv_items--) {
335                         SV *const val = *subrv_p++;
336                         *++svp = SvIsCOW_shared_hash(val)
337                             ? newSVhek(SvSHARED_HEK_FROM_PV(SvPVX(val)))
338                             : newSVsv(val);
339                     }
340                 } else {
341                     /* They have no stash.  So create ourselves an ->isa cache
342                        as if we'd copied it from what theirs should be.  */
343                     stored = MUTABLE_HV(sv_2mortal(MUTABLE_SV(newHV())));
344                     (void) hv_store(stored, "UNIVERSAL", 9, &PL_sv_undef, 0);
345                     av_push(retval,
346                             newSVhek(HeKEY_hek(hv_store_ent(stored, sv,
347                                                             &PL_sv_undef, 0))));
348                 }
349             }
350         }
351     } else {
352         /* We have no parents.  */
353         stored = MUTABLE_HV(sv_2mortal(MUTABLE_SV(newHV())));
354         (void) hv_store(stored, "UNIVERSAL", 9, &PL_sv_undef, 0);
355     }
356
357     (void) hv_store_ent(stored, our_name, &PL_sv_undef, 0);
358
359     SvREFCNT_inc_simple_void_NN(stored);
360     SvTEMP_off(stored);
361     SvREADONLY_on(stored);
362
363     meta->isa = stored;
364
365     /* now that we're past the exception dangers, grab our own reference to
366        the AV we're about to use for the result. The reference owned by the
367        mortals' stack will be released soon, so everything will balance.  */
368     SvREFCNT_inc_simple_void_NN(retval);
369     SvTEMP_off(retval);
370
371     /* we don't want anyone modifying the cache entry but us,
372        and we do so by replacing it completely */
373     SvREADONLY_on(retval);
374
375     return MUTABLE_AV(Perl_mro_set_private_data(aTHX_ meta, &dfs_alg,
376                                                 MUTABLE_SV(retval)));
377 }
378
379 /*
380 =for apidoc mro_get_linear_isa
381
382 Returns either C<mro_get_linear_isa_c3> or
383 C<mro_get_linear_isa_dfs> for the given stash,
384 dependant upon which MRO is in effect
385 for that stash.  The return value is a
386 read-only AV*.
387
388 You are responsible for C<SvREFCNT_inc()> on the
389 return value if you plan to store it anywhere
390 semi-permanently (otherwise it might be deleted
391 out from under you the next time the cache is
392 invalidated).
393
394 =cut
395 */
396 AV*
397 Perl_mro_get_linear_isa(pTHX_ HV *stash)
398 {
399     struct mro_meta* meta;
400     AV *isa;
401
402     PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA;
403     if(!SvOOK(stash))
404         Perl_croak(aTHX_ "Can't linearize anonymous symbol table");
405
406     meta = HvMROMETA(stash);
407     if (!meta->mro_which)
408         Perl_croak(aTHX_ "panic: invalid MRO!");
409     isa = meta->mro_which->resolve(aTHX_ stash, 0);
410
411     if (!meta->isa) {
412             HV *const isa_hash = newHV();
413             /* Linearisation didn't build it for us, so do it here.  */
414             SV *const *svp = AvARRAY(isa);
415             SV *const *const svp_end = svp + AvFILLp(isa) + 1;
416             const HEK *canon_name = HvENAME_HEK(stash);
417             if (!canon_name) canon_name = HvNAME_HEK(stash);
418
419             while (svp < svp_end) {
420                 (void) hv_store_ent(isa_hash, *svp++, &PL_sv_undef, 0);
421             }
422
423             (void) hv_common(isa_hash, NULL, HEK_KEY(canon_name),
424                              HEK_LEN(canon_name), HEK_FLAGS(canon_name),
425                              HV_FETCH_ISSTORE, &PL_sv_undef,
426                              HEK_HASH(canon_name));
427             (void) hv_store(isa_hash, "UNIVERSAL", 9, &PL_sv_undef, 0);
428
429             SvREADONLY_on(isa_hash);
430
431             meta->isa = isa_hash;
432     }
433
434     return isa;
435 }
436
437 /*
438 =for apidoc mro_isa_changed_in
439
440 Takes the necessary steps (cache invalidations, mostly)
441 when the @ISA of the given package has changed.  Invoked
442 by the C<setisa> magic, should not need to invoke directly.
443
444 =cut
445 */
446
447 /* Macro to avoid repeating the code five times. */
448 #define CLEAR_LINEAR(mEta)                                     \
449     if (mEta->mro_linear_all) {                                 \
450         SvREFCNT_dec(MUTABLE_SV(mEta->mro_linear_all));          \
451         mEta->mro_linear_all = NULL;                              \
452         /* This is just acting as a shortcut pointer.  */          \
453         mEta->mro_linear_current = NULL;                            \
454     } else if (mEta->mro_linear_current) {                           \
455         /* Only the current MRO is stored, so this owns the data.  */ \
456         SvREFCNT_dec(mEta->mro_linear_current);                        \
457         mEta->mro_linear_current = NULL;                                \
458     }
459
460 void
461 Perl_mro_isa_changed_in(pTHX_ HV* stash)
462 {
463     dVAR;
464     HV* isarev;
465     AV* linear_mro;
466     HE* iter;
467     SV** svp;
468     I32 items;
469     bool is_universal;
470     struct mro_meta * meta;
471     HV *isa = NULL;
472
473     const char * const stashname = HvENAME_get(stash);
474     const STRLEN stashname_len = HvENAMELEN_get(stash);
475
476     PERL_ARGS_ASSERT_MRO_ISA_CHANGED_IN;
477
478     if(!stashname)
479         Perl_croak(aTHX_ "Can't call mro_isa_changed_in() on anonymous symbol table");
480
481
482     /* wipe out the cached linearizations for this stash */
483     meta = HvMROMETA(stash);
484     CLEAR_LINEAR(meta);
485     if (meta->isa) {
486         /* Steal it for our own purposes. */
487         isa = (HV *)sv_2mortal((SV *)meta->isa);
488         meta->isa = NULL;
489     }
490
491     /* Inc the package generation, since our @ISA changed */
492     meta->pkg_gen++;
493
494     /* Wipe the global method cache if this package
495        is UNIVERSAL or one of its parents */
496
497     svp = hv_fetch(PL_isarev, stashname, stashname_len, 0);
498     isarev = svp ? MUTABLE_HV(*svp) : NULL;
499
500     if((stashname_len == 9 && strEQ(stashname, "UNIVERSAL"))
501         || (isarev && hv_exists(isarev, "UNIVERSAL", 9))) {
502         PL_sub_generation++;
503         is_universal = TRUE;
504     }
505     else { /* Wipe the local method cache otherwise */
506         meta->cache_gen++;
507         is_universal = FALSE;
508     }
509
510     /* wipe next::method cache too */
511     if(meta->mro_nextmethod) hv_clear(meta->mro_nextmethod);
512
513     /* Iterate the isarev (classes that are our children),
514        wiping out their linearization, method and isa caches
515        and upating PL_isarev. */
516     if(isarev) {
517         HV *isa_hashes = NULL;
518
519        /* We have to iterate through isarev twice to avoid a chicken and
520         * egg problem: if A inherits from B and both are in isarev, A might
521         * be processed before B and use B’s previous linearisation.
522         */
523
524        /* First iteration: Wipe everything, but stash away the isa hashes
525         * since we still need them for updating PL_isarev.
526         */
527
528         if(hv_iterinit(isarev)) {
529             /* Only create the hash if we need it; i.e., if isarev has
530                any elements. */
531             isa_hashes = (HV *)sv_2mortal((SV *)newHV());
532         }
533         while((iter = hv_iternext(isarev))) {
534             I32 len;
535             const char* const revkey = hv_iterkey(iter, &len);
536             HV* revstash = gv_stashpvn(revkey, len, 0);
537             struct mro_meta* revmeta;
538
539             if(!revstash) continue;
540             revmeta = HvMROMETA(revstash);
541             CLEAR_LINEAR(revmeta);
542             if(!is_universal)
543                 revmeta->cache_gen++;
544             if(revmeta->mro_nextmethod)
545                 hv_clear(revmeta->mro_nextmethod);
546
547             (void)
548               hv_store(
549                isa_hashes, (const char*)&revstash, sizeof(HV *),
550                revmeta->isa ? (SV *)revmeta->isa : &PL_sv_undef, 0
551               );
552             revmeta->isa = NULL;
553         }
554
555        /* Second pass: Update PL_isarev. We can just use isa_hashes to
556         * avoid another round of stash lookups. */
557
558        /* isarev might be deleted from PL_isarev during this loop, so hang
559         * on to it. */
560         SvREFCNT_inc_simple_void_NN(sv_2mortal((SV *)isarev));
561
562         if(isa_hashes) {
563             hv_iterinit(isa_hashes);
564             while((iter = hv_iternext(isa_hashes))) {
565                 HV* const revstash = *(HV **)HEK_KEY(HeKEY_hek(iter));
566                 HV * const isa = (HV *)HeVAL(iter);
567                 const HEK *namehek;
568
569                 /* We're starting at the 2nd element, skipping revstash */
570                 linear_mro = mro_get_linear_isa(revstash);
571                 svp = AvARRAY(linear_mro) + 1;
572                 items = AvFILLp(linear_mro);
573
574                 namehek = HvENAME_HEK(revstash);
575                 if (!namehek) namehek = HvNAME_HEK(revstash);
576
577                 while (items--) {
578                     SV* const sv = *svp++;
579                     HV* mroisarev;
580
581                     HE *he = hv_fetch_ent(PL_isarev, sv, TRUE, 0);
582
583                     /* That fetch should not fail.  But if it had to create
584                        a new SV for us, then will need to upgrade it to an
585                        HV (which sv_upgrade() can now do for us). */
586
587                     mroisarev = MUTABLE_HV(HeVAL(he));
588
589                     SvUPGRADE(MUTABLE_SV(mroisarev), SVt_PVHV);
590
591                     /* This hash only ever contains PL_sv_yes. Storing it
592                        over itself is almost as cheap as calling hv_exists,
593                        so on aggregate we expect to save time by not making
594                        two calls to the common HV code for the case where
595                        it doesn't exist.  */
596            
597                     (void)
598                       hv_store(
599                        mroisarev, HEK_KEY(namehek), HEK_LEN(namehek),
600                        &PL_sv_yes, 0
601                       );
602                 }
603
604                 if((SV *)isa != &PL_sv_undef)
605                     mro_clean_isarev(
606                      isa, HEK_KEY(namehek), HEK_LEN(namehek),
607                      HvMROMETA(revstash)->isa
608                     );
609             }
610         }
611     }
612
613     /* Now iterate our MRO (parents), adding ourselves and everything from
614        our isarev to their isarev.
615     */
616
617     /* We're starting at the 2nd element, skipping ourselves here */
618     linear_mro = mro_get_linear_isa(stash);
619     svp = AvARRAY(linear_mro) + 1;
620     items = AvFILLp(linear_mro);
621
622     while (items--) {
623         SV* const sv = *svp++;
624         HV* mroisarev;
625
626         HE *he = hv_fetch_ent(PL_isarev, sv, TRUE, 0);
627
628         /* That fetch should not fail.  But if it had to create a new SV for
629            us, then will need to upgrade it to an HV (which sv_upgrade() can
630            now do for us. */
631
632         mroisarev = MUTABLE_HV(HeVAL(he));
633
634         SvUPGRADE(MUTABLE_SV(mroisarev), SVt_PVHV);
635
636         /* This hash only ever contains PL_sv_yes. Storing it over itself is
637            almost as cheap as calling hv_exists, so on aggregate we expect to
638            save time by not making two calls to the common HV code for the
639            case where it doesn't exist.  */
640            
641         (void)hv_store(mroisarev, stashname, stashname_len, &PL_sv_yes, 0);
642     }
643
644     /* Delete our name from our former parents’ isarevs. */
645     if(isa && HvARRAY(isa))
646         mro_clean_isarev(isa, stashname, stashname_len, meta->isa);
647 }
648
649 /* Deletes name from all the isarev entries listed in isa */
650 STATIC void
651 S_mro_clean_isarev(pTHX_ HV * const isa, const char * const name,
652                          const STRLEN len, HV * const exceptions)
653 {
654     HE* iter;
655
656     PERL_ARGS_ASSERT_MRO_CLEAN_ISAREV;
657
658     /* Delete our name from our former parents’ isarevs. */
659     if(isa && HvARRAY(isa) && hv_iterinit(isa)) {
660         SV **svp;
661         while((iter = hv_iternext(isa))) {
662             I32 klen;
663             const char * const key = hv_iterkey(iter, &klen);
664             if(exceptions && hv_exists(exceptions, key, klen)) continue;
665             svp = hv_fetch(PL_isarev, key, klen, 0);
666             if(svp) {
667                 HV * const isarev = (HV *)*svp;
668                 (void)hv_delete(isarev, name, len, G_DISCARD);
669                 if(!HvARRAY(isarev) || !HvUSEDKEYS(isarev))
670                     (void)hv_delete(PL_isarev, key, klen, G_DISCARD);
671             }
672         }
673     }
674 }
675
676 /*
677 =for apidoc mro_package_moved
678
679 Call this function to signal to a stash that it has been assigned to
680 another spot in the stash hierarchy. C<stash> is the stash that has been
681 assigned. C<oldstash> is the stash it replaces, if any. C<gv> is the glob
682 that is actually being assigned to.
683
684 This can also be called with a null first argument to
685 indicate that C<oldstash> has been deleted.
686
687 This function invalidates isa caches on the old stash, on all subpackages
688 nested inside it, and on the subclasses of all those, including
689 non-existent packages that have corresponding entries in C<stash>.
690
691 It also sets the effective names (C<HvENAME>) on all the stashes as
692 appropriate.
693
694 If the C<gv> is present and is not in the symbol table, then this function
695 simply returns. This checked will be skipped if C<flags & 1>.
696
697 =cut
698 */
699 void
700 Perl_mro_package_moved(pTHX_ HV * const stash, HV * const oldstash,
701                        const GV * const gv, U32 flags)
702 {
703     SV *namesv;
704     HEK **namep;
705     I32 name_count;
706     HV *stashes;
707     HE* iter;
708
709     PERL_ARGS_ASSERT_MRO_PACKAGE_MOVED;
710     assert(stash || oldstash);
711
712     /* Determine the name(s) of the location that stash was assigned to
713      * or from which oldstash was removed.
714      *
715      * We cannot reliably use the name in oldstash, because it may have
716      * been deleted from the location in the symbol table that its name
717      * suggests, as in this case:
718      *
719      *   $globref = \*foo::bar::;
720      *   Symbol::delete_package("foo");
721      *   *$globref = \%baz::;
722      *   *$globref = *frelp::;
723      *      # calls mro_package_moved(%frelp::, %baz::, *$globref, NULL, 0)
724      *
725      * So we get it from the gv. But, since the gv may no longer be in the
726      * symbol table, we check that first. The only reliable way to tell is
727      * to see whether its stash has an effective name and whether the gv
728      * resides in that stash under its name. That effective name may be
729      * different from what gv_fullname4 would use.
730      * If flags & 1, the caller has asked us to skip the check.
731      */
732     if(!(flags & 1)) {
733         SV **svp;
734         if(
735          !GvSTASH(gv) || !HvENAME(GvSTASH(gv)) ||
736          !(svp = hv_fetch(GvSTASH(gv), GvNAME(gv), GvNAMELEN(gv), 0)) ||
737          *svp != (SV *)gv
738         ) return;
739     }
740     assert(SvOOK(GvSTASH(gv)));
741     assert(GvNAMELEN(gv));
742     assert(GvNAME(gv)[GvNAMELEN(gv) - 1] == ':');
743     assert(GvNAMELEN(gv) == 1 || GvNAME(gv)[GvNAMELEN(gv) - 2] == ':');
744     name_count = HvAUX(GvSTASH(gv))->xhv_name_count;
745     if (!name_count) {
746         name_count = 1;
747         namep = &HvAUX(GvSTASH(gv))->xhv_name_u.xhvnameu_name;
748     }
749     else {
750         namep = HvAUX(GvSTASH(gv))->xhv_name_u.xhvnameu_names;
751         if (name_count < 0) ++namep, name_count = -name_count - 1;
752     }
753     if (name_count == 1) {
754         if (HEK_LEN(*namep) == 4 && strnEQ(HEK_KEY(*namep), "main", 4)) {
755             namesv = GvNAMELEN(gv) == 1
756                 ? newSVpvs_flags(":", SVs_TEMP)
757                 : newSVpvs_flags("",  SVs_TEMP);
758         }
759         else {
760             namesv = sv_2mortal(newSVhek(*namep));
761             if (GvNAMELEN(gv) == 1) sv_catpvs(namesv, ":");
762             else                    sv_catpvs(namesv, "::");
763         }
764         if (GvNAMELEN(gv) != 1)
765             sv_catpvn(namesv, GvNAME(gv), GvNAMELEN(gv) - 2);
766                                           /* skip trailing :: */
767     }
768     else {
769         SV *aname;
770         namesv = sv_2mortal((SV *)newAV());
771         while (name_count--) {
772             if(HEK_LEN(*namep) == 4 && strnEQ(HEK_KEY(*namep), "main", 4)){
773                 aname = GvNAMELEN(gv) == 1
774                          ? newSVpvs(":")
775                          : newSVpvs("");
776                 namep++;
777             }
778             else {
779                 aname = newSVhek(*namep++);
780                 if (GvNAMELEN(gv) == 1) sv_catpvs(aname, ":");
781                 else                    sv_catpvs(aname, "::");
782             }
783             if (GvNAMELEN(gv) != 1)
784                 sv_catpvn(aname, GvNAME(gv), GvNAMELEN(gv) - 2);
785                                           /* skip trailing :: */
786             av_push((AV *)namesv, aname);
787         }
788     }
789
790     /* Get a list of all the affected classes. */
791     /* We cannot simply pass them all to mro_isa_changed_in to avoid
792        the list, as that function assumes that only one package has
793        changed. It does not work with:
794
795           @foo::ISA = qw( B B::B );
796           *B:: = delete $::{"A::"};
797
798        as neither B nor B::B can be updated before the other, since they
799        will reset caches on foo, which will see either B or B::B with the
800        wrong name. The names must be set on *all* affected stashes before
801        we do anything else. (And linearisations must be cleared, too.)
802      */
803     stashes = (HV *) sv_2mortal((SV *)newHV());
804     mro_gather_and_rename(
805      stashes, (HV *) sv_2mortal((SV *)newHV()),
806      stash, oldstash, namesv
807     );
808
809     /* Once the caches have been wiped on all the classes, call
810        mro_isa_changed_in on each. */
811     hv_iterinit(stashes);
812     while((iter = hv_iternext(stashes))) {
813         HV * const stash = *(HV **)HEK_KEY(HeKEY_hek(iter));
814         if(HvENAME(stash)) {
815             /* We have to restore the original meta->isa (that
816                mro_gather_and_rename set aside for us) this way, in case
817                one class in this list is a superclass of a another class
818                that we have already encountered. In such a case, meta->isa
819                will have been overwritten without old entries being deleted 
820                from PL_isarev. */
821             struct mro_meta * const meta = HvMROMETA(stash);
822             if(meta->isa != (HV *)HeVAL(iter)){
823                 SvREFCNT_dec(meta->isa);
824                 meta->isa
825                  = HeVAL(iter) == &PL_sv_yes
826                     ? NULL
827                     : (HV *)HeVAL(iter);
828                 HeVAL(iter) = NULL; /* We donated our reference count. */
829             }
830             mro_isa_changed_in(stash);
831         }
832     }
833 }
834
835 void
836 S_mro_gather_and_rename(pTHX_ HV * const stashes, HV * const seen_stashes,
837                               HV *stash, HV *oldstash, SV *namesv)
838 {
839     register XPVHV* xhv;
840     register HE *entry;
841     I32 riter = -1;
842     I32 items = 0;
843     const bool stash_had_name = stash && HvENAME(stash);
844     bool fetched_isarev = FALSE;
845     HV *seen = NULL;
846     HV *isarev = NULL;
847     SV **svp = NULL;
848
849     PERL_ARGS_ASSERT_MRO_GATHER_AND_RENAME;
850
851     /* We use the seen_stashes hash to keep track of which packages have
852        been encountered so far. This must be separate from the main list of
853        stashes, as we need to distinguish between stashes being assigned
854        and stashes being replaced/deleted. (A nested stash can be on both
855        sides of an assignment. We cannot simply skip iterating through a
856        stash on the right if we have seen it on the left, as it will not
857        get its ename assigned to it.)
858
859        To avoid allocating extra SVs, instead of a bitfield we can make
860        bizarre use of immortals:
861
862         &PL_sv_undef:  seen on the left  (oldstash)
863         &PL_sv_no   :  seen on the right (stash)
864         &PL_sv_yes  :  seen on both sides
865
866      */
867
868     if(oldstash) {
869         /* Add to the big list. */
870         struct mro_meta * meta;
871         HE * const entry
872          = (HE *)
873              hv_common(
874               seen_stashes, NULL, (const char *)&oldstash, sizeof(HV *), 0,
875               HV_FETCH_LVALUE|HV_FETCH_EMPTY_HE, NULL, 0
876              );
877         if(HeVAL(entry) == &PL_sv_undef || HeVAL(entry) == &PL_sv_yes) {
878             oldstash = NULL;
879             goto check_stash;
880         }
881         HeVAL(entry)
882          = HeVAL(entry) == &PL_sv_no ? &PL_sv_yes : &PL_sv_undef;
883         meta = HvMROMETA(oldstash);
884         (void)
885           hv_store(
886            stashes, (const char *)&oldstash, sizeof(HV *),
887            meta->isa
888             ? SvREFCNT_inc_simple_NN((SV *)meta->isa)
889             : &PL_sv_yes,
890            0
891           );
892         CLEAR_LINEAR(meta);
893
894         /* Update the effective name. */
895         if(HvENAME_get(oldstash)) {
896             const HEK * const enamehek = HvENAME_HEK(oldstash);
897             if(SvTYPE(namesv) == SVt_PVAV) {
898                 items = AvFILLp((AV *)namesv) + 1;
899                 svp = AvARRAY((AV *)namesv);
900             }
901             else {
902                 items = 1;
903                 svp = &namesv;
904             }
905             while (items--) {
906                 STRLEN len;
907                 const char *name = SvPVx_const(*svp++, len);
908                 if(PL_stashcache)
909                     (void)hv_delete(PL_stashcache, name, len, G_DISCARD);
910                 hv_ename_delete(oldstash, name, len, 0);
911
912                 if (!fetched_isarev) {
913                     /* If the name deletion caused a name change, then we
914                      * are not going to call mro_isa_changed_in with this
915                      * name (and not at all if it has become anonymous) so
916                      * we need to delete old isarev entries here, both
917                      * those in the superclasses and this class’s own list
918                      * of subclasses. We simply delete the latter from
919                      * PL_isarev, since we still need it. hv_delete morti-
920                      * fies it for us, so sv_2mortal is not necessary. */
921                     if(HvENAME_HEK(oldstash) != enamehek) {
922                         if(meta->isa && HvARRAY(meta->isa))
923                             mro_clean_isarev(meta->isa, name, len, NULL);
924                         isarev = (HV *)hv_delete(PL_isarev, name, len, 0);
925                         fetched_isarev=TRUE;
926                     }
927                 }
928             }
929         }
930     }
931    check_stash:
932     if(stash) {
933         if(SvTYPE(namesv) == SVt_PVAV) {
934             items = AvFILLp((AV *)namesv) + 1;
935             svp = AvARRAY((AV *)namesv);
936         }
937         else {
938             items = 1;
939             svp = &namesv;
940         }
941         while (items--) {
942             STRLEN len;
943             const char *name = SvPVx_const(*svp++, len);
944             hv_ename_add(stash, name, len, 0);
945         }
946
947        /* Add it to the big list if it needs
948         * mro_isa_changed_in called on it. That happens if it was
949         * detached from the symbol table (so it had no HvENAME) before
950         * being assigned to the spot named by the ‘name’ variable, because
951         * its cached isa linearisation is now stale (the effective name
952         * having changed), and subclasses will then use that cache when
953         * mro_package_moved calls mro_isa_changed_in. (See
954         * [perl #77358].)
955         *
956         * If it did have a name, then its previous name is still
957         * used in isa caches, and there is no need for
958         * mro_package_moved to call mro_isa_changed_in.
959         */
960
961         entry
962          = (HE *)
963              hv_common(
964               seen_stashes, NULL, (const char *)&stash, sizeof(HV *), 0,
965               HV_FETCH_LVALUE|HV_FETCH_EMPTY_HE, NULL, 0
966              );
967         if(HeVAL(entry) == &PL_sv_yes || HeVAL(entry) == &PL_sv_no)
968             stash = NULL;
969         else {
970             HeVAL(entry)
971              = HeVAL(entry) == &PL_sv_undef ? &PL_sv_yes : &PL_sv_no;
972             if(!stash_had_name)
973             {
974                 struct mro_meta * const meta = HvMROMETA(stash);
975                 (void)
976                   hv_store(
977                    stashes, (const char *)&stash, sizeof(HV *),
978                    meta->isa
979                     ? SvREFCNT_inc_simple_NN((SV *)meta->isa)
980                     : &PL_sv_yes,
981                    0
982                   );
983                 CLEAR_LINEAR(meta);
984             }
985         }
986     }
987
988     if(!stash && !oldstash)
989         /* Both stashes have been encountered already. */
990         return;
991
992     /* Add all the subclasses to the big list. */
993     if(!fetched_isarev) {
994         /* If oldstash is not null, then we can use its HvENAME to look up
995            the isarev hash, since all its subclasses will be listed there.
996            It will always have an HvENAME. It the HvENAME was removed
997            above, then fetch_isarev will be true, and this code will not be
998            reached.
999
1000            If oldstash is null, then this is an empty spot with no stash in
1001            it, so subclasses could be listed in isarev hashes belonging to
1002            any of the names, so we have to check all of them.
1003          */
1004         assert(!oldstash || HvENAME(oldstash));
1005         if (oldstash) {
1006             /* Extra variable to avoid a compiler warning */
1007             char * const hvename = HvENAME(oldstash);
1008             fetched_isarev = TRUE;
1009             svp = hv_fetch(PL_isarev, hvename, HvENAMELEN_get(oldstash), 0);
1010             if (svp) isarev = MUTABLE_HV(*svp);
1011         }
1012         else if(SvTYPE(namesv) == SVt_PVAV) {
1013             items = AvFILLp((AV *)namesv) + 1;
1014             svp = AvARRAY((AV *)namesv);
1015         }
1016         else {
1017             items = 1;
1018             svp = &namesv;
1019         }
1020     }
1021     if(
1022         isarev || !fetched_isarev
1023     ) {
1024       while (fetched_isarev || items--) {
1025         HE *iter;
1026
1027         if (!fetched_isarev) {
1028             HE * const he = hv_fetch_ent(PL_isarev, *svp++, 0, 0);
1029             if (!he || !(isarev = MUTABLE_HV(HeVAL(he)))) continue;
1030         }
1031
1032         hv_iterinit(isarev);
1033         while((iter = hv_iternext(isarev))) {
1034             I32 len;
1035             const char* const revkey = hv_iterkey(iter, &len);
1036             HV* revstash = gv_stashpvn(revkey, len, 0);
1037             struct mro_meta * meta;
1038
1039             if(!revstash) continue;
1040             meta = HvMROMETA(revstash);
1041             (void)
1042               hv_store(
1043                stashes, (const char *)&revstash, sizeof(HV *),
1044                meta->isa
1045                 ? SvREFCNT_inc_simple_NN((SV *)meta->isa)
1046                 : &PL_sv_yes,
1047                0
1048               );
1049             CLEAR_LINEAR(meta);
1050         }
1051
1052         if (fetched_isarev) break;
1053       }
1054     }
1055
1056     /* This is partly based on code in hv_iternext_flags. We are not call-
1057        ing that here, as we want to avoid resetting the hash iterator. */
1058
1059     /* Skip the entire loop if the hash is empty.   */
1060     if(oldstash && HvUSEDKEYS(oldstash)) { 
1061         xhv = (XPVHV*)SvANY(oldstash);
1062         seen = (HV *) sv_2mortal((SV *)newHV());
1063
1064         /* Iterate through entries in the oldstash, adding them to the
1065            list, meanwhile doing the equivalent of $seen{$key} = 1.
1066          */
1067
1068         while (++riter <= (I32)xhv->xhv_max) {
1069             entry = (HvARRAY(oldstash))[riter];
1070
1071             /* Iterate through the entries in this list */
1072             for(; entry; entry = HeNEXT(entry)) {
1073                 const char* key;
1074                 I32 len;
1075
1076                 /* If this entry is not a glob, ignore it.
1077                    Try the next.  */
1078                 if (!isGV(HeVAL(entry))) continue;
1079
1080                 key = hv_iterkey(entry, &len);
1081                 if ((len > 1 && key[len-2] == ':' && key[len-1] == ':')
1082                  || (len == 1 && key[0] == ':')) {
1083                     HV * const oldsubstash = GvHV(HeVAL(entry));
1084                     SV ** const stashentry
1085                      = stash ? hv_fetch(stash, key, len, 0) : NULL;
1086                     HV *substash = NULL;
1087
1088                     /* Avoid main::main::main::... */
1089                     if(oldsubstash == oldstash) continue;
1090
1091                     if(
1092                         (
1093                             stashentry && *stashentry
1094                          && (substash = GvHV(*stashentry))
1095                         )
1096                      || (oldsubstash && HvENAME_get(oldsubstash))
1097                     )
1098                     {
1099                         /* Add :: and the key (minus the trailing ::)
1100                            to each name. */
1101                         SV *subname;
1102                         if(SvTYPE(namesv) == SVt_PVAV) {
1103                             SV *aname;
1104                             items = AvFILLp((AV *)namesv) + 1;
1105                             svp = AvARRAY((AV *)namesv);
1106                             subname = sv_2mortal((SV *)newAV());
1107                             while (items--) {
1108                                 aname = newSVsv(*svp++);
1109                                 if (len == 1)
1110                                     sv_catpvs(aname, ":");
1111                                 else {
1112                                     sv_catpvs(aname, "::");
1113                                     sv_catpvn(aname, key, len-2);
1114                                 }
1115                                 av_push((AV *)subname, aname);
1116                             }
1117                         }
1118                         else {
1119                             subname = sv_2mortal(newSVsv(namesv));
1120                             if (len == 1) sv_catpvs(subname, ":");
1121                             else {
1122                                 sv_catpvs(subname, "::");
1123                                 sv_catpvn(subname, key, len-2);
1124                             }
1125                         }
1126                         mro_gather_and_rename(
1127                              stashes, seen_stashes,
1128                              substash, oldsubstash, subname
1129                         );
1130                     }
1131
1132                     (void)hv_store(seen, key, len, &PL_sv_yes, 0);
1133                 }
1134             }
1135         }
1136     }
1137
1138     /* Skip the entire loop if the hash is empty.   */
1139     if (stash && HvUSEDKEYS(stash)) {
1140         xhv = (XPVHV*)SvANY(stash);
1141         riter = -1;
1142
1143         /* Iterate through the new stash, skipping $seen{$key} items,
1144            calling mro_gather_and_rename(stashes,seen,entry,NULL, ...). */
1145         while (++riter <= (I32)xhv->xhv_max) {
1146             entry = (HvARRAY(stash))[riter];
1147
1148             /* Iterate through the entries in this list */
1149             for(; entry; entry = HeNEXT(entry)) {
1150                 const char* key;
1151                 I32 len;
1152
1153                 /* If this entry is not a glob, ignore it.
1154                    Try the next.  */
1155                 if (!isGV(HeVAL(entry))) continue;
1156
1157                 key = hv_iterkey(entry, &len);
1158                 if ((len > 1 && key[len-2] == ':' && key[len-1] == ':')
1159                  || (len == 1 && key[0] == ':')) {
1160                     HV *substash;
1161
1162                     /* If this entry was seen when we iterated through the
1163                        oldstash, skip it. */
1164                     if(seen && hv_exists(seen, key, len)) continue;
1165
1166                     /* We get here only if this stash has no corresponding
1167                        entry in the stash being replaced. */
1168
1169                     substash = GvHV(HeVAL(entry));
1170                     if(substash) {
1171                         SV *subname;
1172
1173                         /* Avoid checking main::main::main::... */
1174                         if(substash == stash) continue;
1175
1176                         /* Add :: and the key (minus the trailing ::)
1177                            to each name. */
1178                         if(SvTYPE(namesv) == SVt_PVAV) {
1179                             SV *aname;
1180                             items = AvFILLp((AV *)namesv) + 1;
1181                             svp = AvARRAY((AV *)namesv);
1182                             subname = sv_2mortal((SV *)newAV());
1183                             while (items--) {
1184                                 aname = newSVsv(*svp++);
1185                                 if (len == 1)
1186                                     sv_catpvs(aname, ":");
1187                                 else {
1188                                     sv_catpvs(aname, "::");
1189                                     sv_catpvn(aname, key, len-2);
1190                                 }
1191                                 av_push((AV *)subname, aname);
1192                             }
1193                         }
1194                         else {
1195                             subname = sv_2mortal(newSVsv(namesv));
1196                             if (len == 1) sv_catpvs(subname, ":");
1197                             else {
1198                                 sv_catpvs(subname, "::");
1199                                 sv_catpvn(subname, key, len-2);
1200                             }
1201                         }
1202                         mro_gather_and_rename(
1203                           stashes, seen_stashes,
1204                           substash, NULL, subname
1205                         );
1206                     }
1207                 }
1208             }
1209         }
1210     }
1211 }
1212
1213 /*
1214 =for apidoc mro_method_changed_in
1215
1216 Invalidates method caching on any child classes
1217 of the given stash, so that they might notice
1218 the changes in this one.
1219
1220 Ideally, all instances of C<PL_sub_generation++> in
1221 perl source outside of C<mro.c> should be
1222 replaced by calls to this.
1223
1224 Perl automatically handles most of the common
1225 ways a method might be redefined.  However, there
1226 are a few ways you could change a method in a stash
1227 without the cache code noticing, in which case you
1228 need to call this method afterwards:
1229
1230 1) Directly manipulating the stash HV entries from
1231 XS code.
1232
1233 2) Assigning a reference to a readonly scalar
1234 constant into a stash entry in order to create
1235 a constant subroutine (like constant.pm
1236 does).
1237
1238 This same method is available from pure perl
1239 via, C<mro::method_changed_in(classname)>.
1240
1241 =cut
1242 */
1243 void
1244 Perl_mro_method_changed_in(pTHX_ HV *stash)
1245 {
1246     const char * const stashname = HvENAME_get(stash);
1247     const STRLEN stashname_len = HvENAMELEN_get(stash);
1248
1249     SV ** const svp = hv_fetch(PL_isarev, stashname, stashname_len, 0);
1250     HV * const isarev = svp ? MUTABLE_HV(*svp) : NULL;
1251
1252     PERL_ARGS_ASSERT_MRO_METHOD_CHANGED_IN;
1253
1254     if(!stashname)
1255         Perl_croak(aTHX_ "Can't call mro_method_changed_in() on anonymous symbol table");
1256
1257     /* Inc the package generation, since a local method changed */
1258     HvMROMETA(stash)->pkg_gen++;
1259
1260     /* If stash is UNIVERSAL, or one of UNIVERSAL's parents,
1261        invalidate all method caches globally */
1262     if((stashname_len == 9 && strEQ(stashname, "UNIVERSAL"))
1263         || (isarev && hv_exists(isarev, "UNIVERSAL", 9))) {
1264         PL_sub_generation++;
1265         return;
1266     }
1267
1268     /* else, invalidate the method caches of all child classes,
1269        but not itself */
1270     if(isarev) {
1271         HE* iter;
1272
1273         hv_iterinit(isarev);
1274         while((iter = hv_iternext(isarev))) {
1275             I32 len;
1276             const char* const revkey = hv_iterkey(iter, &len);
1277             HV* const revstash = gv_stashpvn(revkey, len, 0);
1278             struct mro_meta* mrometa;
1279
1280             if(!revstash) continue;
1281             mrometa = HvMROMETA(revstash);
1282             mrometa->cache_gen++;
1283             if(mrometa->mro_nextmethod)
1284                 hv_clear(mrometa->mro_nextmethod);
1285         }
1286     }
1287 }
1288
1289 void
1290 Perl_mro_set_mro(pTHX_ struct mro_meta *const meta, SV *const name)
1291 {
1292     const struct mro_alg *const which = Perl_mro_get_from_name(aTHX_ name);
1293  
1294     PERL_ARGS_ASSERT_MRO_SET_MRO;
1295
1296     if (!which)
1297         Perl_croak(aTHX_ "Invalid mro name: '%"SVf"'", name);
1298
1299     if(meta->mro_which != which) {
1300         if (meta->mro_linear_current && !meta->mro_linear_all) {
1301             /* If we were storing something directly, put it in the hash before
1302                we lose it. */
1303             Perl_mro_set_private_data(aTHX_ meta, meta->mro_which, 
1304                                       MUTABLE_SV(meta->mro_linear_current));
1305         }
1306         meta->mro_which = which;
1307         /* Scrub our cached pointer to the private data.  */
1308         meta->mro_linear_current = NULL;
1309         /* Only affects local method cache, not
1310            even child classes */
1311         meta->cache_gen++;
1312         if(meta->mro_nextmethod)
1313             hv_clear(meta->mro_nextmethod);
1314     }
1315 }
1316
1317 #include "XSUB.h"
1318
1319 XS(XS_mro_method_changed_in);
1320
1321 void
1322 Perl_boot_core_mro(pTHX)
1323 {
1324     dVAR;
1325     static const char file[] = __FILE__;
1326
1327     Perl_mro_register(aTHX_ &dfs_alg);
1328
1329     newXSproto("mro::method_changed_in", XS_mro_method_changed_in, file, "$");
1330 }
1331
1332 XS(XS_mro_method_changed_in)
1333 {
1334     dVAR;
1335     dXSARGS;
1336     SV* classname;
1337     HV* class_stash;
1338
1339     if(items != 1)
1340         croak_xs_usage(cv, "classname");
1341     
1342     classname = ST(0);
1343
1344     class_stash = gv_stashsv(classname, 0);
1345     if(!class_stash) Perl_croak(aTHX_ "No such class: '%"SVf"'!", SVfARG(classname));
1346
1347     mro_method_changed_in(class_stash);
1348
1349     XSRETURN_EMPTY;
1350 }
1351
1352 /*
1353  * Local variables:
1354  * c-indentation-style: bsd
1355  * c-basic-offset: 4
1356  * indent-tabs-mode: t
1357  * End:
1358  *
1359  * ex: set ts=8 sts=4 sw=4 noet:
1360  */