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