Lines Matching defs:gv
1 /* gv.c
52 Make sure there is a slot of type C<type> in the GV C<gv>.
58 Perl_gv_add_by_type(pTHX_ GV *gv, svtype type)
63 !gv
65 SvTYPE((const SV *)gv) != SVt_PVGV
66 && SvTYPE((const SV *)gv) != SVt_PVLV
86 where = (SV **)&GvHV(gv);
88 where = (SV **)&GvAV(gv);
90 where = (SV **)&GvIOp(gv);
92 where = &GvSV(gv);
99 && memEQs(GvNAME(gv), GvNAMELEN(gv), "ISA"))
101 sv_magic(*where, (SV *)gv, PERL_MAGIC_isa, NULL, 0);
104 return gv;
142 GV *gv;
160 gv = *gvp;
161 if (!isGV(gv)) {
162 gv_init(gv, PL_defstash, tmpbuf, tmplen, FALSE);
164 GvSV(gv) = newSVpvn(name, namelen);
166 sv_setpvn(GvSV(gv), name, namelen);
169 if (PERLDB_LINE_OR_SAVESRC && !GvAV(gv))
170 hv_magic(GvHVn(gv), GvAVn(gv), PERL_MAGIC_dbfile);
173 gv = NULL;
177 return gv;
183 If C<gv> is a typeglob whose subroutine entry is a constant sub eligible for
184 inlining, or C<gv> is a placeholder reference that would be promoted to such
192 Perl_gv_const_sv(pTHX_ GV *gv)
197 if (SvTYPE(gv) == SVt_PVGV)
198 return cv_const_sv(GvCVu(gv));
199 return SvROK(gv) && SvTYPE(SvRV(gv)) != SVt_PVAV && SvTYPE(SvRV(gv)) != SVt_PVCV ? SvRV(gv) : NULL;
203 Perl_newGP(pTHX_ GV *const gv)
212 gp->gp_egv = gv; /* allow compiler to reuse gv after this */
244 /* Assign CvGV(cv) = gv, handling weak references.
248 Perl_cvgv_set(pTHX_ CV* cv, GV* gv)
254 if (oldgv == gv)
272 SvANY(cv)->xcv_gv_u.xcv_gv = gv;
275 if (!gv)
278 if (isGV_with_GP(gv) && GvGP(gv) && (GvCV(gv) == cv || GvFORM(gv) == cv))
279 Perl_sv_add_backref(aTHX_ MUTABLE_SV(gv), MUTABLE_SV(cv));
282 SvREFCNT_inc_simple_void_NN(gv);
293 GV *gv;
300 gv = MUTABLE_GV(svp && *svp ? *svp : newSV_type(SVt_NULL));
301 if (!isGV(gv))
302 gv_init_pvn(gv, CvSTASH(cv), HEK_KEY(CvNAME_HEK(cv)),
306 assert (SvANY(cv)->xcv_gv_u.xcv_gv == gv);
307 return gv;
311 SvANY(cv)->xcv_gv_u.xcv_gv = gv;
312 if (svp && *svp) SvREFCNT_inc_simple_void_NN(gv);
314 return gv;
342 C<gv> is the scalar to be converted.
347 that is, it must not include the package name. If C<gv> is a
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);
444 Perl_gv_init_pvn(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, U32 flags)
446 const U32 old_type = SvTYPE(gv);
448 char * const proto = (doproto && SvPOK(gv))
449 ? ((void)(SvIsCOW(gv) && (sv_force_normal((SV *)gv), 0)), SvPVX(gv))
451 const STRLEN protolen = proto ? SvCUR(gv) : 0;
452 const U32 proto_utf8 = proto ? SvUTF8(gv) : 0;
453 SV *const has_constant = doproto && SvROK(gv) ? SvRV(gv) : NULL;
454 const U32 exported_constant = has_constant ? SvPCS_IMPORTED(gv) : 0;
475 SvRV_set(gv, NULL);
476 SvROK_off(gv);
482 SvCUR_set(gv, 0);
483 sv_upgrade(MUTABLE_SV(gv), SVt_PVGV);
485 if (SvLEN(gv)) {
490 SvPV_set(gv, NULL);
495 Safefree(SvPVX_mutable(gv));
497 SvLEN_set(gv, 0);
498 SvPOK_off(gv);
500 SvIOK_off(gv);
501 isGV_with_GP_on(gv);
507 GvGP_set(gv, Perl_newGP(aTHX_ gv));
509 GvSTASH(gv) = stash;
511 Perl_sv_add_backref(aTHX_ MUTABLE_SV(stash), MUTABLE_SV(gv));
512 gv_name_set(gv, name, len, GV_ADD | ( flags & SVf_UTF8 ? SVf_UTF8 : 0 ));
514 GvMULTI_on(gv); /* _was_ mentioned */
518 GvCV_set(gv,cv);
520 CvNAME_HEK(cv) == GvNAME_HEK(gv)
521 || ( HEK_LEN(CvNAME_HEK(cv)) == HEK_LEN(GvNAME_HEK(gv))
522 && HEK_FLAGS(CvNAME_HEK(cv)) != HEK_FLAGS(GvNAME_HEK(gv))
523 && HEK_UTF8(CvNAME_HEK(cv)) == HEK_UTF8(GvNAME_HEK(gv))
524 && memEQ(HEK_KEY(CvNAME_HEK(cv)), GvNAME(gv), GvNAMELEN(gv))
527 CvGV_set(cv,gv);
535 if (!GvCV(gv))
536 GvCV_set(gv, (CV *)SvREFCNT_inc_simple_NN(cv));
537 assert(GvCV(gv) == cv); /* newCONSTSUB should have set this */
542 GvIMPORTED_CV_on(gv);
545 cv = newSTUB(gv,1);
556 S_gv_init_svtype(pTHX_ GV *gv, const svtype sv_type)
562 (void)GvIOn(gv);
565 (void)GvAVn(gv);
568 (void)GvHVn(gv);
577 if(GvSVn(gv)) {
579 If we just cast GvSVn(gv) to void, it ignores evaluating it for
589 S_maybe_add_coresub(pTHX_ HV * const stash, GV *gv,
601 assert(gv || stash);
643 if (!gv) {
644 gv = (GV *)newSV_type(SVt_NULL);
645 gv_init(gv, stash, name, len, TRUE);
647 GvMULTI_on(gv);
663 GvCV_set(gv,cv);
664 GvCVGEN(gv) = 0;
669 CvGV_set(cv, gv); /* This stops new ATTRSUB from setting CvFILE
681 (void)hv_store(stash,name,len,(SV *)gv,0);
690 oldsavestack_ix, (OP *)gv,
700 assert(GvCV(gv) == orig_cv);
719 return gv;
1057 GV *gv = gv_fetchmeth_pvn(stash, name, len, level, flags);
1061 if (!gv) {
1069 if (!(gv = gv_fetchmeth_pvn(stash, S_autoload, S_autolen, FALSE, flags)))
1071 cv = GvCV(gv);
1083 return gv;
1147 GV* gv;
1213 gv = gv_fetchmeth_pvn(stash, name, name_end - name, 0, flags);
1214 if (!gv) {
1216 gv = gv_autoload_pvn(
1219 if (!gv && do_croak) {
1233 gv = gv_fetchmeth_pvn(stash, name, name_end - name, 0, flags);
1234 if (gv)
1235 return gv;
1263 CV* const cv = GvCV(gv);
1269 stubgv = gv;
1273 stubgv = gv;
1280 gv = autogv;
1284 return gv;
1339 GV* gv;
1363 if (!(gv = gv_fetchmeth_pvn(stash, S_autoload, S_autolen, FALSE,
1366 cv = GvCV(gv);
1376 && (GvCVGEN(gv) || GvSTASH(gv) != stash)
1466 return gv;
1473 * with the passed gv as an argument.
1475 * The "gv" parameter should be the glob.
1483 S_require_tie_mod(pTHX_ GV *gv, const char varname, const char * name,
1486 const SV * const target = varname == '[' ? GvSV(gv) : (SV *)GvHV(gv);
1516 save_scalar(gv);
1530 XPUSHs((SV *)gv);
1542 #define require_tie_mod_s(gv, varname, name, flags) \
1543 S_require_tie_mod(aTHX_ gv, varname, STR_WITH_LEN(name), flags)
1750 S_gv_magicalize_isa(pTHX_ GV *gv)
1756 av = GvAVn(gv);
1757 GvMULTI_on(gv);
1758 sv_magic(MUTABLE_SV(av), MUTABLE_SV(gv), PERL_MAGIC_isa,
1761 if(HvSTASH_IS_CLASS(GvSTASH(gv))) {
1774 * 'gv' can be directly returned to the caller of gv_fetchpvn_flags
1777 S_parse_gv_stash_name(pTHX_ HV **stash, GV **gv, const char **name,
1832 *gv = gvp ? *gvp : NULL;
1833 if (!*gv || *gv == (const GV *)&PL_sv_undef) {
1836 /* here we know that *gv && *gv != &PL_sv_undef */
1837 if (SvTYPE(*gv) != SVt_PVGV)
1838 gv_init_pvn(*gv, *stash, key, *len, (add & GV_ADDMULTI)|is_utf8);
1840 GvMULTI_on(*gv);
1842 if (!(*stash = GvHV(*gv))) {
1843 *stash = GvHV(*gv) = newHV();
1845 if (GvSTASH(*gv) == PL_defstash && *len == 6
1854 if (HvAUX(GvSTASH(*gv))->xhv_name_count)
1855 mro_package_moved(*stash, NULL, *gv, 1);
1866 if (!*gv) {
1867 *gv = MUTABLE_GV(*hv_fetchs(PL_defstash, "main::", TRUE));
1868 if (SvTYPE(*gv) != SVt_PVGV) {
1869 gv_init_pvn(*gv, PL_defstash, "main::", 6,
1871 GvHV(*gv) =
2008 GV *gv;
2026 gv = gv_fetchpvs("<none>::", GV_ADDMULTI, SVt_PVHV);
2027 if (!gv) {
2031 *stash = GvHV(gv);
2056 * It returns true if the gv did turn out to be magical one; i.e.,
2060 S_gv_magicalize(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len,
2081 GvMULTI_on(gv);
2085 gv_magicalize_isa(gv);
2089 GvMULTI_on(gv);
2093 GvMULTI_on(gv_AVadd(gv));
2099 GvMULTI_on(gv);
2111 S_maybe_add_coresub(aTHX_ 0, gv, name, len);
2134 IoFLAGS(GvIOn(gv)) |= IOf_ARGV|IOf_START;
2137 GvMULTI_on(gv);
2148 GvMULTI_on(gv);
2152 gv_magicalize_isa(gv);
2176 GvMULTI_on(gv);
2177 hv = GvHVn(gv);
2188 GvMULTI_on(gv);
2195 AV* const av = GvAVn(gv);
2201 require_tie_mod_s(gv, '+', "Tie::Hash::NamedCapture",0);
2205 require_tie_mod_s(gv, '-', "Tie::Hash::NamedCapture",0);
2218 GvMULTI_on(gv);
2219 HV *hv = GvHVn(gv);
2336 sv_magic(GvSVn(gv), MUTABLE_SV(gv), PERL_MAGIC_sv, NULL, paren);
2340 sv_setpv(GvSVn(gv),PL_chopset);
2345 SvUPGRADE(GvSVn(gv), SVt_PVLV);
2350 GvMULTI_on(gv);
2353 sv_magic(GvSVn(gv), MUTABLE_SV(gv), PERL_MAGIC_sv, name, len);
2357 require_tie_mod_s(gv, '!', "Errno", 1);
2362 GvMULTI_on(gv); /* no used once warnings here */
2364 sv_magic(GvSVn(gv), MUTABLE_SV(gv), PERL_MAGIC_sv, name, len);
2366 SvREADONLY_on(GvSVn(gv));
2370 require_tie_mod_s(gv, *name, "Tie::Hash::NamedCapture",0);
2373 AV* const av = GvAVn(gv);
2388 HV *const hv = GvHVn(gv);
2394 SvREADONLY_on(GvSVn(gv));
2423 sv_magic(GvSVn(gv), MUTABLE_SV(gv), PERL_MAGIC_sv, name, len);
2427 sv_setpvs(GvSVn(gv),"\f");
2430 sv_setpvs(GvSVn(gv),"\034");
2434 SV * const sv = GvSV(gv);
2437 GvSV(gv) = vnumify(PL_patchlevel);
2438 SvREADONLY_on(GvSV(gv));
2444 SV * const sv = GvSV(gv);
2445 GvSV(gv) = new_version(PL_patchlevel);
2446 SvREADONLY_on(GvSV(gv));
2453 GvMULTI_on(gv);
2459 return GvAV(gv) || GvHV(gv) || GvIO(gv) || GvCV(gv)
2460 || ( GvSV(gv) && (
2461 SvOK(GvSV(gv)) || SvMAGICAL(GvSV(gv))
2477 S_maybe_multimagic_gv(pTHX_ GV *gv, const char *name, const svtype sv_type)
2483 require_tie_mod_s(gv, '!', "Errno", 1);
2485 require_tie_mod_s(gv, *name, "Tie::Hash::NamedCapture", 0);
2497 (void)GvSVn(gv);
2501 (void)GvSVn(gv);
2505 (void)GvSVn(gv);
2586 GV *gv = NULL;
2608 else if (parse_gv_stash_name(&stash, &gv, &name, &len, nambeg, full_len, is_utf8, add)) {
2609 if (name == name_end) return gv;
2622 if (addmg) gv = (GV *)newSV_type(SVt_NULL); /* tentatively */
2625 else gv = *gvp, addmg = 0;
2626 /* From this point on, addmg means gv has not been inserted in the
2629 if (SvTYPE(gv) == SVt_PVGV) {
2642 GvMULTI_on(gv);
2643 gv_init_svtype(gv, sv_type);
2649 maybe_multimagic_gv(gv, name, sv_type);
2653 && (!GvAV(gv) || !SvSMAGICAL(GvAV(gv))))
2654 gv_magicalize_isa(gv);
2656 return gv;
2659 return gv;
2667 else if (no_expand && SvROK(gv)) {
2669 return gv;
2679 faking_it = SvOK(gv);
2685 gv_init_pvn(gv, stash, name, len, (add & GV_ADDMULTI)|is_utf8);
2691 GvONCE_FATAL_on(gv);
2694 GvMULTI_on(gv) ;
2699 if ( gv_magicalize(gv, stash, name, len, sv_type) ) {
2702 /* gv_magicalize magicalised this gv, so we want it
2704 * Effectively the caller is asking, ‘Does this gv exist?’
2707 (void)hv_store(stash,name,len,(SV *)gv,0);
2712 SvREFCNT_dec_NN(gv);
2713 gv = NULL;
2716 if (gv) gv_init_svtype(gv, faking_it ? SVt_PVCV : sv_type);
2717 return gv;
2726 Place the full package name of C<gv> into C<sv>. The C<gv_e*> forms return
2740 Perl_gv_fullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain)
2743 const HV * const hv = GvSTASH(gv);
2757 sv_catsv(sv,newSVhek_mortal(GvNAME_HEK(gv)));
2761 Perl_gv_efullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain)
2763 const GV * const egv = GvEGVx(gv);
2767 gv_fullname4(sv, egv ? egv : gv, prefix, keepmain);
2792 GV *gv;
2798 (gv = MUTABLE_GV(HeVAL(entry))) && isGV(gv) && (hv = GvHV(gv)))
2813 gv = MUTABLE_GV(HeVAL(entry));
2814 if (SvTYPE(gv) != SVt_PVGV || GvMULTI(gv))
2816 file = GvFILE(gv);
2818 CopLINE_set(PL_curcop, GvLINE(gv));
2824 = gv_fetchfile_flags(file, HEK_LEN(GvFILE_HEK(gv)), 0);
2826 if (GvONCE_FATAL(gv)) {
2831 HEKfARG(GvNAME_HEK(gv)));
2838 HEKfARG(GvNAME_HEK(gv)));
2895 Perl_gp_free(pTHX_ GV *gv)
2901 if (!gv || !isGV_with_GP(gv) || !(gp = GvGP(gv)))
2911 if (gp->gp_egv == gv)
2914 GvGP_set(gv, NULL);
3016 io_close(io, gv, FALSE, TRUE);
3080 gp = GvGP(gv);
3101 GvGP_set(gv, NULL);
3181 GV *gv = gv_fetchmeth_pvn(stash, PL_AMG_names[0], 2, -1, 0);
3182 SV * const sv = gv ? GvSV(gv) : NULL;
3185 if (!gv)
3226 gv = Perl_gv_fetchmeth_pvn(aTHX_ stash, cooky, l, -1, 0);
3228 if (gv && (cv = GvCV(gv)) && CvHASGV(cv)) {
3239 SV *gvsv = GvSV(gv);
3243 (void*)GvSV(gv), cp, HvNAME(stash)) );
3259 (GvCVGEN(gv) ? "Stub found while resolving"
3267 cv = GvCV(gv = ngv);
3273 } else if (gv) { /* Autoloaded... */
3274 cv = MUTABLE_CV(gv);
3279 if (gv) {
3353 GV * const gv = gv_fetchmethod(stash, PL_AMG_names[id]);
3355 if (gv && GvCV(gv))
3356 return GvCV(gv);
4284 Set the name for GV C<gv> to C<name> which is C<len> bytes long. Thus it may
4294 Perl_gv_name_set(pTHX_ GV *gv, const char *name, U32 len, U32 flags)
4301 Perl_croak(aTHX_ "panic: gv name too long (%" UVuf ")", (UV) len);
4303 if (!(flags & GV_ADD) && GvNAME_HEK(gv)) {
4304 unshare_hek(GvNAME_HEK(gv));
4308 GvNAME_HEK(gv) = share_hek(name, (flags & SVf_UTF8 ? -(I32)len : (I32)len), hash);
4314 If the typeglob C<gv> can be expressed more succinctly, by having
4316 with the optimised form. Basic requirements for this are that C<gv>
4322 If C<gv> is a completely empty typeglob, it is deleted from the stash.
4324 If C<gv> is a typeglob containing only a sufficiently-ordinary constant
4332 Perl_gv_try_downgrade(pTHX_ GV *gv)
4344 if (!(SvREFCNT(gv) == 1 && SvTYPE(gv) == SVt_PVGV && !SvFAKE(gv) &&
4345 !SvOBJECT(gv) && !SvREADONLY(gv) &&
4346 isGV_with_GP(gv) && GvGP(gv) &&
4347 !GvINTRO(gv) && GvREFCNT(gv) == 1 &&
4348 !GvSV(gv) && !GvAV(gv) && !GvHV(gv) && !GvIOp(gv) && !GvFORM(gv) &&
4349 GvEGVx(gv) == gv && (stash = GvSTASH(gv))))
4351 if (gv == PL_statgv || gv == PL_last_in_gv || gv == PL_stderrgv)
4353 if (SvMAGICAL(gv)) {
4356 if (SvGMAGICAL(gv) || SvSMAGICAL(gv))
4358 for (mg = SvMAGIC(gv); mg; mg = mg->mg_moremagic) {
4363 cv = GvCV(gv);
4365 HEK *gvnhek = GvNAME_HEK(gv);
4367 } else if (GvMULTI(gv) && cv && SvREFCNT(cv) == 1 &&
4369 CvSTASH(cv) == stash && !CvNAMED(cv) && CvGV(cv) == gv &&
4372 (namehek = GvNAME_HEK(gv)) &&
4374 *gvp == (SV*)gv) {
4376 const bool imported = cBOOL(GvIMPORTED_CV(gv));
4377 SvREFCNT(gv) = 0;
4378 sv_clear((SV*)gv);
4379 SvREFCNT(gv) = 1;
4380 SvFLAGS(gv) = SVt_IV|SVf_ROK|SVprv_PCS_IMPORTED * imported;
4383 SvANY(gv) = (XPVGV*)((char*)&(gv->sv_u.svu_iv) -
4385 SvRV_set(gv, value);
4392 GV *gv = gv_fetchpvn(name, len, GV_NOTQUAL, SVt_PVCV);
4395 if (gv && GvCVu(gv) && GvIMPORTED_CV(gv)) return gv;
4397 gv = gvp ? *gvp : NULL;
4398 if (gv && !isGV(gv)) {
4399 if (!SvPCS_IMPORTED(gv)) return NULL;
4400 gv_init(gv, PL_globalstash, name, len, 0);
4401 return gv;
4403 return gv && GvCVu(gv) && GvIMPORTED_CV(gv) ? gv : NULL;