Lines Matching defs:stash
31 A B<stash> is a hash that contains all variables that are defined
344 C<stash> is the parent stash/package, if any.
348 stash element, it is the caller's responsibility to ensure that the name
379 Perl_gv_init_sv(pTHX_ GV *gv, HV *stash, SV* namesv, U32 flags)
387 gv_init_pvn(gv, stash, namepv, namelen, flags);
391 Perl_gv_init_pv(pTHX_ GV *gv, HV *stash, const char *name, U32 flags)
394 gv_init_pvn(gv, stash, name, strlen(name), flags);
402 Usually it's also what's actually stored in the stash, but for some cases
406 replace the SV stored in the stash with the regular PVGV structure that it is
408 that is already stored in the stash to a PVGV.
444 Perl_gv_init_pvn(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, U32 flags)
509 GvSTASH(gv) = stash;
510 if (stash)
511 Perl_sv_add_backref(aTHX_ MUTABLE_SV(stash), MUTABLE_SV(gv));
519 if (CvNAMED(cv) && CvSTASH(cv) == stash && (
533 cv = newCONSTSUB_flags(stash, name, len, flags, has_constant);
589 S_maybe_add_coresub(pTHX_ HV * const stash, GV *gv,
601 assert(gv || stash);
645 gv_init(gv, stash, name, len, TRUE);
680 if (stash)
681 (void)hv_store(stash,name,len,(SV *)gv,0);
731 C<stash> is always searched (first), unless it is C<NULL>.
733 If C<stash> is NULL, or was searched but nothing was found in it, and the
742 there is a glob named C<name> in C<stash>, creating one if necessary.
744 C<stash> and C<SUPER::> search, hence caching any C<SUPER::> result. Note that
756 C<stash>, then C<UNIVERSAL::>, and C<name> is never UTF-8. Otherwise it is
778 Perl_gv_fetchmeth_sv(pTHX_ HV *stash, SV *namesv, I32 level, U32 flags)
784 return gv_fetchmeth_internal(stash, namesv, NULL, 0, level,
788 return gv_fetchmeth_pvn(stash, namepv, namelen, level, flags);
793 Perl_gv_fetchmeth_pv(pTHX_ HV *stash, const char *name, I32 level, U32 flags)
796 return gv_fetchmeth_internal(stash, NULL, name, strlen(name), level, flags);
802 S_gv_fetchmeth_internal(pTHX_ HV* stash, SV* meth, const char* name, STRLEN len, I32 level, U32 flags)
820 /* UNIVERSAL methods should be callable without a stash */
821 if (!stash) {
823 if(!(stash = gv_stashpvs("UNIVERSAL", 0)))
827 assert(stash);
829 hvname = HvNAME_get(stash);
830 hvnamelen = HvNAMELEN_get(stash);
841 topgen_cmp = HvMROMETA(stash)->cache_gen + PL_sub_generation;
844 if (!HvAUX(stash)->xhv_mro_meta->super)
845 HvAUX(stash)->xhv_mro_meta->super = newHV();
846 cachestash = HvAUX(stash)->xhv_mro_meta->super;
848 else cachestash = stash;
865 gv_init_pvn(topgv, stash, name, len, GV_ADDMULTI|is_utf8);
884 else if (stash == cachestash
886 && memEQs(hvname, HvNAMELEN_get(stash), "CORE")
891 linear_av = mro_get_linear_isa(stash); /* has ourselves at the top of the list */
908 HEKfARG(HvNAME_HEK(stash)));
991 Perl_gv_fetchmeth_pvn(pTHX_ HV *stash, const char *name, STRLEN len, I32 level, U32 flags)
994 return gv_fetchmeth_internal(stash, NULL, name, len, level, flags);
1012 Perl_gv_fetchmeth_sv_autoload(pTHX_ HV *stash, SV *namesv, I32 level, U32 flags)
1020 return gv_fetchmeth_pvn_autoload(stash, namepv, namelen, level, flags);
1033 Perl_gv_fetchmeth_pv_autoload(pTHX_ HV *stash, const char *name, I32 level, U32 flags)
1036 return gv_fetchmeth_pvn_autoload(stash, name, strlen(name), level, flags);
1055 Perl_gv_fetchmeth_pvn_autoload(pTHX_ HV *stash, const char *name, STRLEN len, I32 level, U32 flags)
1057 GV *gv = gv_fetchmeth_pvn(stash, name, len, level, flags);
1065 if (!stash)
1069 if (!(gv = gv_fetchmeth_pvn(stash, S_autoload, S_autolen, FALSE, flags)))
1076 gv_fetchmeth_pvn(stash, name, len, 0, flags);
1077 gvp = (GV**)hv_fetch(stash, name,
1090 on the C<stash>. In fact in the presence of autoloading this may be the
1115 Perl_gv_fetchmethod_autoload(pTHX_ HV *stash, const char *name, I32 autoload)
1119 return gv_fetchmethod_flags(stash, name, autoload ? GV_AUTOLOAD : 0);
1123 Perl_gv_fetchmethod_sv_flags(pTHX_ HV *stash, SV *namesv, U32 flags)
1131 return gv_fetchmethod_pvn_flags(stash, namepv, namelen, flags);
1135 Perl_gv_fetchmethod_pv_flags(pTHX_ HV *stash, const char *name, U32 flags)
1138 return gv_fetchmethod_pvn_flags(stash, name, strlen(name), flags);
1142 Perl_gv_fetchmethod_pvn_flags(pTHX_ HV *stash, const char *name, const STRLEN len, U32 flags)
1148 HV* ostash = stash;
1149 SV *const error_report = MUTABLE_SV(stash);
1156 if (SvTYPE(stash) < SVt_PVHV)
1157 stash = NULL;
1159 /* The only way stash can become NULL later on is if last_separator is set,
1194 /* ->SUPER::method should really be looked up in original stash */
1195 stash = CopSTASH(PL_curcop);
1198 origname, HvENAME_get(stash), name) );
1203 stash = gv_stashpvn(origname, sep_len - 7, is_utf8);
1204 if (stash) flags |= GV_SUPER;
1208 stash = gv_stashpvn(origname, sep_len, is_utf8);
1210 ostash = stash;
1213 gv = gv_fetchmeth_pvn(stash, name, name_end - name, 0, flags);
1222 if (stash) {
1226 const char *stash_name = HvNAME_get(stash);
1227 if (stash_name && memEQs(stash_name, HvNAMELEN_get(stash), "IO::File")
1233 gv = gv_fetchmeth_pvn(stash, name, name_end - name, 0, flags);
1241 HEKfARG(HvNAME_HEK(stash)));
1297 its stash will be set to the stash of the GV.
1300 L</C<gv_fetchmeth>>, beginning with C<stash> if it isn't NULL.
1318 Perl_gv_autoload_sv(pTHX_ HV *stash, SV* namesv, U32 flags)
1326 return gv_autoload_pvn(stash, namepv, namelen, flags);
1330 Perl_gv_autoload_pv(pTHX_ HV *stash, const char *namepv, U32 flags)
1333 return gv_autoload_pvn(stash, namepv, strlen(namepv), flags);
1337 Perl_gv_autoload_pvn(pTHX_ HV *stash, const char *name, STRLEN len, U32 flags)
1351 if (stash) {
1352 if (SvTYPE(stash) < SVt_PVHV) {
1354 const char * const packname_ptr = SvPV_const(MUTABLE_SV(stash), packname_len);
1356 SVs_TEMP | SvUTF8(stash));
1357 stash = NULL;
1360 packname = newSVhek_mortal(HvNAME_HEK(stash));
1363 if (!(gv = gv_fetchmeth_pvn(stash, S_autoload, S_autolen, FALSE,
1376 && (GvCVGEN(gv) || GvSTASH(gv) != stash)
1386 * via the SvPVX field in the CV, and the stash in CvSTASH.
1406 CvSTASH_set(cv, stash);
1495 HV *stash;
1503 ( (gvp = (GV **)hv_fetchs(stash, "_tie_it", 0)) \
1510 if (!(stash = gv_stashpvn(name, len, 0))
1519 stash = gv_stashpvn(name, len, 0);
1520 if (!stash)
1548 Returns a pointer to the stash for a specified package. Uses C<strlen> to
1564 Returns a pointer to the stash for a specified package. The C<namelen>
1609 HV *stash;
1627 stash = GvHV(tmpgv);
1628 if (!(flags & ~GV_NOADD_MASK) && !stash) return NULL;
1629 assert(stash);
1630 if (!HvHasNAME(stash)) {
1631 hv_name_set(stash, name, namelen, flags & SVf_UTF8 ? SVf_UTF8 : 0 );
1634 /* If the containing stash has multiple effective
1637 mro_package_moved(stash, NULL, tmpgv, 1);
1639 return stash;
1645 Returns a pointer to the stash for a specified package, possibly
1651 If the flag C<GV_CACHE_ONLY> is set, return the stash only if found in the
1668 HV* stash;
1698 stash = gv_stashpvn_internal(name, namelen, flags);
1700 if (stash && namelen) {
1701 SV* const ref = newSViv(PTR2IV(stash));
1706 return stash;
1719 Returns a pointer to the stash for a specified package. See
1770 /* This function grabs name and tries to split a stash and glob
1777 S_parse_gv_stash_name(pTHX_ HV **stash, GV **gv, const char **name,
1802 if (!*stash)
1803 *stash = PL_defstash;
1804 if (!*stash || !SvREFCNT(*stash)) /* symbol table under destruction */
1831 gvp = (GV**)hv_fetch(*stash, key, is_utf8 ? -((I32)*len) : (I32)*len, add);
1838 gv_init_pvn(*gv, *stash, key, *len, (add & GV_ADDMULTI)|is_utf8);
1842 if (!(*stash = GvHV(*gv))) {
1843 *stash = GvHV(*gv) = newHV();
1844 if (!HvHasNAME(*stash)) {
1847 hv_name_sets(*stash, "CORE", 0);
1850 *stash, nambeg, name_cursor-nambeg, is_utf8
1852 /* If the containing stash has multiple effective
1855 mro_package_moved(*stash, NULL, *gv, 1);
1858 else if (!HvHasNAME(*stash))
1859 hv_name_set(*stash, nambeg, name_cursor - nambeg, is_utf8);
1889 /* Checks if an unqualified name is in the main stash */
1944 * find a stash, or if GV_NOTQUAL or an empty name was passed
1947 * It returns FALSE if the default stash can't be found nor created,
1951 S_find_default_stash(pTHX_ HV **stash, const char *name, STRLEN len,
1957 /* No stash in name, so see how we can default */
1960 *stash = PL_defstash;
1964 *stash = PL_curstash;
1973 GV**gvp = (GV**)hv_fetch(*stash,name,is_utf8 ? -(I32)len : (I32)len,0);
1977 *stash = NULL;
1996 *stash = NULL;
2001 /* Use the current op's stash */
2002 *stash = CopSTASH(PL_curcop);
2006 if (!*stash) {
2024 * them in the <none>:: stash.
2031 *stash = GvHV(gv);
2037 if (!SvREFCNT(*stash)) /* symbol table under destruction */
2051 * Note that it does not insert the GV into the stash prior to
2060 S_gv_magicalize(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len,
2067 if (stash != PL_defstash) { /* not the main stash */
2069 and VERSION. All the others apply only to the main stash or to
2092 if (stash == PL_debstash && memEQs(name, len, "args")) {
2107 if (len > 1 /* shortest is uc */ && HvNAMELEN_get(stash) == 4) {
2109 const char * const stashname = HvNAME(stash); assert(stashname);
2470 /* This function is called when the stash already holds the GV of the magic
2589 HV *stash = NULL;
2601 * there is no stash, so we can skip the check.
2608 else if (parse_gv_stash_name(&stash, &gv, &name, &len, nambeg, full_len, is_utf8, add)) {
2615 if (!stash && !find_default_stash(&stash, name, len, is_utf8, add, sv_type)) {
2619 /* By this point we should have a stash and a name */
2620 gvp = (GV**)hv_fetch(stash,name,is_utf8 ? -(I32)len : (I32)len,add);
2635 * 'used only once' warning. If there's already a GV in the stash
2648 if (len == 1 && stash == PL_defstash) {
2661 /* If GV_NOEXPAND is true and what we got off the stash is a ref,
2685 gv_init_pvn(gv, stash, name, len, (add & GV_ADDMULTI)|is_utf8);
2699 if ( gv_magicalize(gv, stash, name, len, sv_type) ) {
2707 (void)hv_store(stash,name,len,(SV *)gv,0);
2771 /* recursively scan a stash and any nested stashes looking for entries
2776 Perl_gv_check(pTHX_ HV *stash)
2782 if (!HvHasAUX(stash))
2785 assert(HvARRAY(stash));
2787 /* mark stash is being scanned, to avoid recursing */
2788 HvAUX(stash)->xhv_aux_flags |= HvAUXf_SCAN_STASH;
2789 for (i = 0; i <= (I32) HvMAX(stash); i++) {
2791 for (entry = HvARRAY(stash)[i]; entry; entry = HeNEXT(entry)) {
2800 if (hv != PL_defstash && hv != stash
2830 HEKfARG(HvNAME_HEK(stash)),
2837 HEKfARG(HvNAME_HEK(stash)),
2843 HvAUX(stash)->xhv_aux_flags &= ~HvAUXf_SCAN_STASH;
3128 Recalculates overload magic in the package given by C<stash>.
3147 Perl_Gv_AMupdate(pTHX_ HV *stash, bool destructing)
3149 MAGIC* const mg = mg_find((const SV *)stash, PERL_MAGIC_overload_table);
3151 const struct mro_meta* stash_meta = HvMROMETA(stash);
3162 sv_unmagic(MUTABLE_SV(stash), PERL_MAGIC_overload_table);
3165 DEBUG_o( Perl_deb(aTHX_ "Recalculating overload magic in package %s\n",HvNAME_get(stash)) );
3181 GV *gv = gv_fetchmeth_pvn(stash, PL_AMG_names[0], 2, -1, 0);
3187 if (!gv_fetchmeth_pvn(stash, "((", 2, -1, 0))
3207 assert(HvHasAUX(stash));
3209 HvAUX(stash)->xhv_aux_flags &= ~HvAUXf_NO_DEREF;
3218 cp, HvNAME_get(stash)) );
3226 gv = Perl_gv_fetchmeth_pvn(aTHX_ stash, cooky, l, -1, 0);
3243 (void*)GvSV(gv), cp, HvNAME(stash)) );
3245 || !(ngv = gv_fetchmethod_sv_flags(stash, gvsv, 0)))
3263 HvNAME_HEK(stash)
3270 cp, HvNAME_get(stash), HvNAME_get(GvSTASH(CvGV(cv))),
3296 HvAUX(stash)->xhv_aux_flags |= HvAUXf_NO_DEREF;
3300 sv_magic(MUTABLE_SV(stash), 0, PERL_MAGIC_overload_table,
3308 sv_magic(MUTABLE_SV(stash), 0, PERL_MAGIC_overload_table,
3322 Perl_gv_handler(pTHX_ HV *stash, I32 id)
3329 if (!stash || !HvHasNAME(stash))
3332 stash_meta = HvMROMETA(stash);
3335 mg = mg_find((const SV *)stash, PERL_MAGIC_overload_table);
3338 if (Gv_AMupdate(stash, 0) == -1)
3340 mg = mg_find((const SV *)stash, PERL_MAGIC_overload_table);
3353 GV * const gv = gv_fetchmethod(stash, PL_AMG_names[id]);
3465 HV *stash = SvSTASH(SvRV(sv));
3466 if (!Gv_AMG(stash))
3469 MAGIC *mg = mg_find((const SV *)stash, PERL_MAGIC_overload_table);
3682 HV *stash;
3689 stash = SvSTASH(SvRV(ref));
3690 assert(HvHasAUX(stash));
3691 if (HvAUX(stash)->xhv_aux_flags & HvAUXf_NO_DEREF)
3781 HV* stash=NULL;
3790 && (stash = SvSTASH(SvRV(left))) && Gv_AMG(stash)
3791 && (mg = mg_find((const SV *)stash, PERL_MAGIC_overload_table))
3860 delegate to the stash. */
3917 && (stash = SvSTASH(SvRV(right))) && Gv_AMG(stash)
3918 && (mg = mg_find((const SV *)stash, PERL_MAGIC_overload_table))
4103 stash ? SVfARG(newSVhek_mortal(HvNAME_HEK(stash))) : SVfARG(newSVpvs_flags("null", SVs_TEMP)),
4315 something other than a real GV in its place in the stash, replace it
4322 If C<gv> is a completely empty typeglob, it is deleted from the stash.
4334 HV *stash;
4349 GvEGVx(gv) == gv && (stash = GvSTASH(gv))))
4366 (void)hv_deletehek(stash, gvnhek, G_DISCARD);
4369 CvSTASH(cv) == stash && !CvNAMED(cv) && CvGV(cv) == gv &&
4373 (gvp = hv_fetchhek(stash, namehek, 0)) &&