* if it walks like a dirhandle, then let's assume that
* this is a dirhandle.
*/
- const char *fh = PL_op->op_type == OP_READDIR ||
+ const char * const fh =
+ PL_op->op_type == OP_READDIR ||
PL_op->op_type == OP_TELLDIR ||
PL_op->op_type == OP_SEEKDIR ||
PL_op->op_type == OP_REWINDDIR ||
GV *gv;
if (!PL_defstash)
- return Nullgv;
+ return NULL;
tmplen = strlen(name) + 2;
if (tmplen < sizeof smallbuf)
sv_setpvn(GvSV(gv), name, tmplen - 2);
#endif
if (PERLDB_LINE)
- hv_magic(GvHVn(gv_AVadd(gv)), Nullgv, PERL_MAGIC_dbfile);
+ hv_magic(GvHVn(gv_AVadd(gv)), NULL, PERL_MAGIC_dbfile);
}
if (tmpbuf != smallbuf)
Safefree(tmpbuf);
{
dVAR;
register GP *gp;
- const bool doproto = SvTYPE(gv) > SVt_NULL;
+ const U32 old_type = SvTYPE(gv);
+ 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;
SvROK_off(gv);
}
- sv_upgrade((SV*)gv, SVt_PVGV);
+
+ if (old_type < SVt_PVGV) {
+ if (old_type >= SVt_PV)
+ SvCUR_set(gv, 0);
+ sv_upgrade((SV*)gv, SVt_PVGV);
+ }
if (SvLEN(gv)) {
if (proto) {
SvPV_set(gv, NULL);
Safefree(SvPVX_mutable(gv));
}
Newxz(gp, 1, GP);
+ SvSCREAM_on(gv);
GvGP(gv) = gp_ref(gp);
#ifdef PERL_DONT_CREATE_GVSV
GvSV(gv) = NULL;
GvFILE(gv) = CopFILE(PL_curcop) ? CopFILE(PL_curcop) : (char *) "";
GvCVGEN(gv) = 0;
GvEGV(gv) = gv;
- sv_magic((SV*)gv, (SV*)gv, PERL_MAGIC_glob, NULL, 0);
GvSTASH(gv) = stash;
if (stash)
Perl_sv_add_backref(aTHX_ (SV*)stash, (SV*)gv);
- GvNAME(gv) = savepvn(name, len);
- GvNAMELEN(gv) = len;
+ gv_name_set(gv, name, len, GV_ADD);
if (multi || doproto) /* doproto means it _was_ mentioned */
GvMULTI_on(gv);
if (doproto) { /* Replicate part of newSUB here. */
gvp = (GV**)hv_fetch(stash, name, len, (level >= 0));
if (!gvp)
- topgv = Nullgv;
+ topgv = NULL;
else {
topgv = *gvp;
if (SvTYPE(topgv) != SVt_PVGV)
return topgv;
/* Stale cached entry: junk it */
SvREFCNT_dec(cv);
- GvCV(topgv) = cv = Nullcv;
+ GvCV(topgv) = cv = NULL;
GvCVGEN(topgv) = 0;
}
else if (GvCVGEN(topgv) == PL_sub_generation)
if (SvTYPE(gv) != SVt_PVGV)
gv_init(gv, stash, "ISA", 3, TRUE);
SvREFCNT_dec(GvAV(gv));
- GvAV(gv) = (AV*)SvREFCNT_inc(av);
+ GvAV(gv) = (AV*)SvREFCNT_inc_simple(av);
}
}
}
--nsplit;
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",
+ 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);
STRLEN packname_len;
if (len == S_autolen && strnEQ(name, S_autoload, S_autolen))
- return Nullgv;
+ return NULL;
if (stash) {
if (SvTYPE(stash) < SVt_PVHV) {
packname = SvPV_const((SV*)stash, packname_len);
}
}
if (!(gv = gv_fetchmeth(stash, S_autoload, S_autolen, FALSE)))
- return Nullgv;
+ return NULL;
cv = GvCV(gv);
if (!(CvROOT(cv) || CvXSUB(cv)))
- return Nullgv;
+ return NULL;
/*
* Inheriting AUTOLOAD for non-methods works ... for now.
"Use of inherited AUTOLOAD for non-method %s::%.*s() is deprecated",
packname, (int)len, name);
- if (CvXSUB(cv)) {
+ if (CvISXSUB(cv)) {
/* rather than lookup/init $AUTOLOAD here
* only to have the XSUB do another lookup for $AUTOLOAD
* and split that value on the last '::',
ENTER;
save_scalar(gv); /* keep the value of $! */
Perl_load_module(aTHX_ PERL_LOADMOD_NOIMPORT,
- newSVpvs("Errno"), Nullsv);
+ newSVpvs("Errno"), NULL);
LEAVE;
SPAGAIN;
stash = gv_stashpvs("Errno", FALSE);
if (!stash)
stash = PL_defstash;
if (!stash || !SvREFCNT(stash)) /* symbol table under destruction */
- return Nullgv;
+ return NULL;
len = name_cursor - name;
if (len > 0) {
tmpbuf[len++] = ':';
tmpbuf[len] = '\0';
gvp = (GV**)hv_fetch(stash,tmpbuf,len,add);
- gv = gvp ? *gvp : Nullgv;
+ gv = gvp ? *gvp : NULL;
if (gv && gv != (GV*)&PL_sv_undef) {
if (SvTYPE(gv) != SVt_PVGV)
gv_init(gv, stash, tmpbuf, len, (add & GV_ADDMULTI));
if (tmpbuf != smallbuf)
Safefree(tmpbuf);
if (!gv || gv == (GV*)&PL_sv_undef)
- return Nullgv;
+ return NULL;
if (!(stash = GvHV(gv)))
stash = GvHV(gv) = newHV();
stash = GvHV(gv_fetchpvn_flags("<none>::", 8, GV_ADDMULTI, SVt_PVHV));
}
else
- return Nullgv;
+ return NULL;
}
if (!SvREFCNT(stash)) /* symbol table under destruction */
- return Nullgv;
+ return NULL;
gvp = (GV**)hv_fetch(stash,name,len,add);
if (!gvp || *gvp == (GV*)&PL_sv_undef)
- return Nullgv;
+ return NULL;
gv = *gvp;
if (SvTYPE(gv) == SVt_PVGV) {
if (add) {
if (len > 1) {
#ifndef EBCDIC
if (*name > 'V' ) {
+ /*EMPTY*/;
/* Nothing else to do.
The compiler will probably turn the switch statement into a
branch table. Make sure we avoid even that small overhead for
if (strEQ(name2, "VERLOAD")) {
HV* const hv = GvHVn(gv);
GvMULTI_on(gv);
- hv_magic(hv, Nullgv, PERL_MAGIC_overload);
+ hv_magic(hv, NULL, PERL_MAGIC_overload);
}
break;
case 'S':
}
GvMULTI_on(gv);
hv = GvHVn(gv);
- hv_magic(hv, Nullgv, PERL_MAGIC_sig);
+ hv_magic(hv, NULL, PERL_MAGIC_sig);
for (i = 1; i < SIG_SIZE; i++) {
SV * const * const init = hv_fetch(hv, PL_sig_name[i], strlen(PL_sig_name[i]), 1);
if (init)
goto ro_magicalize;
if (strEQ(name2, "TF8LOCALE"))
goto ro_magicalize;
+ if (strEQ(name2, "TF8CACHE"))
+ goto magicalize;
break;
case '\027': /* $^WARNING_BITS */
if (strEQ(name2, "ARNING_BITS"))
case '-':
{
AV* const av = GvAVn(gv);
- sv_magic((SV*)av, Nullsv, PERL_MAGIC_regdata, NULL, 0);
+ sv_magic((SV*)av, NULL, PERL_MAGIC_regdata, NULL, 0);
SvREADONLY_on(av);
goto magicalize;
}
{
dVAR;
return gv_fetchpv(Perl_form(aTHX_ "%s::_GEN_%ld", pack, (long)PL_gensym++),
- TRUE, SVt_PVGV);
+ GV_ADD, SVt_PVGV);
}
/* hopefully this is only called on local symbol table entries */
if (gp->gp_cvgen) {
/* multi-named GPs cannot be used for method cache */
SvREFCNT_dec(gp->gp_cv);
- gp->gp_cv = Nullcv;
+ gp->gp_cv = NULL;
gp->gp_cvgen = 0;
}
else {
dVAR;
GP* gp;
- if (!gv || !(gp = GvGP(gv)))
+ if (!gv || !isGV_with_GP(gv) || !(gp = GvGP(gv)))
return;
if (gp->gp_refcnt == 0) {
if (ckWARN_d(WARN_INTERNAL))
if (--gp->gp_refcnt > 0) {
if (gp->gp_egv == gv)
gp->gp_egv = 0;
+ GvGP(gv) = 0;
return;
}
int i;
for (i = 1; i < NofAMmeth; i++) {
CV * const cv = amtp->table[i];
- if (cv != Nullcv) {
+ if (cv) {
SvREFCNT_dec((SV *) cv);
- amtp->table[i] = Nullcv;
+ amtp->table[i] = NULL;
}
}
}
lim = DESTROY_amg; /* Skip overloading entries. */
#ifdef PERL_DONT_CREATE_GVSV
else if (!sv) {
- /* Equivalent to !SvTRUE and !SvOK */
+ /*EMPTY*/; /* Equivalent to !SvTRUE and !SvOK */
}
#endif
else if (SvTRUE(sv))
amt.fallback=AMGfallNEVER;
for (i = 1; i < lim; i++)
- amt.table[i] = Nullcv;
+ amt.table[i] = NULL;
for (; i < NofAMmeth; i++) {
const char * const cooky = PL_AMG_names[i];
/* Human-readable form, for debugging: */
cv = (CV*)gv;
filled = 1;
}
- amt.table[i]=(CV*)SvREFCNT_inc(cv);
+ amt.table[i]=(CV*)SvREFCNT_inc_simple(cv);
}
if (filled) {
AMT_AMAGIC_on(&amt);
AMT *amtp;
if (!stash || !HvNAME_get(stash))
- return Nullcv;
+ return NULL;
mg = mg_find((SV*)stash, PERL_MAGIC_overload_table);
if (!mg) {
do_update:
return ret;
}
- return Nullcv;
+ return NULL;
}
CATCH_SET(TRUE);
Zero(&myop, 1, BINOP);
myop.op_last = (OP *) &myop;
- myop.op_next = Nullop;
+ myop.op_next = NULL;
myop.op_flags = OPf_WANT_SCALAR | OPf_STACKED;
PUSHSTACKi(PERLSI_OVERLOAD);
bool
Perl_is_gv_magical(pTHX_ const char *name, STRLEN len, U32 flags)
{
+ PERL_UNUSED_CONTEXT;
PERL_UNUSED_ARG(flags);
if (len > 1) {
return FALSE;
}
+void
+Perl_gv_name_set(pTHX_ GV *gv, const char *name, U32 len, U32 flags)
+{
+ dVAR;
+ U32 hash;
+
+ PERL_UNUSED_ARG(flags);
+
+ if (len > I32_MAX)
+ Perl_croak(aTHX_ "panic: gv name too long (%"UVuf")", (UV) len);
+
+ if (!(flags & GV_ADD) && GvNAME_HEK(gv)) {
+ unshare_hek(GvNAME_HEK(gv));
+ }
+
+ PERL_HASH(hash, name, len);
+ GvNAME_HEK(gv) = name ? share_hek(name, len, hash) : 0;
+}
+
/*
* Local variables:
* c-indentation-style: bsd