This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Fix package assignment with nested aliased packages
[perl5.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 && 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 =for apidoc mro_isa_changed_in3
445
446 Takes the necessary steps (cache invalidations, mostly)
447 when the @ISA of the given package has changed.  Invoked
448 by the C<setisa> magic, should not need to invoke directly.
449
450 The stash can be passed as the first argument, or its name and length as
451 the second and third (or both). If just the name is passed and the stash
452 does not exist, then only the subclasses' method and isa caches will be
453 invalidated.
454
455 =cut
456 */
457 void
458 Perl_mro_isa_changed_in3(pTHX_ HV* stash, const char *stashname,
459                          STRLEN stashname_len)
460 {
461     dVAR;
462     HV* isarev;
463     AV* linear_mro;
464     HE* iter;
465     SV** svp;
466     I32 items;
467     bool is_universal;
468     struct mro_meta * meta = NULL;
469     HV *isa = NULL;
470
471     if(!stashname && stash) {
472         stashname = HvENAME_get(stash);
473         stashname_len = HvENAMELEN_get(stash);
474     }
475     else if(!stash)
476         stash = gv_stashpvn(stashname, stashname_len, 0 /* don't add */);
477
478     if(!stashname)
479         Perl_croak(aTHX_ "Can't call mro_isa_changed_in() on anonymous symbol table");
480
481     if(stash) {
482       /* wipe out the cached linearizations for this stash */
483       meta = HvMROMETA(stash);
484       if (meta->mro_linear_all) {
485         SvREFCNT_dec(MUTABLE_SV(meta->mro_linear_all));
486         meta->mro_linear_all = NULL;
487         /* This is just acting as a shortcut pointer.  */
488         meta->mro_linear_current = NULL;
489       } else if (meta->mro_linear_current) {
490         /* Only the current MRO is stored, so this owns the data.  */
491         SvREFCNT_dec(meta->mro_linear_current);
492         meta->mro_linear_current = NULL;
493       }
494       if (meta->isa) {
495         /* Steal it for our own purposes. */
496         isa = (HV *)sv_2mortal((SV *)meta->isa);
497         meta->isa = NULL;
498       }
499
500       /* Inc the package generation, since our @ISA changed */
501       meta->pkg_gen++;
502     }
503
504     /* Wipe the global method cache if this package
505        is UNIVERSAL or one of its parents */
506
507     svp = hv_fetch(PL_isarev, stashname, stashname_len, 0);
508     isarev = svp ? MUTABLE_HV(*svp) : NULL;
509
510     if((stashname_len == 9 && strEQ(stashname, "UNIVERSAL"))
511         || (isarev && hv_exists(isarev, "UNIVERSAL", 9))) {
512         PL_sub_generation++;
513         is_universal = TRUE;
514     }
515     else { /* Wipe the local method cache otherwise */
516         if(meta) meta->cache_gen++;
517         is_universal = FALSE;
518     }
519
520     /* wipe next::method cache too */
521     if(meta && meta->mro_nextmethod) hv_clear(meta->mro_nextmethod);
522
523     /* Iterate the isarev (classes that are our children),
524        wiping out their linearization, method and isa caches
525        and upating PL_isarev. */
526     if(isarev) {
527         HV *isa_hashes = NULL;
528
529        /* We have to iterate through isarev twice to avoid a chicken and
530         * egg problem: if A inherits from B and both are in isarev, A might
531         * be processed before B and use B’s previous linearisation.
532         */
533
534        /* First iteration: Wipe everything, but stash away the isa hashes
535         * since we still need them for updating PL_isarev.
536         */
537
538         if(hv_iterinit(isarev)) {
539             /* Only create the hash if we need it; i.e., if isarev has
540                any elements. */
541             isa_hashes = (HV *)sv_2mortal((SV *)newHV());
542         }
543         while((iter = hv_iternext(isarev))) {
544             I32 len;
545             const char* const revkey = hv_iterkey(iter, &len);
546             HV* revstash = gv_stashpvn(revkey, len, 0);
547             struct mro_meta* revmeta;
548
549             if(!revstash) continue;
550             revmeta = HvMROMETA(revstash);
551             if (revmeta->mro_linear_all) {
552                 SvREFCNT_dec(MUTABLE_SV(revmeta->mro_linear_all));
553                 revmeta->mro_linear_all = NULL;
554                 /* This is just acting as a shortcut pointer.  */
555                 revmeta->mro_linear_current = NULL;
556             } else if (revmeta->mro_linear_current) {
557                 /* Only the current MRO is stored, so this owns the data.  */
558                 SvREFCNT_dec(revmeta->mro_linear_current);
559                 revmeta->mro_linear_current = NULL;
560             }
561             if(!is_universal)
562                 revmeta->cache_gen++;
563             if(revmeta->mro_nextmethod)
564                 hv_clear(revmeta->mro_nextmethod);
565
566             (void)
567               hv_store(
568                isa_hashes, (const char*)&revstash, sizeof(HV *),
569                revmeta->isa ? (SV *)revmeta->isa : &PL_sv_undef, 0
570               );
571             revmeta->isa = NULL;
572         }
573
574        /* Second pass: Update PL_isarev. We can just use isa_hashes to
575         * avoid another round of stash lookups. */
576
577        /* isarev might be deleted from PL_isarev during this loop, so hang
578         * on to it. */
579         SvREFCNT_inc_simple_void_NN(sv_2mortal((SV *)isarev));
580
581         if(isa_hashes) {
582             hv_iterinit(isa_hashes);
583             while((iter = hv_iternext(isa_hashes))) {
584                 HV* const revstash = *(HV **)HEK_KEY(HeKEY_hek(iter));
585                 HV * const isa = (HV *)HeVAL(iter);
586                 const HEK *namehek;
587
588                 /* Re-calculate the linearisation, unless a previous iter-
589                    ation was for a subclass of this class. */
590                 if(!HvMROMETA(revstash)->isa)
591                     (void)mro_get_linear_isa(revstash);
592
593                 /* We're starting at the 2nd element, skipping revstash */
594                 linear_mro = mro_get_linear_isa(revstash);
595                 svp = AvARRAY(linear_mro) + 1;
596                 items = AvFILLp(linear_mro);
597
598                 namehek = HvENAME_HEK(revstash);
599                 if (!namehek) namehek = HvNAME_HEK(revstash);
600
601                 while (items--) {
602                     SV* const sv = *svp++;
603                     HV* mroisarev;
604
605                     HE *he = hv_fetch_ent(PL_isarev, sv, TRUE, 0);
606
607                     /* That fetch should not fail.  But if it had to create
608                        a new SV for us, then will need to upgrade it to an
609                        HV (which sv_upgrade() can now do for us). */
610
611                     mroisarev = MUTABLE_HV(HeVAL(he));
612
613                     SvUPGRADE(MUTABLE_SV(mroisarev), SVt_PVHV);
614
615                     /* This hash only ever contains PL_sv_yes. Storing it
616                        over itself is almost as cheap as calling hv_exists,
617                        so on aggregate we expect to save time by not making
618                        two calls to the common HV code for the case where
619                        it doesn't exist.  */
620            
621                     (void)
622                       hv_store(
623                        mroisarev, HEK_KEY(namehek), HEK_LEN(namehek),
624                        &PL_sv_yes, 0
625                       );
626                 }
627
628                 if((SV *)isa != &PL_sv_undef)
629                     mro_clean_isarev(
630                      isa, HEK_KEY(namehek), HEK_LEN(namehek),
631                      HvMROMETA(revstash)->isa
632                     );
633             }
634         }
635     }
636
637     /* Now iterate our MRO (parents), adding ourselves and everything from
638        our isarev to their isarev.
639     */
640
641     /* This only applies if the stash exists. */
642     if(!stash) goto clean_up_isarev;
643
644     /* We're starting at the 2nd element, skipping ourselves here */
645     linear_mro = mro_get_linear_isa(stash);
646     svp = AvARRAY(linear_mro) + 1;
647     items = AvFILLp(linear_mro);
648
649     while (items--) {
650         SV* const sv = *svp++;
651         HV* mroisarev;
652
653         HE *he = hv_fetch_ent(PL_isarev, sv, TRUE, 0);
654
655         /* That fetch should not fail.  But if it had to create a new SV for
656            us, then will need to upgrade it to an HV (which sv_upgrade() can
657            now do for us. */
658
659         mroisarev = MUTABLE_HV(HeVAL(he));
660
661         SvUPGRADE(MUTABLE_SV(mroisarev), SVt_PVHV);
662
663         /* This hash only ever contains PL_sv_yes. Storing it over itself is
664            almost as cheap as calling hv_exists, so on aggregate we expect to
665            save time by not making two calls to the common HV code for the
666            case where it doesn't exist.  */
667            
668         (void)hv_store(mroisarev, stashname, stashname_len, &PL_sv_yes, 0);
669     }
670
671    clean_up_isarev:
672     /* Delete our name from our former parents’ isarevs. */
673     if(isa && HvARRAY(isa))
674         mro_clean_isarev(isa, stashname, stashname_len, meta->isa);
675 }
676
677 /* Deletes name from all the isarev entries listed in isa */
678 STATIC void
679 S_mro_clean_isarev(pTHX_ HV * const isa, const char * const name,
680                          const STRLEN len, HV * const exceptions)
681 {
682     HE* iter;
683
684     PERL_ARGS_ASSERT_MRO_CLEAN_ISAREV;
685
686     /* Delete our name from our former parents’ isarevs. */
687     if(isa && HvARRAY(isa) && hv_iterinit(isa)) {
688         SV **svp;
689         while((iter = hv_iternext(isa))) {
690             I32 klen;
691             const char * const key = hv_iterkey(iter, &klen);
692             if(exceptions && hv_exists(exceptions, key, klen)) continue;
693             svp = hv_fetch(PL_isarev, key, klen, 0);
694             if(svp) {
695                 HV * const isarev = (HV *)*svp;
696                 (void)hv_delete(isarev, name, len, G_DISCARD);
697                 if(!HvARRAY(isarev) || !HvKEYS(isarev))
698                     (void)hv_delete(PL_isarev, key, klen, G_DISCARD);
699             }
700         }
701     }
702 }
703
704 /*
705 =for apidoc mro_package_moved
706
707 Call this function to signal to a stash that it has been assigned to
708 another spot in the stash hierarchy. C<stash> is the stash that has been
709 assigned. C<oldstash> is the stash it replaces, if any. C<gv> is the glob
710 that is actually being assigned to. C<newname> and C<newname_len> are the
711 full name of the GV. If these last two arguments are omitted, they can be
712 inferred from C<gv>. C<gv> can be omitted if C<newname> is given.
713
714 This can also be called with a null first argument to
715 indicate that C<oldstash> has been deleted.
716
717 This function invalidates isa caches on the old stash, on all subpackages
718 nested inside it, and on the subclasses of all those, including
719 non-existent packages that have corresponding entries in C<stash>.
720
721 It also sets the effective names (C<HvENAME>) on all the stashes as
722 appropriate.
723
724 =cut
725 */
726 void
727 Perl_mro_package_moved(pTHX_ HV * const stash, HV * const oldstash,
728                        const GV *gv, const char *newname,
729                        I32 newname_len)
730 {
731     HV *stashes;
732     HE* iter;
733
734     assert(stash || oldstash);
735     assert(gv || newname);
736
737     /* Determine the name of the location that stash was assigned to
738      * or from which oldstash was removed.
739      *
740      * We cannot reliably use the name in oldstash, because it may have
741      * been deleted from the location in the symbol table that its name
742      * suggests, as in this case:
743      *
744      *   $globref = \*foo::bar::;
745      *   Symbol::delete_package("foo");
746      *   *$globref = \%baz::;
747      *   *$globref = *frelp::;
748      *      # calls mro_package_moved(%frelp::, %baz::, *$globref, NULL, 0)
749      *
750      * If newname is not null, then we trust that the caller gave us the
751      * right name. Otherwise, we get it from the gv. But if the gv is not
752      * in the symbol table, then we just return.
753      */
754     if(!newname && gv) {
755         SV * const namesv = sv_newmortal();
756         STRLEN len;
757         gv_fullname4(namesv, gv, NULL, 0);
758         if(gv_fetchsv(namesv, GV_NOADD_NOINIT, SVt_PVGV) != gv) return;
759         newname = SvPV_const(namesv, len);
760         newname_len = len - 2; /* skip trailing :: */
761     }
762     if(newname_len < 0) newname_len = -newname_len;
763
764     /* Get a list of all the affected classes. */
765     /* We cannot simply pass them all to mro_isa_changed_in to avoid
766        the list, as that function assumes that only one package has
767        changed. It does not work with:
768
769           @foo::ISA = qw( B B::B );
770           *B:: = delete $::{"A::"};
771
772        as neither B nor B::B can be updated before the other, since they
773        will reset caches on foo, which will see either B or B::B with the
774        wrong name. The names must be set on *all* affected stashes before
775        we do anything else.
776      */
777     stashes = (HV *) sv_2mortal((SV *)newHV());
778     mro_gather_and_rename(
779      stashes, (HV *) sv_2mortal((SV *)newHV()),
780      stash, oldstash, newname, newname_len
781     );
782
783     /* Iterate through the stashes, wiping isa linearisations, but leaving
784        the isa hash (which mro_isa_changed_in needs for adjusting the
785        isarev hashes belonging to parent classes). */
786     hv_iterinit(stashes);
787     while((iter = hv_iternext(stashes))) {
788         if(HeVAL(iter) != &PL_sv_yes && HvENAME(HeVAL(iter))) {
789             struct mro_meta* meta;
790             meta = HvMROMETA((HV *)HeVAL(iter));
791             if (meta->mro_linear_all) {
792                 SvREFCNT_dec(MUTABLE_SV(meta->mro_linear_all));
793                 meta->mro_linear_all = NULL;
794                 /* This is just acting as a shortcut pointer.  */
795                 meta->mro_linear_current = NULL;
796             } else if (meta->mro_linear_current) {
797                 /* Only the current MRO is stored, so this owns the data.  */
798                 SvREFCNT_dec(meta->mro_linear_current);
799                 meta->mro_linear_current = NULL;
800             }
801         }
802     }
803
804     /* Once the caches have been wiped on all the classes, call
805        mro_isa_changed_in on each. */
806     hv_iterinit(stashes);
807     while((iter = hv_iternext(stashes))) {
808         if(HvENAME(HeVAL(iter)))
809             mro_isa_changed_in((HV *)HeVAL(iter));
810     }
811 }
812
813 void
814 S_mro_gather_and_rename(pTHX_ HV * const stashes, HV * const seen_stashes,
815                               HV *stash, HV *oldstash, const char *name,
816                               I32 namlen)
817 {
818     register XPVHV* xhv;
819     register HE *entry;
820     I32 riter = -1;
821     const bool stash_had_name = stash && HvENAME(stash);
822     HV *seen = NULL;
823     HV *isarev = NULL;
824     SV **svp;
825
826     PERL_ARGS_ASSERT_MRO_GATHER_AND_RENAME;
827
828     /* We use the seen_stashes hash to keep track of which packages have
829        been encountered so far. This must be separate from the main list of
830        stashes, as we need to distinguish between stashes being assigned
831        and stashes being replaced/deleted. (A nested stash can be on both
832        sides of an assignment. We cannot simply skip iterating through a
833        stash on the right if we have seen it on the left, as it will not
834        get its ename assigned to it.)
835
836        To avoid allocating extra SVs, instead of a bitfield we can make
837        bizarre use of immortals:
838
839         &PL_sv_undef:  seen on the left  (oldstash)
840         &PL_sv_no   :  seen on the right (stash)
841         &PL_sv_yes  :  seen on both sides
842
843      */
844
845     if(oldstash) {
846         /* Add to the big list. */
847         HE * const entry
848          = (HE *)
849              hv_common(
850               seen_stashes, NULL, (const char *)&oldstash, sizeof(HV *), 0,
851               HV_FETCH_LVALUE|HV_FETCH_EMPTY_HE, NULL, 0
852              );
853         if(HeVAL(entry) == &PL_sv_undef || HeVAL(entry) == &PL_sv_yes) {
854             oldstash = NULL;
855             goto check_stash;
856         }
857         HeVAL(entry)
858          = HeVAL(entry) == &PL_sv_no ? &PL_sv_yes : &PL_sv_undef;
859         (void)
860           hv_store(
861            stashes, (const char *)&oldstash, sizeof(HV *),
862            SvREFCNT_inc_simple_NN((SV*)oldstash), 0
863           );
864
865         /* Update the effective name. */
866         if(HvENAME_get(oldstash)) {
867           const HEK * const enamehek = HvENAME_HEK(oldstash);
868           if(PL_stashcache)
869             (void)
870              hv_delete(PL_stashcache, name, namlen, G_DISCARD);
871           hv_ename_delete(oldstash, name, namlen);
872
873          /* If the name deletion caused a name change, then we are not
874           * going to call mro_isa_changed_in with this name (and not at all
875           * if it has become anonymous) so we need to delete old isarev
876           * entries here, both those in the superclasses and this class’s
877           * own list of subclasses. We simply delete the latter from
878           * from PL_isarev, since we still need it. hv_delete mortifies it
879           * for us, so sv_2mortal is not necessary. */
880           if(HvENAME_HEK(oldstash) != enamehek) {
881             const struct mro_meta * meta = HvMROMETA(oldstash);
882             if(meta->isa && HvARRAY(meta->isa))
883                 mro_clean_isarev(meta->isa, name, namlen, NULL);
884             isarev = (HV *)hv_delete(PL_isarev, name, namlen, 0);
885           }
886         }
887     }
888    check_stash:
889     if(stash) {
890         hv_ename_add(stash, name, namlen);
891
892        /* Add it to the big list if it needs
893         * mro_isa_changed_in called on it. That happens if it was
894         * detached from the symbol table (so it had no HvENAME) before
895         * being assigned to the spot named by the ‘name’ variable, because
896         * its cached isa linerisation is now stale (the effective name
897         * having changed), and subclasses will then use that cache when
898         * mro_package_moved calls mro_isa_changed_in. (See
899         * [perl #77358].)
900         *
901         * If it did have a name, then its previous name is still
902         * used in isa caches, and there is no need for
903         * mro_package_moved to call mro_isa_changed_in.
904         */
905
906         entry
907          = (HE *)
908              hv_common(
909               seen_stashes, NULL, (const char *)&stash, sizeof(HV *), 0,
910               HV_FETCH_LVALUE|HV_FETCH_EMPTY_HE, NULL, 0
911              );
912         if(HeVAL(entry) == &PL_sv_yes || HeVAL(entry) == &PL_sv_no)
913             stash = NULL;
914         else {
915             HeVAL(entry)
916              = HeVAL(entry) == &PL_sv_undef ? &PL_sv_yes : &PL_sv_no;
917             if(!stash_had_name)
918                 (void)
919                   hv_store(
920                    stashes, (const char *)&stash, sizeof(HV *),
921                    SvREFCNT_inc_simple_NN((SV *)stash), 0
922                   );
923         }
924     }
925
926     if(!stash && !oldstash)
927         /* Both stashes have been encountered already. */
928         return;
929
930     /* Add all the subclasses to the big list. */
931     if(
932         isarev
933      || (
934            (svp = hv_fetch(PL_isarev, name, namlen, 0))
935         && (isarev = MUTABLE_HV(*svp))
936         )
937     ) {
938         HE *iter;
939         hv_iterinit(isarev);
940         while((iter = hv_iternext(isarev))) {
941             I32 len;
942             const char* const revkey = hv_iterkey(iter, &len);
943             HV* revstash = gv_stashpvn(revkey, len, 0);
944
945             if(!revstash) continue;
946             (void)
947               hv_store(
948                stashes, (const char *)&revstash, sizeof(HV *),
949                SvREFCNT_inc_simple_NN((SV *)revstash), 0
950               );
951         }
952     }
953
954     if(
955      (!stash || !HvARRAY(stash)) && (!oldstash || !HvARRAY(oldstash))
956     ) return;
957
958     /* This is partly based on code in hv_iternext_flags. We are not call-
959        ing that here, as we want to avoid resetting the hash iterator. */
960
961     /* Skip the entire loop if the hash is empty.   */
962     if(oldstash && HvUSEDKEYS(oldstash)) { 
963         xhv = (XPVHV*)SvANY(oldstash);
964         seen = (HV *) sv_2mortal((SV *)newHV());
965
966         /* Iterate through entries in the oldstash, adding them to the
967            list, meanwhile doing the equivalent of $seen{$key} = 1.
968          */
969
970         while (++riter <= (I32)xhv->xhv_max) {
971             entry = (HvARRAY(oldstash))[riter];
972
973             /* Iterate through the entries in this list */
974             for(; entry; entry = HeNEXT(entry)) {
975                 const char* key;
976                 I32 len;
977
978                 /* If this entry is not a glob, ignore it.
979                    Try the next.  */
980                 if (!isGV(HeVAL(entry))) continue;
981
982                 key = hv_iterkey(entry, &len);
983                 if(len > 1 && key[len-2] == ':' && key[len-1] == ':') {
984                     HV * const oldsubstash = GvHV(HeVAL(entry));
985                     SV ** const stashentry
986                      = stash ? hv_fetch(stash, key, len, 0) : NULL;
987                     HV *substash = NULL;
988
989                     /* Avoid main::main::main::... */
990                     if(oldsubstash == oldstash) continue;
991
992                     if(
993                         (
994                             stashentry && *stashentry
995                          && (substash = GvHV(*stashentry))
996                         )
997                      || (oldsubstash && HvENAME_get(oldsubstash))
998                     )
999                     {
1000                         /* Add :: and the key (minus the trailing ::)
1001                            to newname. */
1002                         SV *namesv
1003                          = newSVpvn_flags(name, namlen, SVs_TEMP);
1004                         {
1005                             const char *name;
1006                             STRLEN namlen;
1007                             sv_catpvs(namesv, "::");
1008                             sv_catpvn(namesv, key, len-2);
1009                             name = SvPV_const(namesv, namlen);
1010                             mro_gather_and_rename(
1011                              stashes, seen_stashes,
1012                              substash, oldsubstash, name, namlen
1013                             );
1014                         }
1015                     }
1016
1017                     (void)hv_store(seen, key, len, &PL_sv_yes, 0);
1018                 }
1019             }
1020         }
1021     }
1022
1023     /* Skip the entire loop if the hash is empty.   */
1024     if (stash && HvUSEDKEYS(stash)) {
1025         xhv = (XPVHV*)SvANY(stash);
1026         riter = -1;
1027
1028         /* Iterate through the new stash, skipping $seen{$key} items,
1029            calling mro_gather_and_rename(stashes,seen,entry,NULL, ...). */
1030         while (++riter <= (I32)xhv->xhv_max) {
1031             entry = (HvARRAY(stash))[riter];
1032
1033             /* Iterate through the entries in this list */
1034             for(; entry; entry = HeNEXT(entry)) {
1035                 const char* key;
1036                 I32 len;
1037
1038                 /* If this entry is not a glob, ignore it.
1039                    Try the next.  */
1040                 if (!isGV(HeVAL(entry))) continue;
1041
1042                 key = hv_iterkey(entry, &len);
1043                 if(len > 1 && key[len-2] == ':' && key[len-1] == ':') {
1044                     HV *substash;
1045
1046                     /* If this entry was seen when we iterated through the
1047                        oldstash, skip it. */
1048                     if(seen && hv_exists(seen, key, len)) continue;
1049
1050                     /* We get here only if this stash has no corresponding
1051                        entry in the stash being replaced. */
1052
1053                     substash = GvHV(HeVAL(entry));
1054                     if(substash) {
1055                         SV *namesv;
1056                         const char *subname;
1057                         STRLEN subnamlen;
1058
1059                         /* Avoid checking main::main::main::... */
1060                         if(substash == stash) continue;
1061
1062                         /* Add :: and the key (minus the trailing ::)
1063                            to newname. */
1064                         namesv
1065                          = newSVpvn_flags(name, namlen, SVs_TEMP);
1066                         sv_catpvs(namesv, "::");
1067                         sv_catpvn(namesv, key, len-2);
1068                         subname = SvPV_const(namesv, subnamlen);
1069                         mro_gather_and_rename(
1070                           stashes, seen_stashes,
1071                           substash, NULL, subname, subnamlen
1072                         );
1073                     }
1074                 }
1075             }
1076         }
1077     }
1078 }
1079
1080 /*
1081 =for apidoc mro_method_changed_in
1082
1083 Invalidates method caching on any child classes
1084 of the given stash, so that they might notice
1085 the changes in this one.
1086
1087 Ideally, all instances of C<PL_sub_generation++> in
1088 perl source outside of C<mro.c> should be
1089 replaced by calls to this.
1090
1091 Perl automatically handles most of the common
1092 ways a method might be redefined.  However, there
1093 are a few ways you could change a method in a stash
1094 without the cache code noticing, in which case you
1095 need to call this method afterwards:
1096
1097 1) Directly manipulating the stash HV entries from
1098 XS code.
1099
1100 2) Assigning a reference to a readonly scalar
1101 constant into a stash entry in order to create
1102 a constant subroutine (like constant.pm
1103 does).
1104
1105 This same method is available from pure perl
1106 via, C<mro::method_changed_in(classname)>.
1107
1108 =cut
1109 */
1110 void
1111 Perl_mro_method_changed_in(pTHX_ HV *stash)
1112 {
1113     const char * const stashname = HvENAME_get(stash);
1114     const STRLEN stashname_len = HvENAMELEN_get(stash);
1115
1116     SV ** const svp = hv_fetch(PL_isarev, stashname, stashname_len, 0);
1117     HV * const isarev = svp ? MUTABLE_HV(*svp) : NULL;
1118
1119     PERL_ARGS_ASSERT_MRO_METHOD_CHANGED_IN;
1120
1121     if(!stashname)
1122         Perl_croak(aTHX_ "Can't call mro_method_changed_in() on anonymous symbol table");
1123
1124     /* Inc the package generation, since a local method changed */
1125     HvMROMETA(stash)->pkg_gen++;
1126
1127     /* If stash is UNIVERSAL, or one of UNIVERSAL's parents,
1128        invalidate all method caches globally */
1129     if((stashname_len == 9 && strEQ(stashname, "UNIVERSAL"))
1130         || (isarev && hv_exists(isarev, "UNIVERSAL", 9))) {
1131         PL_sub_generation++;
1132         return;
1133     }
1134
1135     /* else, invalidate the method caches of all child classes,
1136        but not itself */
1137     if(isarev) {
1138         HE* iter;
1139
1140         hv_iterinit(isarev);
1141         while((iter = hv_iternext(isarev))) {
1142             I32 len;
1143             const char* const revkey = hv_iterkey(iter, &len);
1144             HV* const revstash = gv_stashpvn(revkey, len, 0);
1145             struct mro_meta* mrometa;
1146
1147             if(!revstash) continue;
1148             mrometa = HvMROMETA(revstash);
1149             mrometa->cache_gen++;
1150             if(mrometa->mro_nextmethod)
1151                 hv_clear(mrometa->mro_nextmethod);
1152         }
1153     }
1154 }
1155
1156 void
1157 Perl_mro_set_mro(pTHX_ struct mro_meta *const meta, SV *const name)
1158 {
1159     const struct mro_alg *const which = Perl_mro_get_from_name(aTHX_ name);
1160  
1161     PERL_ARGS_ASSERT_MRO_SET_MRO;
1162
1163     if (!which)
1164         Perl_croak(aTHX_ "Invalid mro name: '%"SVf"'", name);
1165
1166     if(meta->mro_which != which) {
1167         if (meta->mro_linear_current && !meta->mro_linear_all) {
1168             /* If we were storing something directly, put it in the hash before
1169                we lose it. */
1170             Perl_mro_set_private_data(aTHX_ meta, meta->mro_which, 
1171                                       MUTABLE_SV(meta->mro_linear_current));
1172         }
1173         meta->mro_which = which;
1174         /* Scrub our cached pointer to the private data.  */
1175         meta->mro_linear_current = NULL;
1176         /* Only affects local method cache, not
1177            even child classes */
1178         meta->cache_gen++;
1179         if(meta->mro_nextmethod)
1180             hv_clear(meta->mro_nextmethod);
1181     }
1182 }
1183
1184 #include "XSUB.h"
1185
1186 XS(XS_mro_method_changed_in);
1187
1188 void
1189 Perl_boot_core_mro(pTHX)
1190 {
1191     dVAR;
1192     static const char file[] = __FILE__;
1193
1194     Perl_mro_register(aTHX_ &dfs_alg);
1195
1196     newXSproto("mro::method_changed_in", XS_mro_method_changed_in, file, "$");
1197 }
1198
1199 XS(XS_mro_method_changed_in)
1200 {
1201     dVAR;
1202     dXSARGS;
1203     SV* classname;
1204     HV* class_stash;
1205
1206     if(items != 1)
1207         croak_xs_usage(cv, "classname");
1208     
1209     classname = ST(0);
1210
1211     class_stash = gv_stashsv(classname, 0);
1212     if(!class_stash) Perl_croak(aTHX_ "No such class: '%"SVf"'!", SVfARG(classname));
1213
1214     mro_method_changed_in(class_stash);
1215
1216     XSRETURN_EMPTY;
1217 }
1218
1219 /*
1220  * Local variables:
1221  * c-indentation-style: bsd
1222  * c-basic-offset: 4
1223  * indent-tabs-mode: t
1224  * End:
1225  *
1226  * ex: set ts=8 sts=4 sw=4 noet:
1227  */