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), and:
 638          1) Add ourselves and everything from our isarev to their isarev
 639          2) Delete the parent’s entry from the (now temporary) isa hash
 640     */
 641
 642     /* This only applies if the stash exists. */
 643     if(!stash) goto clean_up_isarev;
 644
 645     /* We're starting at the 2nd element, skipping ourselves here */
 646     linear_mro = mro_get_linear_isa(stash);
 647     svp = AvARRAY(linear_mro) + 1;
 648     items = AvFILLp(linear_mro);
 649
 650     while (items--) {
 651         SV* const sv = *svp++;
 652         HV* mroisarev;
 653
 654         HE *he = hv_fetch_ent(PL_isarev, sv, TRUE, 0);
 655
 656         /* That fetch should not fail.  But if it had to create a new SV for
 657            us, then will need to upgrade it to an HV (which sv_upgrade() can
 658            now do for us. */
 659
 660         mroisarev = MUTABLE_HV(HeVAL(he));
 661
 662         SvUPGRADE(MUTABLE_SV(mroisarev), SVt_PVHV);
 663
 664         /* This hash only ever contains PL_sv_yes. Storing it over itself is
 665            almost as cheap as calling hv_exists, so on aggregate we expect to
 666            save time by not making two calls to the common HV code for the
 667            case where it doesn't exist.  */
 668
 669         (void)hv_store(mroisarev, stashname, stashname_len, &PL_sv_yes, 0);
 670     }
 671
 672    clean_up_isarev:
 673     /* Delete our name from our former parents’ isarevs. */
 674     if(isa && HvARRAY(isa))
 675         mro_clean_isarev(isa, stashname, stashname_len, meta->isa);
 676 }
 677
 678 /* Deletes name from all the isarev entries listed in isa */
 679 STATIC void
 680 S_mro_clean_isarev(pTHX_ HV * const isa, const char * const name,
 681                          const STRLEN len, HV * const exceptions)
 682 {
 683     HE* iter;
 684
 685     PERL_ARGS_ASSERT_MRO_CLEAN_ISAREV;
 686
 687     /* Delete our name from our former parents’ isarevs. */
 688     if(isa && HvARRAY(isa) && hv_iterinit(isa)) {
 689         SV **svp;
 690         while((iter = hv_iternext(isa))) {
 691             I32 klen;
 692             const char * const key = hv_iterkey(iter, &klen);
 693             if(exceptions && hv_exists(exceptions, key, klen)) continue;
 694             svp = hv_fetch(PL_isarev, key, klen, 0);
 695             if(svp) {
 696                 HV * const isarev = (HV *)*svp;
 697                 (void)hv_delete(isarev, name, len, G_DISCARD);
 698                 if(!HvARRAY(isarev) || !HvKEYS(isarev))
 699                     (void)hv_delete(PL_isarev, key, klen, G_DISCARD);
 700             }
 701         }
 702     }
 703 }
 704
 705 /*
 706 =for apidoc mro_package_moved
 707
 708 Call this function to signal to a stash that it has been assigned to
 709 another spot in the stash hierarchy. C<stash> is the stash that has been
 710 assigned. C<oldstash> is the stash it replaces, if any. C<gv> is the glob
 711 that is actually being assigned to. C<newname> and C<newname_len> are the
 712 full name of the GV. If these last two arguments are omitted, they can be
 713 inferred from C<gv>. C<gv> can be omitted if C<newname> is given.
 714
 715 This can also be called with a null first argument to
 716 indicate that C<oldstash> has been deleted.
 717
 718 This function invalidates isa caches on the old stash, on all subpackages
 719 nested inside it, and on the subclasses of all those, including
 720 non-existent packages that have corresponding entries in C<stash>.
 721
 722 It also sets the effective names (C<HvENAME>) on all the stashes as
 723 appropriate.
 724
 725 =cut
 726 */
 727 void
 728 Perl_mro_package_moved(pTHX_ HV * const stash, HV * const oldstash,
 729                        const GV *gv, const char *newname,
 730                        I32 newname_len)
 731 {
 732     HV *stashes;
 733     HE* iter;
 734
 735     assert(stash || oldstash);
 736     assert(gv || newname);
 737
 738     /* Determine the name of the location that stash was assigned to
 739      * or from which oldstash was removed.
 740      *
 741      * We cannot reliably use the name in oldstash, because it may have
 742      * been deleted from the location in the symbol table that its name
 743      * suggests, as in this case:
 744      *
 745      *   $globref = \*foo::bar::;
 746      *   Symbol::delete_package("foo");
 747      *   *$globref = \%baz::;
 748      *   *$globref = *frelp::;
 749      *      # calls mro_package_moved(%frelp::, %baz::, *$globref, NULL, 0)
 750      *
 751      * If newname is not null, then we trust that the caller gave us the
 752      * right name. Otherwise, we get it from the gv. But if the gv is not
 753      * in the symbol table, then we just return.
 754      */
 755     if(!newname && gv) {
 756         SV * const namesv = sv_newmortal();
 757         STRLEN len;
 758         gv_fullname4(namesv, gv, NULL, 0);
 759         if(gv_fetchsv(namesv, GV_NOADD_NOINIT, SVt_PVGV) != gv) return;
 760         newname = SvPV_const(namesv, len);
 761         newname_len = len - 2; /* skip trailing :: */
 762     }
 763     if(newname_len < 0) newname_len = -newname_len;
 764
 765     /* Get a list of all the affected classes. */
 766     /* We cannot simply pass them all to mro_isa_changed_in to avoid
 767        the list, as that function assumes that only one package has
 768        changed. It does not work with:
 769
 770           @foo::ISA = qw( B B::B );
 771           *B:: = delete $::{"A::"};
 772
 773        as neither B nor B::B can be updated before the other, since they
 774        will reset caches on foo, which will see either B or B::B with the
 775        wrong name. The names must be set on *all* affected stashes before
 776        we do anything else.
 777      */
 778     stashes = (HV *) sv_2mortal((SV *)newHV());
 779     mro_gather_and_rename(stashes, stash, oldstash, newname, newname_len);
 780
 781     /* Iterate through the stashes, wiping isa linearisations, but leaving
 782        the isa hash (which mro_isa_changed_in needs for adjusting the
 783        isarev hashes belonging to parent classes). */
 784     hv_iterinit(stashes);
 785     while((iter = hv_iternext(stashes))) {
 786         if(HeVAL(iter) != &PL_sv_yes && HvENAME(HeVAL(iter))) {
 787             struct mro_meta* meta;
 788             meta = HvMROMETA((HV *)HeVAL(iter));
 789             if (meta->mro_linear_all) {
 790                 SvREFCNT_dec(MUTABLE_SV(meta->mro_linear_all));
 791                 meta->mro_linear_all = NULL;
 792                 /* This is just acting as a shortcut pointer.  */
 793                 meta->mro_linear_current = NULL;
 794             } else if (meta->mro_linear_current) {
 795                 /* Only the current MRO is stored, so this owns the data.  */
 796                 SvREFCNT_dec(meta->mro_linear_current);
 797                 meta->mro_linear_current = NULL;
 798             }
 799         }
 800     }
 801
 802     /* Once the caches have been wiped on all the classes, call
 803        mro_isa_changed_in on each. */
 804     hv_iterinit(stashes);
 805     while((iter = hv_iternext(stashes))) {
 806         if(HeVAL(iter) != &PL_sv_yes && HvENAME(HeVAL(iter)))
 807             mro_isa_changed_in((HV *)HeVAL(iter));
 808         /* We are not holding a refcount, so eliminate the pointer before
 809          * stashes is freed. */
 810         HeVAL(iter) = NULL;
 811     }
 812 }
 813
 814 void
 815 S_mro_gather_and_rename(pTHX_ HV * const stashes, HV *stash, HV *oldstash,
 816                               const char *name, 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     if(oldstash) {
 829         /* Add to the big list. */
 830         HE * const entry
 831          = (HE *)
 832              hv_common(
 833               stashes, NULL, (const char *)&oldstash, sizeof(HV *), 0,
 834               HV_FETCH_LVALUE|HV_FETCH_EMPTY_HE, NULL, 0
 835              );
 836         if(HeVAL(entry) == (SV *)oldstash) {
 837             oldstash = NULL;
 838             goto check_stash;
 839         }
 840         HeVAL(entry) = (SV *)oldstash;
 841
 842         /* Update the effective name. */
 843         if(HvENAME_get(oldstash)) {
 844           const HEK * const enamehek = HvENAME_HEK(oldstash);
 845           if(PL_stashcache)
 846             (void)
 847              hv_delete(PL_stashcache, name, namlen, G_DISCARD);
 848           hv_ename_delete(oldstash, name, namlen);
 849
 850          /* If the name deletion caused a name change, then we are not
 851           * going to call mro_isa_changed_in with this name (and not at all
 852           * if it has become anonymous) so we need to delete old isarev
 853           * entries here, both those in the superclasses and this class’s
 854           * own list of subclasses. We simply delete the latter from
 855           * from PL_isarev, since we still need it. hv_delete mortifies it
 856           * for us, so sv_2mortal is not necessary. */
 857           if(HvENAME_HEK(oldstash) != enamehek) {
 858             const struct mro_meta * meta = HvMROMETA(oldstash);
 859             if(meta->isa && HvARRAY(meta->isa))
 860                 mro_clean_isarev(meta->isa, name, namlen, NULL);
 861             isarev = (HV *)hv_delete(PL_isarev, name, namlen, 0);
 862           }
 863         }
 864     }
 865    check_stash:
 866     if(stash) {
 867         hv_ename_add(stash, name, namlen);
 868
 869        /* Add it to the big list. We use the stash itself as the value if
 870         * it needs mro_isa_changed_in called on it. Otherwise we just use
 871         * &PL_sv_yes to indicate that we have seen it. */
 872
 873        /* The stash needs mro_isa_changed_in called on it if it was
 874         * detached from the symbol table (so it had no HvENAME) before
 875         * being assigned to the spot named by the ‘name’ variable, because
 876         * its cached isa linerisation is now stale (the effective name
 877         * having changed), and subclasses will then use that cache when
 878         * mro_package_moved calls mro_isa_changed_in. (See
 879         * [perl #77358].)
 880         *
 881         * If it did have a name, then its previous name is still
 882         * used in isa caches, and there is no need for
 883         * mro_package_moved to call mro_isa_changed_in.
 884         */
 885
 886         entry
 887          = (HE *)
 888              hv_common(
 889               stashes, NULL, (const char *)&stash, sizeof(HV *), 0,
 890               HV_FETCH_LVALUE|HV_FETCH_EMPTY_HE, NULL, 0
 891              );
 892         if(HeVAL(entry) == &PL_sv_yes || HeVAL(entry) == (SV *)stash)
 893             stash = NULL;
 894         else HeVAL(entry) = stash_had_name ? &PL_sv_yes : (SV *)stash;
 895     }
 896
 897     if(!stash && !oldstash)
 898         /* Both stashes have been encountered already. */
 899         return;
 900
 901     /* Add all the subclasses to the big list. */
 902     if(
 903         isarev
 904      || (
 905            (svp = hv_fetch(PL_isarev, name, namlen, 0))
 906         && (isarev = MUTABLE_HV(*svp))
 907         )
 908     ) {
 909         HE *iter;
 910         hv_iterinit(isarev);
 911         while((iter = hv_iternext(isarev))) {
 912             I32 len;
 913             const char* const revkey = hv_iterkey(iter, &len);
 914             HV* revstash = gv_stashpvn(revkey, len, 0);
 915
 916             if(!revstash) continue;
 917             entry
 918              = (HE *)
 919                  hv_common(
 920                   stashes, NULL, (const char *)&revstash, sizeof(HV *), 0,
 921                   HV_FETCH_LVALUE|HV_FETCH_EMPTY_HE, NULL, 0
 922                  );
 923             HeVAL(entry) = (SV *)revstash;
 924
 925         }
 926     }
 927
 928     if(
 929      (!stash || !HvARRAY(stash)) && (!oldstash || !HvARRAY(oldstash))
 930     ) return;
 931
 932     /* This is partly based on code in hv_iternext_flags. We are not call-
 933        ing that here, as we want to avoid resetting the hash iterator. */
 934
 935     /* Skip the entire loop if the hash is empty.   */
 936     if(oldstash && HvUSEDKEYS(oldstash)) {
 937         xhv = (XPVHV*)SvANY(oldstash);
 938         seen = (HV *) sv_2mortal((SV *)newHV());
 939
 940         /* Iterate through entries in the oldstash, adding them to the
 941            list, meanwhile doing the equivalent of $seen{$key} = 1.
 942          */
 943
 944         while (++riter <= (I32)xhv->xhv_max) {
 945             entry = (HvARRAY(oldstash))[riter];
 946
 947             /* Iterate through the entries in this list */
 948             for(; entry; entry = HeNEXT(entry)) {
 949                 const char* key;
 950                 I32 len;
 951
 952                 /* If this entry is not a glob, ignore it.
 953                    Try the next.  */
 954                 if (!isGV(HeVAL(entry))) continue;
 955
 956                 key = hv_iterkey(entry, &len);
 957                 if(len > 1 && key[len-2] == ':' && key[len-1] == ':') {
 958                     HV * const oldsubstash = GvHV(HeVAL(entry));
 959                     SV ** const stashentry
 960                      = stash ? hv_fetch(stash, key, len, 0) : NULL;
 961                     HV *substash = NULL;
 962
 963                     /* Avoid main::main::main::... */
 964                     if(oldsubstash == oldstash) continue;
 965
 966                     if(
 967                         (
 968                             stashentry && *stashentry
 969                          && (substash = GvHV(*stashentry))
 970                         )
 971                      || (oldsubstash && HvENAME_get(oldsubstash))
 972                     )
 973                     {
 974                         /* Add :: and the key (minus the trailing ::)
 975                            to newname. */
 976                         SV *namesv
 977                          = newSVpvn_flags(name, namlen, SVs_TEMP);
 978                         {
 979                             const char *name;
 980                             STRLEN namlen;
 981                             sv_catpvs(namesv, "::");
 982                             sv_catpvn(namesv, key, len-2);
 983                             name = SvPV_const(namesv, namlen);
 984                             mro_gather_and_rename(
 985                              stashes, substash, oldsubstash, name, namlen
 986                             );
 987                         }
 988                     }
 989
 990                     (void)hv_store(seen, key, len, &PL_sv_yes, 0);
 991                 }
 992             }
 993         }
 994     }
 995
 996     /* Skip the entire loop if the hash is empty.   */
 997     if (stash && HvUSEDKEYS(stash)) {
 998         xhv = (XPVHV*)SvANY(stash);
 999
1000         /* Iterate through the new stash, skipping $seen{$key} items,
1001            calling mro_gather_and_rename(stashes, entry, NULL, ...). */
1002         while (++riter <= (I32)xhv->xhv_max) {
1003             entry = (HvARRAY(stash))[riter];
1004
1005             /* Iterate through the entries in this list */
1006             for(; entry; entry = HeNEXT(entry)) {
1007                 const char* key;
1008                 I32 len;
1009
1010                 /* If this entry is not a glob, ignore it.
1011                    Try the next.  */
1012                 if (!isGV(HeVAL(entry))) continue;
1013
1014                 key = hv_iterkey(entry, &len);
1015                 if(len > 1 && key[len-2] == ':' && key[len-1] == ':') {
1016                     HV *substash;
1017
1018                     /* If this entry was seen when we iterated through the
1019                        oldstash, skip it. */
1020                     if(seen && hv_exists(seen, key, len)) continue;
1021
1022                     /* We get here only if this stash has no corresponding
1023                        entry in the stash being replaced. */
1024
1025                     substash = GvHV(HeVAL(entry));
1026                     if(substash) {
1027                         SV *namesv;
1028                         const char *subname;
1029                         STRLEN subnamlen;
1030
1031                         /* Avoid checking main::main::main::... */
1032                         if(substash == stash) continue;
1033
1034                         /* Add :: and the key (minus the trailing ::)
1035                            to newname. */
1036                         namesv
1037                          = newSVpvn_flags(name, namlen, SVs_TEMP);
1038                         sv_catpvs(namesv, "::");
1039                         sv_catpvn(namesv, key, len-2);
1040                         subname = SvPV_const(namesv, subnamlen);
1041                         mro_gather_and_rename(
1042                           stashes, substash, NULL, subname, subnamlen
1043                         );
1044                     }
1045                 }
1046             }
1047         }
1048     }
1049 }
1050
1051 /*
1052 =for apidoc mro_method_changed_in
1053
1054 Invalidates method caching on any child classes
1055 of the given stash, so that they might notice
1056 the changes in this one.
1057
1058 Ideally, all instances of C<PL_sub_generation++> in
1059 perl source outside of C<mro.c> should be
1060 replaced by calls to this.
1061
1062 Perl automatically handles most of the common
1063 ways a method might be redefined.  However, there
1064 are a few ways you could change a method in a stash
1065 without the cache code noticing, in which case you
1066 need to call this method afterwards:
1067
1068 1) Directly manipulating the stash HV entries from
1069 XS code.
1070
1071 2) Assigning a reference to a readonly scalar
1072 constant into a stash entry in order to create
1073 a constant subroutine (like constant.pm
1074 does).
1075
1076 This same method is available from pure perl
1077 via, C<mro::method_changed_in(classname)>.
1078
1079 =cut
1080 */
1081 void
1082 Perl_mro_method_changed_in(pTHX_ HV *stash)
1083 {
1084     const char * const stashname = HvENAME_get(stash);
1085     const STRLEN stashname_len = HvENAMELEN_get(stash);
1086
1087     SV ** const svp = hv_fetch(PL_isarev, stashname, stashname_len, 0);
1088     HV * const isarev = svp ? MUTABLE_HV(*svp) : NULL;
1089
1090     PERL_ARGS_ASSERT_MRO_METHOD_CHANGED_IN;
1091
1092     if(!stashname)
1093         Perl_croak(aTHX_ "Can't call mro_method_changed_in() on anonymous symbol table");
1094
1095     /* Inc the package generation, since a local method changed */
1096     HvMROMETA(stash)->pkg_gen++;
1097
1098     /* If stash is UNIVERSAL, or one of UNIVERSAL's parents,
1099        invalidate all method caches globally */
1100     if((stashname_len == 9 && strEQ(stashname, "UNIVERSAL"))
1101         || (isarev && hv_exists(isarev, "UNIVERSAL", 9))) {
1102         PL_sub_generation++;
1103         return;
1104     }
1105
1106     /* else, invalidate the method caches of all child classes,
1107        but not itself */
1108     if(isarev) {
1109         HE* iter;
1110
1111         hv_iterinit(isarev);
1112         while((iter = hv_iternext(isarev))) {
1113             I32 len;
1114             const char* const revkey = hv_iterkey(iter, &len);
1115             HV* const revstash = gv_stashpvn(revkey, len, 0);
1116             struct mro_meta* mrometa;
1117
1118             if(!revstash) continue;
1119             mrometa = HvMROMETA(revstash);
1120             mrometa->cache_gen++;
1121             if(mrometa->mro_nextmethod)
1122                 hv_clear(mrometa->mro_nextmethod);
1123         }
1124     }
1125 }
1126
1127 void
1128 Perl_mro_set_mro(pTHX_ struct mro_meta *const meta, SV *const name)
1129 {
1130     const struct mro_alg *const which = Perl_mro_get_from_name(aTHX_ name);
1131
1132     PERL_ARGS_ASSERT_MRO_SET_MRO;
1133
1134     if (!which)
1135         Perl_croak(aTHX_ "Invalid mro name: '%"SVf"'", name);
1136
1137     if(meta->mro_which != which) {
1138         if (meta->mro_linear_current && !meta->mro_linear_all) {
1139             /* If we were storing something directly, put it in the hash before
1140                we lose it. */
1141             Perl_mro_set_private_data(aTHX_ meta, meta->mro_which,
1142                                       MUTABLE_SV(meta->mro_linear_current));
1143         }
1144         meta->mro_which = which;
1145         /* Scrub our cached pointer to the private data.  */
1146         meta->mro_linear_current = NULL;
1147         /* Only affects local method cache, not
1148            even child classes */
1149         meta->cache_gen++;
1150         if(meta->mro_nextmethod)
1151             hv_clear(meta->mro_nextmethod);
1152     }
1153 }
1154
1155 #include "XSUB.h"
1156
1157 XS(XS_mro_method_changed_in);
1158
1159 void
1160 Perl_boot_core_mro(pTHX)
1161 {
1162     dVAR;
1163     static const char file[] = __FILE__;
1164
1165     Perl_mro_register(aTHX_ &dfs_alg);
1166
1167     newXSproto("mro::method_changed_in", XS_mro_method_changed_in, file, "$");
1168 }
1169
1170 XS(XS_mro_method_changed_in)
1171 {
1172     dVAR;
1173     dXSARGS;
1174     SV* classname;
1175     HV* class_stash;
1176
1177     if(items != 1)
1178         croak_xs_usage(cv, "classname");
1179
1180     classname = ST(0);
1181
1182     class_stash = gv_stashsv(classname, 0);
1183     if(!class_stash) Perl_croak(aTHX_ "No such class: '%"SVf"'!", SVfARG(classname));
1184
1185     mro_method_changed_in(class_stash);
1186
1187     XSRETURN_EMPTY;
1188 }
1189
1190 /*
1191  * Local variables:
1192  * c-indentation-style: bsd
1193  * c-basic-offset: 4
1194  * indent-tabs-mode: t
1195  * End:
1196  *
1197  * ex: set ts=8 sts=4 sw=4 noet:
1198  */