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
 470     if(!stashname && stash) {
 471         stashname = HvENAME_get(stash);
 472         stashname_len = HvENAMELEN_get(stash);
 473     }
 474     else if(!stash)
 475         stash = gv_stashpvn(stashname, stashname_len, 0 /* don't add */);
 476
 477     if(!stashname)
 478         Perl_croak(aTHX_ "Can't call mro_isa_changed_in() on anonymous symbol table");
 479
 480     if(stash) {
 481       /* wipe out the cached linearizations for this stash */
 482       meta = HvMROMETA(stash);
 483       if (meta->mro_linear_all) {
 484         SvREFCNT_dec(MUTABLE_SV(meta->mro_linear_all));
 485         meta->mro_linear_all = NULL;
 486         /* This is just acting as a shortcut pointer.  */
 487         meta->mro_linear_current = NULL;
 488       } else if (meta->mro_linear_current) {
 489         /* Only the current MRO is stored, so this owns the data.  */
 490         SvREFCNT_dec(meta->mro_linear_current);
 491         meta->mro_linear_current = NULL;
 492       }
 493       if (meta->isa) {
 494         SvREFCNT_dec(meta->isa);
 495         meta->isa = NULL;
 496       }
 497
 498       /* Inc the package generation, since our @ISA changed */
 499       meta->pkg_gen++;
 500     }
 501
 502     /* Wipe the global method cache if this package
 503        is UNIVERSAL or one of its parents */
 504
 505     svp = hv_fetch(PL_isarev, stashname, stashname_len, 0);
 506     isarev = svp ? MUTABLE_HV(*svp) : NULL;
 507
 508     if((stashname_len == 9 && strEQ(stashname, "UNIVERSAL"))
 509         || (isarev && hv_exists(isarev, "UNIVERSAL", 9))) {
 510         PL_sub_generation++;
 511         is_universal = TRUE;
 512     }
 513     else { /* Wipe the local method cache otherwise */
 514         if(meta) meta->cache_gen++;
 515         is_universal = FALSE;
 516     }
 517
 518     /* wipe next::method cache too */
 519     if(meta && meta->mro_nextmethod) hv_clear(meta->mro_nextmethod);
 520
 521     /* Iterate the isarev (classes that are our children),
 522        wiping out their linearization, method and isa caches */
 523     if(isarev) {
 524         hv_iterinit(isarev);
 525         while((iter = hv_iternext(isarev))) {
 526             I32 len;
 527             const char* const revkey = hv_iterkey(iter, &len);
 528             HV* revstash = gv_stashpvn(revkey, len, 0);
 529             struct mro_meta* revmeta;
 530
 531             if(!revstash) continue;
 532             revmeta = HvMROMETA(revstash);
 533             if (revmeta->mro_linear_all) {
 534                 SvREFCNT_dec(MUTABLE_SV(revmeta->mro_linear_all));
 535                 revmeta->mro_linear_all = NULL;
 536                 /* This is just acting as a shortcut pointer.  */
 537                 revmeta->mro_linear_current = NULL;
 538             } else if (revmeta->mro_linear_current) {
 539                 /* Only the current MRO is stored, so this owns the data.  */
 540                 SvREFCNT_dec(revmeta->mro_linear_current);
 541                 revmeta->mro_linear_current = NULL;
 542             }
 543             if(!is_universal)
 544                 revmeta->cache_gen++;
 545             if(revmeta->mro_nextmethod)
 546                 hv_clear(revmeta->mro_nextmethod);
 547             if (revmeta->isa) {
 548                 SvREFCNT_dec(revmeta->isa);
 549                 revmeta->isa = NULL;
 550             }
 551         }
 552     }
 553
 554     /* Now iterate our MRO (parents), and do a few things:
 555          1) instantiate with the "fake" flag if they don't exist
 556          2) flag them as universal if we are universal
 557          3) Add everything from our isarev to their isarev
 558     */
 559
 560     /* This only applies if the stash exists. */
 561     if(!stash) return;
 562
 563     /* We're starting at the 2nd element, skipping ourselves here */
 564     linear_mro = mro_get_linear_isa(stash);
 565     svp = AvARRAY(linear_mro) + 1;
 566     items = AvFILLp(linear_mro);
 567
 568     while (items--) {
 569         SV* const sv = *svp++;
 570         HV* mroisarev;
 571
 572         HE *he = hv_fetch_ent(PL_isarev, sv, TRUE, 0);
 573
 574         /* That fetch should not fail.  But if it had to create a new SV for
 575            us, then will need to upgrade it to an HV (which sv_upgrade() can
 576            now do for us. */
 577
 578         mroisarev = MUTABLE_HV(HeVAL(he));
 579
 580         SvUPGRADE(MUTABLE_SV(mroisarev), SVt_PVHV);
 581
 582         /* This hash only ever contains PL_sv_yes. Storing it over itself is
 583            almost as cheap as calling hv_exists, so on aggregate we expect to
 584            save time by not making two calls to the common HV code for the
 585            case where it doesn't exist.  */
 586
 587         (void)hv_store(mroisarev, stashname, stashname_len, &PL_sv_yes, 0);
 588
 589         if(isarev) {
 590             hv_iterinit(isarev);
 591             while((iter = hv_iternext(isarev))) {
 592                 I32 revkeylen;
 593                 char* const revkey = hv_iterkey(iter, &revkeylen);
 594                 (void)hv_store(mroisarev, revkey, revkeylen, &PL_sv_yes, 0);
 595             }
 596         }
 597     }
 598 }
 599
 600 /*
 601 =for apidoc mro_package_moved
 602
 603 Call this function to signal to a stash that it has been assigned to
 604 another spot in the stash hierarchy. C<stash> is the stash that has been
 605 assigned. C<oldstash> is the stash it replaces, if any. C<gv> is the glob
 606 that is actually being assigned to. C<newname> and C<newname_len> are the
 607 full name of the GV. If these last two arguments are omitted, they can be
 608 inferred from C<gv>. C<gv> can be omitted if C<newname> is given.
 609
 610 This can also be called with a null first argument to
 611 indicate that C<oldstash> has been deleted.
 612
 613 This function invalidates isa caches on the old stash, on all subpackages
 614 nested inside it, and on the subclasses of all those, including
 615 non-existent packages that have corresponding entries in C<stash>.
 616
 617 =cut
 618 */
 619 void
 620 Perl_mro_package_moved(pTHX_ HV * const stash, HV * const oldstash,
 621                        const GV *gv, const char *newname,
 622                        I32 newname_len)
 623 {
 624     register XPVHV* xhv;
 625     register HE *entry;
 626     I32 riter = -1;
 627     HV *seen = NULL;
 628     HV *seen_stashes = NULL;
 629     const bool stash_had_name = stash && HvENAME(stash);
 630
 631     /* If newname_len is negative, then gv is actually the caller’s hash of
 632        stashes that have been seen so far. */
 633
 634     assert(stash || oldstash);
 635     assert((gv && newname_len >= 0) || newname);
 636
 637     if(newname_len < 0) seen_stashes = (HV *)gv, gv = NULL;
 638
 639     /* Determine the name of the location that stash was assigned to
 640      * or from which oldstash was removed.
 641      *
 642      * We cannot reliably use the name in oldstash, because it may have
 643      * been deleted from the location in the symbol table that its name
 644      * suggests, as in this case:
 645      *
 646      *   $globref = \*foo::bar::;
 647      *   Symbol::delete_package("foo");
 648      *   *$globref = \%baz::;
 649      *   *$globref = *frelp::;
 650      *      # calls mro_package_moved(%frelp::, %baz::, *$globref, NULL, 0)
 651      *
 652      * If newname is not null, then we trust that the caller gave us the
 653      * right name. Otherwise, we get it from the gv. But if the gv is not
 654      * in the symbol table, then we just return.
 655      */
 656     if(!newname && gv) {
 657         SV * const namesv = sv_newmortal();
 658         STRLEN len;
 659         gv_fullname4(namesv, gv, NULL, 0);
 660         if(gv_fetchsv(namesv, GV_NOADD_NOINIT, SVt_PVGV) != gv) return;
 661         newname = SvPV_const(namesv, len);
 662         newname_len = len - 2; /* skip trailing :: */
 663     }
 664     if(newname_len < 0) newname_len = -newname_len;
 665
 666     if(oldstash && HvENAME_get(oldstash)) {
 667         if(PL_stashcache)
 668             (void)
 669              hv_delete(PL_stashcache, newname, newname_len, G_DISCARD);
 670         hv_ename_delete(oldstash, newname, newname_len);
 671     }
 672     if(stash) {
 673         hv_ename_add(stash, newname, newname_len);
 674
 675        /* If this stash had been detached from the symbol table (so it
 676         * had no HvENAME) before being assigned to spot whose name is in
 677         * newname, then its isa cache would be stale (the effective name
 678         * having changed), and subclasses of newname would then use that
 679         * cache in the mro_isa_changed_in3(oldstash...) call below. (See
 680         * [perl #77358].)
 681         * If it did have a name, then its previous name is still
 682         * used in isa caches, and there is no need for this call.
 683         */
 684         if(!stash_had_name) mro_isa_changed_in(stash);
 685     }
 686
 687     mro_isa_changed_in3((HV *)oldstash, newname, newname_len);
 688
 689     if(
 690      (!stash || !HvARRAY(stash)) && (!oldstash || !HvARRAY(oldstash))
 691     ) return;
 692
 693     /* This is partly based on code in hv_iternext_flags. We are not call-
 694        ing that here, as we want to avoid resetting the hash iterator. */
 695
 696     /* Skip the entire loop if the hash is empty.   */
 697     if(oldstash && HvUSEDKEYS(oldstash)) {
 698         xhv = (XPVHV*)SvANY(oldstash);
 699         seen = (HV *) sv_2mortal((SV *)newHV());
 700         if(!seen_stashes) seen_stashes = (HV *) sv_2mortal((SV *)newHV());
 701
 702         /* Iterate through entries in the oldstash, calling
 703             mro_package_moved(
 704              corresponding_entry_in_new_stash, current_entry, ...
 705             )
 706            meanwhile doing the equivalent of $seen{$key} = 1.
 707          */
 708
 709         while (++riter <= (I32)xhv->xhv_max) {
 710             entry = (HvARRAY(oldstash))[riter];
 711
 712             /* Iterate through the entries in this list */
 713             for(; entry; entry = HeNEXT(entry)) {
 714                 const char* key;
 715                 I32 len;
 716
 717                 /* If this entry is not a glob, ignore it.
 718                    Try the next.  */
 719                 if (!isGV(HeVAL(entry))) continue;
 720
 721                 key = hv_iterkey(entry, &len);
 722                 if(len > 1 && key[len-2] == ':' && key[len-1] == ':') {
 723                     HV * const oldsubstash = GvHV(HeVAL(entry));
 724                     SV ** const stashentry
 725                      = stash ? hv_fetch(stash, key, len, 0) : NULL;
 726                     HV *substash = NULL;
 727
 728                     /* Avoid main::main::main::... */
 729                     if(oldsubstash == oldstash) continue;
 730                     if(oldsubstash) {
 731                         HE * const entry
 732                          = (HE *)
 733                             hv_common(
 734                              seen_stashes, NULL,
 735                              (const char *)&oldsubstash, sizeof(HV *), 0,
 736                              HV_FETCH_LVALUE, NULL, 0
 737                             );
 738                         if(HeVAL(entry) == &PL_sv_yes) continue;
 739                         HeVAL(entry) = &PL_sv_yes;
 740                     }
 741
 742                     if(
 743                         (
 744                             stashentry && *stashentry
 745                          && (substash = GvHV(*stashentry))
 746                         )
 747                      || (oldsubstash && HvENAME_get(oldsubstash))
 748                     )
 749                     {
 750                         /* Add :: and the key (minus the trailing ::)
 751                            to newname. */
 752                         SV *namesv
 753                          = newSVpvn_flags(newname, newname_len, SVs_TEMP);
 754                         const char *name;
 755                         STRLEN namlen;
 756                         sv_catpvs(namesv, "::");
 757                         sv_catpvn(namesv, key, len-2);
 758                         name = SvPV_const(namesv, namlen);
 759                         mro_package_moved(
 760                           substash, oldsubstash,
 761                           (GV *)seen_stashes, name, -namlen
 762                         );
 763                     }
 764
 765                     (void)hv_store(seen, key, len, &PL_sv_yes, 0);
 766                 }
 767             }
 768         }
 769     }
 770
 771     /* Skip the entire loop if the hash is empty.   */
 772     if (stash && HvUSEDKEYS(stash)) {
 773         xhv = (XPVHV*)SvANY(stash);
 774         if(!seen_stashes) seen_stashes = (HV *) sv_2mortal((SV *)newHV());
 775
 776         /* Iterate through the new stash, skipping $seen{$key} items,
 777            calling mro_package_moved(entry, NULL, ...). */
 778         while (++riter <= (I32)xhv->xhv_max) {
 779             entry = (HvARRAY(stash))[riter];
 780
 781             /* Iterate through the entries in this list */
 782             for(; entry; entry = HeNEXT(entry)) {
 783                 const char* key;
 784                 I32 len;
 785
 786                 /* If this entry is not a glob, ignore it.
 787                    Try the next.  */
 788                 if (!isGV(HeVAL(entry))) continue;
 789
 790                 key = hv_iterkey(entry, &len);
 791                 if(len > 1 && key[len-2] == ':' && key[len-1] == ':') {
 792                     HV *substash;
 793
 794                     /* If this entry was seen when we iterated through the
 795                        oldstash, skip it. */
 796                     if(seen && hv_exists(seen, key, len)) continue;
 797
 798                     /* We get here only if this stash has no corresponding
 799                        entry in the stash being replaced. */
 800
 801                     substash = GvHV(HeVAL(entry));
 802                     if(substash) {
 803                         SV *namesv;
 804                         const char *name;
 805                         STRLEN namlen;
 806                         HE *entry;
 807
 808                         /* Avoid checking main::main::main::... */
 809                         if(substash == stash) continue;
 810                         entry
 811                          = (HE *)
 812                                hv_common(
 813                                 seen_stashes, NULL,
 814                                 (const char *)&substash, sizeof(HV *), 0,
 815                                 HV_FETCH_LVALUE, NULL, 0
 816                                );
 817                         if(HeVAL(entry) == &PL_sv_yes) continue;
 818                         HeVAL(entry) = &PL_sv_yes;
 819
 820                         /* Add :: and the key (minus the trailing ::)
 821                            to newname. */
 822                         namesv
 823                          = newSVpvn_flags(newname, newname_len, SVs_TEMP);
 824                         sv_catpvs(namesv, "::");
 825                         sv_catpvn(namesv, key, len-2);
 826                         name = SvPV_const(namesv, namlen);
 827                         mro_package_moved(
 828                           substash, NULL, (GV *)seen_stashes, name, -namlen
 829                         );
 830                     }
 831                 }
 832             }
 833         }
 834     }
 835 }
 836
 837 /*
 838 =for apidoc mro_method_changed_in
 839
 840 Invalidates method caching on any child classes
 841 of the given stash, so that they might notice
 842 the changes in this one.
 843
 844 Ideally, all instances of C<PL_sub_generation++> in
 845 perl source outside of C<mro.c> should be
 846 replaced by calls to this.
 847
 848 Perl automatically handles most of the common
 849 ways a method might be redefined.  However, there
 850 are a few ways you could change a method in a stash
 851 without the cache code noticing, in which case you
 852 need to call this method afterwards:
 853
 854 1) Directly manipulating the stash HV entries from
 855 XS code.
 856
 857 2) Assigning a reference to a readonly scalar
 858 constant into a stash entry in order to create
 859 a constant subroutine (like constant.pm
 860 does).
 861
 862 This same method is available from pure perl
 863 via, C<mro::method_changed_in(classname)>.
 864
 865 =cut
 866 */
 867 void
 868 Perl_mro_method_changed_in(pTHX_ HV *stash)
 869 {
 870     const char * const stashname = HvENAME_get(stash);
 871     const STRLEN stashname_len = HvENAMELEN_get(stash);
 872
 873     SV ** const svp = hv_fetch(PL_isarev, stashname, stashname_len, 0);
 874     HV * const isarev = svp ? MUTABLE_HV(*svp) : NULL;
 875
 876     PERL_ARGS_ASSERT_MRO_METHOD_CHANGED_IN;
 877
 878     if(!stashname)
 879         Perl_croak(aTHX_ "Can't call mro_method_changed_in() on anonymous symbol table");
 880
 881     /* Inc the package generation, since a local method changed */
 882     HvMROMETA(stash)->pkg_gen++;
 883
 884     /* If stash is UNIVERSAL, or one of UNIVERSAL's parents,
 885        invalidate all method caches globally */
 886     if((stashname_len == 9 && strEQ(stashname, "UNIVERSAL"))
 887         || (isarev && hv_exists(isarev, "UNIVERSAL", 9))) {
 888         PL_sub_generation++;
 889         return;
 890     }
 891
 892     /* else, invalidate the method caches of all child classes,
 893        but not itself */
 894     if(isarev) {
 895         HE* iter;
 896
 897         hv_iterinit(isarev);
 898         while((iter = hv_iternext(isarev))) {
 899             I32 len;
 900             const char* const revkey = hv_iterkey(iter, &len);
 901             HV* const revstash = gv_stashpvn(revkey, len, 0);
 902             struct mro_meta* mrometa;
 903
 904             if(!revstash) continue;
 905             mrometa = HvMROMETA(revstash);
 906             mrometa->cache_gen++;
 907             if(mrometa->mro_nextmethod)
 908                 hv_clear(mrometa->mro_nextmethod);
 909         }
 910     }
 911 }
 912
 913 void
 914 Perl_mro_set_mro(pTHX_ struct mro_meta *const meta, SV *const name)
 915 {
 916     const struct mro_alg *const which = Perl_mro_get_from_name(aTHX_ name);
 917
 918     PERL_ARGS_ASSERT_MRO_SET_MRO;
 919
 920     if (!which)
 921         Perl_croak(aTHX_ "Invalid mro name: '%"SVf"'", name);
 922
 923     if(meta->mro_which != which) {
 924         if (meta->mro_linear_current && !meta->mro_linear_all) {
 925             /* If we were storing something directly, put it in the hash before
 926                we lose it. */
 927             Perl_mro_set_private_data(aTHX_ meta, meta->mro_which,
 928                                       MUTABLE_SV(meta->mro_linear_current));
 929         }
 930         meta->mro_which = which;
 931         /* Scrub our cached pointer to the private data.  */
 932         meta->mro_linear_current = NULL;
 933         /* Only affects local method cache, not
 934            even child classes */
 935         meta->cache_gen++;
 936         if(meta->mro_nextmethod)
 937             hv_clear(meta->mro_nextmethod);
 938     }
 939 }
 940
 941 #include "XSUB.h"
 942
 943 XS(XS_mro_method_changed_in);
 944
 945 void
 946 Perl_boot_core_mro(pTHX)
 947 {
 948     dVAR;
 949     static const char file[] = __FILE__;
 950
 951     Perl_mro_register(aTHX_ &dfs_alg);
 952
 953     newXSproto("mro::method_changed_in", XS_mro_method_changed_in, file, "$");
 954 }
 955
 956 XS(XS_mro_method_changed_in)
 957 {
 958     dVAR;
 959     dXSARGS;
 960     SV* classname;
 961     HV* class_stash;
 962
 963     if(items != 1)
 964         croak_xs_usage(cv, "classname");
 965
 966     classname = ST(0);
 967
 968     class_stash = gv_stashsv(classname, 0);
 969     if(!class_stash) Perl_croak(aTHX_ "No such class: '%"SVf"'!", SVfARG(classname));
 970
 971     mro_method_changed_in(class_stash);
 972
 973     XSRETURN_EMPTY;
 974 }
 975
 976 /*
 977  * Local variables:
 978  * c-indentation-style: bsd
 979  * c-basic-offset: 4
 980  * indent-tabs-mode: t
 981  * End:
 982  *
 983  * ex: set ts=8 sts=4 sw=4 noet:
 984  */