/* gv.c
*
* Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- * 2000, 2001, 2002, 2003, 2004, 2005, 2006, by Larry Wall and others
+ * 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
Perl_newGP(pTHX_ GV *const gv)
{
GP *gp;
- const char *const file = CopFILE(PL_curcop) ? CopFILE(PL_curcop) : "";
+ const char *const file
+ = (PL_curcop && CopFILE(PL_curcop)) ? CopFILE(PL_curcop) : "";
STRLEN len = strlen(file);
U32 hash;
Newxz(gp, 1, GP);
#ifndef PERL_DONT_CREATE_GVSV
- gp->gv_sv = newSV(0);
+ gp->gp_sv = newSV(0);
#endif
- gp->gp_line = CopLINE(PL_curcop);
+ gp->gp_line = PL_curcop ? CopLINE(PL_curcop) : 0;
/* XXX Ideally this cast would be replaced with a change to const char*
in the struct. */
gp->gp_file_hek = share_hek(file, len, hash);
const bool doproto = old_type > SVt_NULL;
const char * const proto = (doproto && SvPOK(gv)) ? SvPVX_const(gv) : NULL;
SV *const has_constant = doproto && SvROK(gv) ? SvRV(gv) : NULL;
+ const U32 exported_constant = has_constant ? SvPCS_IMPORTED(gv) : 0;
assert (!(proto && has_constant));
case SVt_PVIO:
Perl_croak(aTHX_ "Cannot convert a reference to %s to typeglob",
sv_reftype(has_constant, 0));
+ default: NOOP;
}
SvRV_set(gv, NULL);
SvROK_off(gv);
} else
Safefree(SvPVX_mutable(gv));
}
- SvSCREAM_on(gv);
+ SvIOK_off(gv);
+ isGV_with_GP_on(gv);
GvGP(gv) = Perl_newGP(aTHX_ gv);
GvSTASH(gv) = stash;
if (multi || doproto) /* doproto means it _was_ mentioned */
GvMULTI_on(gv);
if (doproto) { /* Replicate part of newSUB here. */
- SvIOK_off(gv);
ENTER;
if (has_constant) {
/* newCONSTSUB takes ownership of the reference from us. */
GvCV(gv) = newCONSTSUB(stash, name, has_constant);
+ /* If this reference was a copy of another, then the subroutine
+ must have been "imported", by a Perl space assignment to a GV
+ from a reference to CV. */
+ if (exported_constant)
+ GvIMPORTED_CV_on(gv);
} else {
/* XXX unsafe for threads if eval_owner isn't held */
(void) start_subparse(0,0); /* Create empty CV in compcv. */
GV** gvp;
CV* cv;
const char *hvname;
+ HV* lastchance = NULL;
/* UNIVERSAL methods should be callable without a stash */
if (!stash) {
level = -1; /* probably appropriate */
- if(!(stash = gv_stashpvs("UNIVERSAL", FALSE)))
+ if(!(stash = gv_stashpvs("UNIVERSAL", 0)))
return 0;
}
HV* basestash;
packlen -= 7;
- basestash = gv_stashpvn(hvname, packlen, TRUE);
+ basestash = gv_stashpvn(hvname, packlen, GV_ADD);
gvp = (GV**)hv_fetchs(basestash, "ISA", FALSE);
if (gvp && (gv = *gvp) != (GV*)&PL_sv_undef && (av = GvAV(gv))) {
gvp = (GV**)hv_fetchs(stash, "ISA", TRUE);
I32 items = AvFILLp(av) + 1;
while (items--) {
SV* const sv = *svp++;
- HV* const basestash = gv_stashsv(sv, FALSE);
+ HV* const basestash = gv_stashsv(sv, 0);
if (!basestash) {
if (ckWARN(WARN_MISC))
Perl_warner(aTHX_ packWARN(WARN_MISC), "Can't locate package %"SVf" for @%s::ISA",
- (void*)sv, hvname);
+ SVfARG(sv), hvname);
continue;
}
gv = gv_fetchmeth(basestash, name, len,
/* if at top level, try UNIVERSAL */
if (level == 0 || level == -1) {
- HV* const lastchance = gv_stashpvs("UNIVERSAL", FALSE);
+ lastchance = gv_stashpvs("UNIVERSAL", 0);
if (lastchance) {
if ((gv = gv_fetchmeth(lastchance, name, len,
SV * const tmpstr = sv_2mortal(Perl_newSVpvf(aTHX_ "%s::SUPER",
CopSTASHPV(PL_curcop)));
/* __PACKAGE__::SUPER stash should be autovivified */
- stash = gv_stashpvn(SvPVX_const(tmpstr), SvCUR(tmpstr), TRUE);
+ stash = gv_stashpvn(SvPVX_const(tmpstr), SvCUR(tmpstr), GV_ADD);
DEBUG_o( Perl_deb(aTHX_ "Treating %s as %s::%s\n",
origname, HvNAME_get(stash), name) );
}
else {
/* don't autovifify if ->NoSuchStash::method */
- stash = gv_stashpvn(origname, nsplit - origname, FALSE);
+ stash = gv_stashpvn(origname, nsplit - origname, 0);
/* however, explicit calls to Pkg::SUPER::method may
happen, and may require autovivification to work */
if (!stash && (nsplit - origname) >= 7 &&
strnEQ(nsplit - 7, "::SUPER", 7) &&
- gv_stashpvn(origname, nsplit - origname - 7, FALSE))
- stash = gv_stashpvn(origname, nsplit - origname, TRUE);
+ gv_stashpvn(origname, nsplit - origname - 7, 0))
+ stash = gv_stashpvn(origname, nsplit - origname, GV_ADD);
}
ostash = stash;
}
sv_setpvn(varsv, packname, packname_len);
sv_catpvs(varsv, "::");
sv_catpvn(varsv, name, len);
- SvTAINTED_off(varsv);
return gv;
}
-/* The "gv" parameter should be the glob known to Perl code as *!
- * The scalar must already have been magicalized.
+
+/* require_tie_mod() internal routine for requiring a module
+ * that implements the logic of automatical ties like %! and %-
+ *
+ * The "gv" parameter should be the glob.
+ * "varpv" holds the name of the var, used for error messages
+ * "namesv" holds the module name
+ * "methpv" holds the method name to test for to check that things
+ * are working reasonably close to as expected
+ * "flags" if flag & 1 then save the scalar before loading.
+ * For the protection of $! to work (it is set by this routine)
+ * the sv slot must already be magicalized.
*/
-STATIC void
-S_require_errno(pTHX_ GV *gv)
+STATIC HV*
+S_require_tie_mod(pTHX_ GV *gv, const char *varpv, SV* namesv, const char *methpv,const U32 flags)
{
dVAR;
- HV* stash = gv_stashpvs("Errno", FALSE);
-
- if (!stash || !(gv_fetchmethod(stash, "TIEHASH"))) {
+ HV* stash = gv_stashsv(namesv, 0);
+
+ if (!stash || !(gv_fetchmethod(stash, methpv))) {
+ SV *module = newSVsv(namesv);
dSP;
PUTBACK;
ENTER;
- save_scalar(gv); /* keep the value of $! */
- Perl_load_module(aTHX_ PERL_LOADMOD_NOIMPORT,
- newSVpvs("Errno"), NULL);
+ if ( flags & 1 )
+ save_scalar(gv);
+ Perl_load_module(aTHX_ PERL_LOADMOD_NOIMPORT, module, NULL);
LEAVE;
SPAGAIN;
- stash = gv_stashpvs("Errno", FALSE);
- if (!stash || !(gv_fetchmethod(stash, "TIEHASH")))
- Perl_croak(aTHX_ "Can't use %%! because Errno.pm is not available");
+ stash = gv_stashsv(namesv, 0);
+ if (!stash)
+ Perl_croak( aTHX_ "panic: Can't use %%%s because %"SVf" is not available",
+ varpv, SVfARG(module));
+ else if (!gv_fetchmethod(stash, methpv))
+ Perl_croak( aTHX_ "panic: Can't use %%%s because %"SVf" does not support method %s",
+ varpv, SVfARG(module), methpv);
}
+ return stash;
}
/*
=for apidoc gv_stashpv
-Returns a pointer to the stash for a specified package. C<name> should
-be a valid UTF-8 string and must be null-terminated. 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.
+Returns a pointer to the stash for a specified package. Uses C<strlen> to
+determine the length of C<name, then calls C<gv_stashpvn()>.
=cut
*/
/*
=for apidoc gv_stashpvn
-Returns a pointer to the stash for a specified package. C<name> should
-be a valid UTF-8 string. The C<namelen> parameter indicates the length of
-the C<name>, in bytes. 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.
+Returns a pointer to the stash for a specified package. The C<namelen>
+parameter indicates the length of the C<name>, in bytes. C<flags> is passed
+to C<gv_fetchpvn_flags()>, so if set to C<GV_ADD> then the package will be
+created if it does not already exist. If the package does not exist and
+C<flags> is 0 (or any other setting that does not create packages) then NULL
+is returned.
+
=cut
*/
HV*
-Perl_gv_stashpvn(pTHX_ const char *name, U32 namelen, I32 create)
+Perl_gv_stashpvn(pTHX_ const char *name, U32 namelen, I32 flags)
{
char smallbuf[128];
char *tmpbuf;
tmpbuf[namelen++] = ':';
tmpbuf[namelen++] = ':';
tmpbuf[namelen] = '\0';
- tmpgv = gv_fetchpvn_flags(tmpbuf, namelen, create, SVt_PVHV);
+ tmpgv = gv_fetchpvn_flags(tmpbuf, namelen, flags, SVt_PVHV);
if (tmpbuf != smallbuf)
Safefree(tmpbuf);
if (!tmpgv)
- return 0;
+ return NULL;
if (!GvHV(tmpgv))
GvHV(tmpgv) = newHV();
stash = GvHV(tmpgv);
/*
=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>.
+Returns a pointer to the stash for a specified package. See C<gv_stashpvn>.
=cut
*/
HV*
-Perl_gv_stashsv(pTHX_ SV *sv, I32 create)
+Perl_gv_stashsv(pTHX_ SV *sv, I32 flags)
{
STRLEN len;
const char * const ptr = SvPV_const(sv,len);
- return gv_stashpvn(ptr, len, create);
+ return gv_stashpvn(ptr, len, flags);
}
HV *stash = NULL;
const I32 no_init = flags & (GV_NOADD_NOINIT | GV_NOINIT);
const I32 no_expand = flags & GV_NOEXPAND;
- const I32 add =
- flags & ~SVf_UTF8 & ~GV_NOADD_NOINIT & ~GV_NOEXPAND & ~GV_NOTQUAL;
+ const I32 add = flags & ~GV_NOADD_MASK;
const char *const name_end = nambeg + full_len;
const char *const name_em1 = name_end - 1;
: sv_type == SVt_PVAV ? "@"
: sv_type == SVt_PVHV ? "%"
: ""), name);
+ GV *gv;
if (USE_UTF8_IN_NAMES)
SvUTF8_on(err);
qerror(err);
- stash = GvHV(gv_fetchpvn_flags("<none>::", 8, GV_ADDMULTI, SVt_PVHV));
+ gv = gv_fetchpvn_flags("<none>::", 8, GV_ADDMULTI, SVt_PVHV);
+ if(!gv) {
+ /* symbol table under destruction */
+ return NULL;
+ }
+ stash = GvHV(gv);
}
else
return NULL;
if (add) {
GvMULTI_on(gv);
gv_init_sv(gv, sv_type);
- if (*name=='!' && sv_type == SVt_PVHV && len==1)
- require_errno(gv);
+ if (sv_type == SVt_PVHV && len == 1 ) {
+ if (*name == '!')
+ require_tie_mod(gv, "!", newSVpvs("Errno"), "TIEHASH", 1);
+ else
+ if (*name == '-' || *name == '+')
+ require_tie_mod(gv, name, newSVpvs("re::Tie::Hash::NamedCapture"), "FETCH", 0);
+
+ }
}
return gv;
} else if (no_init) {
if (strEQ(name2, "RGV")) {
IoFLAGS(GvIOn(gv)) |= IOf_ARGV|IOf_START;
}
+ else if (strEQ(name2, "RGVOUT")) {
+ GvMULTI_on(gv);
+ }
break;
case 'E':
if (strnEQ(name2, "XPORT", 5))
{
const char *pname;
av_push(av, newSVpvn(pname = "NDBM_File",9));
- gv_stashpvn(pname, 9, TRUE);
+ gv_stashpvn(pname, 9, GV_ADD);
av_push(av, newSVpvn(pname = "DB_File",7));
- gv_stashpvn(pname, 7, TRUE);
+ gv_stashpvn(pname, 7, GV_ADD);
av_push(av, newSVpvn(pname = "GDBM_File",9));
- gv_stashpvn(pname, 9, TRUE);
+ gv_stashpvn(pname, 9, GV_ADD);
av_push(av, newSVpvn(pname = "SDBM_File",9));
- gv_stashpvn(pname, 9, TRUE);
+ gv_stashpvn(pname, 9, GV_ADD);
av_push(av, newSVpvn(pname = "ODBM_File",9));
- gv_stashpvn(pname, 9, TRUE);
+ gv_stashpvn(pname, 9, GV_ADD);
}
}
break;
if (strEQ(name2, "NCODING"))
goto magicalize;
break;
+ case '\015': /* $^MATCH */
+ if (strEQ(name2, "ATCH"))
+ goto ro_magicalize;
case '\017': /* $^OPEN */
if (strEQ(name2, "PEN"))
goto magicalize;
break;
+ case '\020': /* $^PREMATCH $^POSTMATCH */
+ if (strEQ(name2, "REMATCH") || strEQ(name2, "OSTMATCH"))
+ goto ro_magicalize;
case '\024': /* ${^TAINT} */
if (strEQ(name2, "AINT"))
goto ro_magicalize;
goto magicalize;
case '!':
-
- /* If %! has been used, automatically load Errno.pm.
- The require will itself set errno, so in order to
- preserve its value we have to set up the magic
- now (rather than going to magicalize)
- */
+ GvMULTI_on(gv);
+ /* If %! has been used, automatically load Errno.pm. */
sv_magic(GvSVn(gv), (SV*)gv, PERL_MAGIC_sv, name, len);
+ /* magicalization must be done before require_tie_mod is called */
if (sv_type == SVt_PVHV)
- require_errno(gv);
+ require_tie_mod(gv, "!", newSVpvs("Errno"), "TIEHASH", 1);
break;
case '-':
- {
- AV* const av = GvAVn(gv);
- sv_magic((SV*)av, NULL, PERL_MAGIC_regdata, NULL, 0);
- SvREADONLY_on(av);
- goto magicalize;
+ case '+':
+ GvMULTI_on(gv); /* no used once warnings here */
+ {
+ bool plus = (*name == '+');
+ SV *stashname = newSVpvs("re::Tie::Hash::NamedCapture");
+ AV* const av = GvAVn(gv);
+ HV *const hv = GvHVn(gv);
+ HV *const hv_tie = newHV();
+ SV *tie = newRV_noinc((SV*)hv_tie);
+
+ sv_bless(tie, gv_stashsv(stashname,GV_ADD));
+ hv_magic(hv, (GV*)tie, PERL_MAGIC_tied);
+ sv_magic((SV*)av, (plus ? (SV*)av : NULL), PERL_MAGIC_regdata, NULL, 0);
+ sv_magic(GvSVn(gv), (SV*)gv, PERL_MAGIC_sv, name, len);
+
+ if (plus)
+ SvREADONLY_on(GvSVn(gv));
+ else
+ Perl_hv_store(aTHX_ hv_tie, STR_WITH_LEN("all"), newSViv(1), 0);
+
+ SvREADONLY_on(hv);
+ SvREADONLY_on(tie);
+ SvREADONLY_on(av);
+
+ if (sv_type == SVt_PVHV)
+ require_tie_mod(gv, name, stashname, "FETCH", 0);
+
+ break;
}
case '*':
case '#':
hv_magic(hv, NULL, PERL_MAGIC_hints);
}
goto magicalize;
-
- case '+':
- {
- AV* const av = GvAVn(gv);
- sv_magic((SV*)av, (SV*)av, PERL_MAGIC_regdata, NULL, 0);
- SvREADONLY_on(av);
- /* FALL THROUGH */
- }
case '\023': /* $^S */
case '1':
case '2':
}
void
-Perl_gv_check(pTHX_ HV *stash)
+Perl_gv_check(pTHX_ const HV *stash)
{
dVAR;
register I32 i;
return;
}
- unshare_hek(gp->gp_file_hek);
+ if (gp->gp_file_hek)
+ unshare_hek(gp->gp_file_hek);
SvREFCNT_dec(gp->gp_sv);
SvREFCNT_dec(gp->gp_av);
/* FIXME - another reference loop GV -> symtab -> GV ?
{
dVAR;
MAGIC* const mg = mg_find((SV*)stash, PERL_MAGIC_overload_table);
- AMT * const amtp = (mg) ? (AMT*)mg->mg_ptr: (AMT *) NULL;
AMT amt;
- if (mg && amtp->was_ok_am == PL_amagic_generation
- && amtp->was_ok_sub == PL_sub_generation)
- return (bool)AMT_OVERLOADED(amtp);
- sv_unmagic((SV*)stash, PERL_MAGIC_overload_table);
+ if (mg) {
+ const AMT * const amtp = (AMT*)mg->mg_ptr;
+ if (amtp->was_ok_am == PL_amagic_generation
+ && amtp->was_ok_sub == PL_sub_generation) {
+ return (bool)AMT_OVERLOADED(amtp);
+ }
+ sv_unmagic((SV*)stash, PERL_MAGIC_overload_table);
+ }
DEBUG_o( Perl_deb(aTHX_ "Recalcing overload magic in package %s\n",HvNAME_get(stash)) );
Gv_AMupdate(stash);
mg = mg_find((SV*)stash, PERL_MAGIC_overload_table);
}
+ assert(mg);
amtp = (AMT*)mg->mg_ptr;
if ( amtp->was_ok_am != PL_amagic_generation
|| amtp->was_ok_sub != PL_sub_generation )
*/
SV* const newref = newSVsv(tmpRef);
SvOBJECT_on(newref);
+ /* As a bit of a source compatibility hack, SvAMAGIC() and
+ friends dereference an RV, to behave the same was as when
+ overloading was stored on the reference, not the referant.
+ Hence we can't use SvAMAGIC_on()
+ */
+ SvFLAGS(newref) |= SVf_AMAGIC;
SvSTASH_set(newref, (HV*)SvREFCNT_inc(SvSTASH(tmpRef)));
return newref;
}
notfound = 1; lr = -1;
} else if (cvp && (cv=cvp[nomethod_amg])) {
notfound = 1; lr = 1;
+ } else if ((amtp && amtp->fallback >= AMGfallYES) && !DEBUG_o_TEST) {
+ /* Skip generating the "no method found" message. */
+ return NULL;
} else {
SV *msg;
if (off==-1) off=method;
if (amtp && amtp->fallback >= AMGfallYES) {
DEBUG_o( Perl_deb(aTHX_ "%s", SvPVX_const(msg)) );
} else {
- Perl_croak(aTHX_ "%"SVf, (void*)msg);
+ Perl_croak(aTHX_ "%"SVf, SVfARG(msg));
}
return NULL;
}
https://perl5.git.perl.org / perl5.git / blobdiff