/* gv.c
*
- * Copyright (c) 1991-1999, Larry Wall
+ * Copyright (c) 1991-2000, Larry Wall
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
STRLEN tmplen;
GV *gv;
+ if (!PL_defstash)
+ return Nullgv;
+
tmplen = strlen(name) + 2;
if (tmplen < sizeof smallbuf)
tmpbuf = smallbuf;
}
}
+/*
+=for apidoc gv_fetchmeth
+
+Returns the glob with the given C<name> and a defined subroutine or
+C<NULL>. The glob lives in the given C<stash>, or in the stashes
+accessible via @ISA and @UNIVERSAL.
+
+The argument C<level> should be either 0 or -1. If C<level==0>, as a
+side-effect creates a glob with the given C<name> in the given C<stash>
+which in the case of success contains an alias for the subroutine, and sets
+up caching info for this glob. Similarly for all the searched stashes.
+
+This function grants C<"SUPER"> token as a postfix of the stash name. The
+GV returned from C<gv_fetchmeth> may be a method cache entry, which is not
+visible to Perl code. So when calling C<call_sv>, you should not use
+the GV directly; instead, you should use the method's CV, which can be
+obtained from the GV with the C<GvCV> macro.
+
+=cut
+*/
+
GV *
Perl_gv_fetchmeth(pTHX_ HV *stash, const char *name, STRLEN len, I32 level)
{
topgv = *gvp;
if (SvTYPE(topgv) != SVt_PVGV)
gv_init(topgv, stash, name, len, TRUE);
- if (cv = GvCV(topgv)) {
+ if ((cv = GvCV(topgv))) {
/* If genuine method or valid cache entry, use it */
if (!GvCVGEN(topgv) || GvCVGEN(topgv) == PL_sub_generation)
return topgv;
if (level == 0 || level == -1) {
HV* lastchance;
- if (lastchance = gv_stashpvn("UNIVERSAL", 9, FALSE)) {
- if (gv = gv_fetchmeth(lastchance, name, len,
- (level >= 0) ? level + 1 : level - 1)) {
+ if ((lastchance = gv_stashpvn("UNIVERSAL", 9, FALSE))) {
+ if ((gv = gv_fetchmeth(lastchance, name, len,
+ (level >= 0) ? level + 1 : level - 1)))
+ {
gotcha:
/*
* Cache method in topgv if:
(cv = GvCV(gv)) &&
(CvROOT(cv) || CvXSUB(cv)))
{
- if (cv = GvCV(topgv))
+ if ((cv = GvCV(topgv)))
SvREFCNT_dec(cv);
GvCV(topgv) = (CV*)SvREFCNT_inc(GvCV(gv));
GvCVGEN(topgv) = PL_sub_generation;
return 0;
}
+/*
+=for apidoc gv_fetchmethod
+
+See L<gv_fetchmethod_autoload>.
+
+=cut
+*/
+
GV *
Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name)
{
return gv_fetchmethod_autoload(stash, name, TRUE);
}
+/*
+=for apidoc gv_fetchmethod_autoload
+
+Returns the glob which contains the subroutine to call to invoke the method
+on the C<stash>. In fact in the presence of autoloading this may be the
+glob for "AUTOLOAD". In this case the corresponding variable $AUTOLOAD is
+already setup.
+
+The third parameter of C<gv_fetchmethod_autoload> determines whether
+AUTOLOAD lookup is performed if the given method is not present: non-zero
+means yes, look for AUTOLOAD; zero means no, don't look for AUTOLOAD.
+Calling C<gv_fetchmethod> is equivalent to calling C<gv_fetchmethod_autoload>
+with a non-zero C<autoload> parameter.
+
+These functions grant C<"SUPER"> token as a prefix of the method name. Note
+that if you want to keep the returned glob for a long time, you need to
+check for it being "AUTOLOAD", since at the later time the call may load a
+different subroutine due to $AUTOLOAD changing its value. Use the glob
+created via a side effect to do this.
+
+These functions have the same side-effects and as C<gv_fetchmeth> with
+C<level==0>. C<name> should be writable if contains C<':'> or C<'
+''>. The warning against passing the GV returned by C<gv_fetchmeth> to
+C<call_sv> apply equally to these functions.
+
+=cut
+*/
+
GV *
Perl_gv_fetchmethod_autoload(pTHX_ HV *stash, const char *name, I32 autoload)
{
if ((nsplit - origname) == 5 && strnEQ(origname, "SUPER", 5)) {
/* ->SUPER::method should really be looked up in original stash */
SV *tmpstr = sv_2mortal(Perl_newSVpvf(aTHX_ "%s::SUPER",
- HvNAME(PL_curcop->cop_stash)));
+ CopSTASHPV(PL_curcop)));
stash = gv_stashpvn(SvPVX(tmpstr), SvCUR(tmpstr), TRUE);
DEBUG_o( Perl_deb(aTHX_ "Treating %s as %s::%s\n",
origname, HvNAME(stash), name) );
return gv;
}
+/*
+=for apidoc gv_stashpv
+
+Returns a pointer to the stash for a specified package. C<name> should
+be a valid UTF-8 string. If C<create> is set then the package will be
+created if it does not already exist. If C<create> is not set and the
+package does not exist then NULL is returned.
+
+=cut
+*/
+
HV*
Perl_gv_stashpv(pTHX_ const char *name, I32 create)
{
return stash;
}
+/*
+=for apidoc gv_stashsv
+
+Returns a pointer to the stash for a specified package, which must be a
+valid UTF-8 string. See C<gv_stashpv>.
+
+=cut
+*/
+
HV*
Perl_gv_stashsv(pTHX_ SV *sv, I32 create)
{
name++;
for (namend = name; *namend; namend++) {
- if ((*namend == '\'' && namend[1]) ||
- (*namend == ':' && namend[1] == ':'))
+ if ((*namend == ':' && namend[1] == ':')
+ || (*namend == '\'' && namend[1]))
{
if (!stash)
stash = PL_defstash;
/* No stash in name, so see how we can default */
if (!stash) {
- if (isIDFIRST(*name)
- || (IN_UTF8 && ((*name & 0xc0) == 0xc0) && isIDFIRST_utf8((U8*)name)))
- {
+ if (isIDFIRST_lazy(name)) {
bool global = FALSE;
if (isUPPER(*name)) {
else if ((COP*)PL_curcop == &PL_compiling) {
stash = PL_curstash;
if (add && (PL_hints & HINT_STRICT_VARS) &&
- !(add & GV_ADDOUR) &&
sv_type != SVt_PVCV &&
sv_type != SVt_PVGV &&
sv_type != SVt_PVFM &&
{
stash = 0;
}
- else if (sv_type == SVt_PV && !GvIMPORTED_SV(*gvp) ||
- sv_type == SVt_PVAV && !GvIMPORTED_AV(*gvp) ||
- sv_type == SVt_PVHV && !GvIMPORTED_HV(*gvp) )
+ else if ((sv_type == SVt_PV && !GvIMPORTED_SV(*gvp)) ||
+ (sv_type == SVt_PVAV && !GvIMPORTED_AV(*gvp)) ||
+ (sv_type == SVt_PVHV && !GvIMPORTED_HV(*gvp)) )
{
Perl_warn(aTHX_ "Variable \"%c%s\" is not imported",
sv_type == SVt_PVAV ? '@' :
}
}
else
- stash = PL_curcop->cop_stash;
+ stash = CopSTASH(PL_curcop);
}
else
stash = PL_defstash;
if (strEQ(name, "SIG")) {
HV *hv;
I32 i;
+ if (!PL_psig_ptr) {
+ int sig_num[] = { SIG_NUM };
+ New(73, PL_psig_ptr, sizeof(sig_num)/sizeof(*sig_num), SV*);
+ New(73, PL_psig_name, sizeof(sig_num)/sizeof(*sig_num), SV*);
+ }
GvMULTI_on(gv);
hv = GvHVn(gv);
hv_magic(hv, gv, 'S');
- for(i = 1; PL_sig_name[i]; i++) {
+ for (i = 1; PL_sig_name[i]; i++) {
SV ** init;
init = hv_fetch(hv, PL_sig_name[i], strlen(PL_sig_name[i]), 1);
if (init)
case '\\':
case '/':
case '|':
- case '\001':
- case '\003':
- case '\004':
- case '\005':
- case '\006':
- case '\010':
- case '\011': /* NOT \t in EBCDIC */
- case '\017':
- case '\020':
- case '\024':
+ case '\001': /* $^A */
+ case '\003': /* $^C */
+ case '\004': /* $^D */
+ case '\005': /* $^E */
+ case '\006': /* $^F */
+ case '\010': /* $^H */
+ case '\011': /* $^I, NOT \t in EBCDIC */
+ case '\017': /* $^O */
+ case '\020': /* $^P */
+ case '\024': /* $^T */
if (len > 1)
break;
goto magicalize;
- case '\023':
+ case '\023': /* $^S */
if (len > 1)
break;
goto ro_magicalize;
- case '\027': /* $^W & $^Warnings */
- if (len > 1 && strNE(name, "\027arnings"))
+ case '\027': /* $^W & $^WARNING_BITS */
+ if (len > 1 && strNE(name, "\027ARNING_BITS")
+ && strNE(name, "\027IDE_SYSTEM_CALLS"))
break;
goto magicalize;
sv_magic(GvSV(gv), (SV*)gv, 0, name, len);
break;
- case '\014':
+ case '\014': /* $^L */
if (len > 1)
break;
sv_setpv(GvSV(gv),"\f");
if (len == 1) {
SV *sv = GvSV(gv);
(void)SvUPGRADE(sv, SVt_PVNV);
- sv_setpv(sv, PL_patchlevel);
- (void)sv_2nv(sv);
+ SvNVX(sv) = SvNVX(PL_patchlevel);
+ SvNOK_on(sv);
+ (void)SvPV_nolen(sv);
SvREADONLY_on(sv);
}
break;
+ case '\026': /* $^V */
+ if (len == 1) {
+ SV *sv = GvSV(gv);
+ GvSV(gv) = SvREFCNT_inc(PL_patchlevel);
+ SvREFCNT_dec(sv);
+ }
+ break;
}
return gv;
}
{
HV *hv = GvSTASH(gv);
if (!hv) {
- SvOK_off(sv);
+ (void)SvOK_off(sv);
return;
}
sv_setpv(sv, prefix ? prefix : "");
GP*
Perl_gp_ref(pTHX_ GP *gp)
{
+ if (!gp)
+ return (GP*)NULL;
gp->gp_refcnt++;
if (gp->gp_cv) {
if (gp->gp_cvgen) {
{
dTHR;
GP* gp;
- CV* cv;
if (!gv || !(gp = GvGP(gv)))
return;
bool
Perl_Gv_AMupdate(pTHX_ HV *stash)
{
- dTHR;
- GV** gvp;
- HV* hv;
+ dTHR;
GV* gv;
CV* cv;
MAGIC* mg=mg_find((SV*)stash,'c');
AMT *amtp = (mg) ? (AMT*)mg->mg_ptr: (AMT *) NULL;
AMT amt;
STRLEN n_a;
+#ifdef OVERLOAD_VIA_HASH
+ GV** gvp;
+ HV* hv;
+#endif
if (mg && amtp->was_ok_am == PL_amagic_generation
&& amtp->was_ok_sub == PL_sub_generation)
int i;
const char *cp;
SV* sv = NULL;
- SV** svp;
/* Work with "fallback" key, which we assume to be first in PL_AMG_names */
- if ( cp = PL_AMG_names[0] ) {
+ if ((cp = PL_AMG_names[0])) {
/* Try to find via inheritance. */
gv = gv_fetchmeth(stash, "()", 2, -1); /* A cookie: "()". */
- if (gv) sv = GvSV(gv);
-
- if (!gv) goto no_table;
- else if (SvTRUE(sv)) amt.fallback=AMGfallYES;
- else if (SvOK(sv)) amt.fallback=AMGfallNEVER;
+ if (gv)
+ sv = GvSV(gv);
+
+ if (!gv)
+ goto no_table;
+ else if (SvTRUE(sv))
+ amt.fallback=AMGfallYES;
+ else if (SvOK(sv))
+ amt.fallback=AMGfallNEVER;
}
for (i = 1; i < NofAMmeth; i++) {
}
break;
case neg_amg:
- if (cv = cvp[off=subtr_amg]) {
+ if ((cv = cvp[off=subtr_amg])) {
right = left;
left = sv_2mortal(newSViv(0));
lr = 1;
if (amtp && amtp->fallback >= AMGfallYES) {
DEBUG_o( Perl_deb(aTHX_ "%s", SvPVX(msg)) );
} else {
- Perl_croak(aTHX_ "%_", msg);
+ Perl_croak(aTHX_ "%"SVf, msg);
}
return NULL;
}
PUSHs((SV*)cv);
PUTBACK;
- if (PL_op = Perl_pp_entersub(aTHX))
+ if ((PL_op = Perl_pp_entersub(aTHX)))
CALLRUNOPS(aTHX);
LEAVE;
SPAGAIN;
https://perl5.git.perl.org / perl5.git / blobdiff