PP(pp_nextstate)
{
- PL_curcop = (COP*)op;
+ PL_curcop = (COP*)PL_op;
TAINT_NOT; /* Each statement is presumed innocent */
PL_stack_sp = PL_stack_base + cxstack[cxstack_ix].blk_oldsp;
FREETMPS;
{
djSP;
EXTEND(SP,1);
- if (op->op_private & OPpLVAL_INTRO)
+ if (PL_op->op_private & OPpLVAL_INTRO)
PUSHs(save_scalar(cGVOP->op_gv));
else
PUSHs(GvSV(cGVOP->op_gv));
djSP; dPOPTOPssrl;
MAGIC *mg;
- if (op->op_private & OPpASSIGN_BACKWARDS) {
+ if (PL_op->op_private & OPpASSIGN_BACKWARDS) {
SV *temp;
temp = left; left = right; right = temp;
}
{
djSP; dTARGET;
XPUSHs(TARG);
- if (op->op_flags & OPf_MOD) {
- if (op->op_private & OPpLVAL_INTRO)
- SAVECLEARSV(PL_curpad[op->op_targ]);
- else if (op->op_private & OPpDEREF) {
+ if (PL_op->op_flags & OPf_MOD) {
+ if (PL_op->op_private & OPpLVAL_INTRO)
+ SAVECLEARSV(PL_curpad[PL_op->op_targ]);
+ else if (PL_op->op_private & OPpDEREF) {
PUTBACK;
- vivify_ref(PL_curpad[op->op_targ], op->op_private & OPpDEREF);
+ vivify_ref(PL_curpad[PL_op->op_targ], PL_op->op_private & OPpDEREF);
SPAGAIN;
}
}
{
djSP;
AV *av = GvAV((GV*)cSVOP->op_sv);
- U32 lval = op->op_flags & OPf_MOD;
- SV** svp = av_fetch(av, op->op_private, lval);
+ U32 lval = PL_op->op_flags & OPf_MOD;
+ SV** svp = av_fetch(av, PL_op->op_private, lval);
SV *sv = (svp ? *svp : &PL_sv_undef);
EXTEND(SP, 1);
if (!lval && SvGMAGICAL(sv)) /* see note in pp_helem() */
SV* sv = sv_newmortal();
sv_upgrade(sv, SVt_PVLV);
LvTYPE(sv) = '/';
- Copy(&op, &LvTARGOFF(sv), 1, OP*);
+ Copy(&PL_op, &LvTARGOFF(sv), 1, OP*);
XPUSHs(sv);
#else
- XPUSHs((SV*)op);
+ XPUSHs((SV*)PL_op);
#endif
RETURN;
}
register PerlIO *fp;
MAGIC *mg;
- if (op->op_flags & OPf_STACKED)
+ if (PL_op->op_flags & OPf_STACKED)
gv = (GV*)*++MARK;
else
gv = PL_defoutgv;
av = (AV*)SvRV(sv);
if (SvTYPE(av) != SVt_PVAV)
DIE("Not an ARRAY reference");
- if (op->op_flags & OPf_REF) {
+ if (PL_op->op_flags & OPf_REF) {
PUSHs((SV*)av);
RETURN;
}
else {
if (SvTYPE(sv) == SVt_PVAV) {
av = (AV*)sv;
- if (op->op_flags & OPf_REF) {
+ if (PL_op->op_flags & OPf_REF) {
PUSHs((SV*)av);
RETURN;
}
goto wasref;
}
if (!SvOK(sv)) {
- if (op->op_flags & OPf_REF ||
- op->op_private & HINT_STRICT_REFS)
+ if (PL_op->op_flags & OPf_REF ||
+ PL_op->op_private & HINT_STRICT_REFS)
DIE(no_usym, "an ARRAY");
if (PL_dowarn)
warn(warn_uninit);
RETPUSHUNDEF;
}
sym = SvPV(sv,PL_na);
- if (op->op_private & HINT_STRICT_REFS)
+ if (PL_op->op_private & HINT_STRICT_REFS)
DIE(no_symref, sym, "an ARRAY");
gv = (GV*)gv_fetchpv(sym, TRUE, SVt_PVAV);
} else {
gv = (GV*)sv;
}
av = GvAVn(gv);
- if (op->op_private & OPpLVAL_INTRO)
+ if (PL_op->op_private & OPpLVAL_INTRO)
av = save_ary(gv);
- if (op->op_flags & OPf_REF) {
+ if (PL_op->op_flags & OPf_REF) {
PUSHs((SV*)av);
RETURN;
}
hv = (HV*)SvRV(sv);
if (SvTYPE(hv) != SVt_PVHV && SvTYPE(hv) != SVt_PVAV)
DIE("Not a HASH reference");
- if (op->op_flags & OPf_REF) {
+ if (PL_op->op_flags & OPf_REF) {
SETs((SV*)hv);
RETURN;
}
else {
if (SvTYPE(sv) == SVt_PVHV || SvTYPE(sv) == SVt_PVAV) {
hv = (HV*)sv;
- if (op->op_flags & OPf_REF) {
+ if (PL_op->op_flags & OPf_REF) {
SETs((SV*)hv);
RETURN;
}
goto wasref;
}
if (!SvOK(sv)) {
- if (op->op_flags & OPf_REF ||
- op->op_private & HINT_STRICT_REFS)
+ if (PL_op->op_flags & OPf_REF ||
+ PL_op->op_private & HINT_STRICT_REFS)
DIE(no_usym, "a HASH");
if (PL_dowarn)
warn(warn_uninit);
RETSETUNDEF;
}
sym = SvPV(sv,PL_na);
- if (op->op_private & HINT_STRICT_REFS)
+ if (PL_op->op_private & HINT_STRICT_REFS)
DIE(no_symref, sym, "a HASH");
gv = (GV*)gv_fetchpv(sym, TRUE, SVt_PVHV);
} else {
gv = (GV*)sv;
}
hv = GvHVn(gv);
- if (op->op_private & OPpLVAL_INTRO)
+ if (PL_op->op_private & OPpLVAL_INTRO)
hv = save_hash(gv);
- if (op->op_flags & OPf_REF) {
+ if (PL_op->op_flags & OPf_REF) {
SETs((SV*)hv);
RETURN;
}
* special care that assigning the identifier on the left doesn't
* clobber a value on the right that's used later in the list.
*/
- if (op->op_private & OPpASSIGN_COMMON) {
+ if (PL_op->op_private & OPpASSIGN_COMMON) {
for (relem = firstrelem; relem <= lastrelem; relem++) {
/*SUPPRESS 560*/
if (sv = *relem) {
if (PL_delaymagic & ~DM_DELAY) {
if (PL_delaymagic & DM_UID) {
#ifdef HAS_SETRESUID
- (void)setresuid(uid,euid,(Uid_t)-1);
+ (void)setresuid(PL_uid,PL_euid,(Uid_t)-1);
#else
# ifdef HAS_SETREUID
(void)setreuid(PL_uid,PL_euid);
# else
# ifdef HAS_SETRUID
- if ((delaymagic & DM_UID) == DM_RUID) {
- (void)setruid(uid);
- delaymagic &= ~DM_RUID;
+ if ((PL_delaymagic & DM_UID) == DM_RUID) {
+ (void)setruid(PL_uid);
+ PL_delaymagic &= ~DM_RUID;
}
# endif /* HAS_SETRUID */
# ifdef HAS_SETEUID
- if ((delaymagic & DM_UID) == DM_EUID) {
- (void)seteuid(uid);
- delaymagic &= ~DM_EUID;
+ if ((PL_delaymagic & DM_UID) == DM_EUID) {
+ (void)seteuid(PL_uid);
+ PL_delaymagic &= ~DM_EUID;
}
# endif /* HAS_SETEUID */
- if (delaymagic & DM_UID) {
- if (uid != euid)
+ if (PL_delaymagic & DM_UID) {
+ if (PL_uid != PL_euid)
DIE("No setreuid available");
- (void)PerlProc_setuid(uid);
+ (void)PerlProc_setuid(PL_uid);
}
# endif /* HAS_SETREUID */
#endif /* HAS_SETRESUID */
}
if (PL_delaymagic & DM_GID) {
#ifdef HAS_SETRESGID
- (void)setresgid(gid,egid,(Gid_t)-1);
+ (void)setresgid(PL_gid,PL_egid,(Gid_t)-1);
#else
# ifdef HAS_SETREGID
(void)setregid(PL_gid,PL_egid);
# else
# ifdef HAS_SETRGID
- if ((delaymagic & DM_GID) == DM_RGID) {
- (void)setrgid(gid);
- delaymagic &= ~DM_RGID;
+ if ((PL_delaymagic & DM_GID) == DM_RGID) {
+ (void)setrgid(PL_gid);
+ PL_delaymagic &= ~DM_RGID;
}
# endif /* HAS_SETRGID */
# ifdef HAS_SETEGID
- if ((delaymagic & DM_GID) == DM_EGID) {
- (void)setegid(gid);
- delaymagic &= ~DM_EGID;
+ if ((PL_delaymagic & DM_GID) == DM_EGID) {
+ (void)setegid(PL_gid);
+ PL_delaymagic &= ~DM_EGID;
}
# endif /* HAS_SETEGID */
- if (delaymagic & DM_GID) {
- if (gid != egid)
+ if (PL_delaymagic & DM_GID) {
+ if (PL_gid != PL_egid)
DIE("No setregid available");
- (void)PerlProc_setgid(gid);
+ (void)PerlProc_setgid(PL_gid);
}
# endif /* HAS_SETREGID */
#endif /* HAS_SETRESGID */
I32 update_minmatch = 1;
SV *screamer;
- if (op->op_flags & OPf_STACKED)
+ if (PL_op->op_flags & OPf_STACKED)
TARG = POPs;
else {
TARG = DEFSV;
}
}
}
- if (!rx->nparens && !global)
- gimme = G_SCALAR; /* accidental array context? */
safebase = (((gimme == G_ARRAY) || global || !rx->nparens)
&& !PL_sawampersand);
safebase = safebase ? 0 : REXEC_COPY_STR ;
PUTBACK; /* EVAL blocks may use stack */
goto play_it_again;
}
+ else if (!iters)
+ XPUSHs(&PL_sv_yes);
LEAVE_SCOPE(oldsave);
RETURN;
}
STRLEN offset;
PerlIO *fp;
register IO *io = GvIO(PL_last_in_gv);
- register I32 type = op->op_type;
+ register I32 type = PL_op->op_type;
I32 gimme = GIMME_V;
MAGIC *mg;
{
djSP;
register PERL_CONTEXT *cx;
- I32 gimme = OP_GIMME(op, -1);
+ I32 gimme = OP_GIMME(PL_op, -1);
if (gimme == -1) {
if (cxstack_ix >= 0)
SV **svp;
SV *keysv = POPs;
HV *hv = (HV*)POPs;
- U32 lval = op->op_flags & OPf_MOD;
- U32 defer = op->op_private & OPpLVAL_DEFER;
+ U32 lval = PL_op->op_flags & OPf_MOD;
+ U32 defer = PL_op->op_private & OPpLVAL_DEFER;
SV *sv;
if (SvTYPE(hv) == SVt_PVHV) {
PUSHs(lv);
RETURN;
}
- if (op->op_private & OPpLVAL_INTRO) {
+ if (PL_op->op_private & OPpLVAL_INTRO) {
if (HvNAME(hv) && isGV(*svp))
- save_gp((GV*)*svp, !(op->op_flags & OPf_SPECIAL));
+ save_gp((GV*)*svp, !(PL_op->op_flags & OPf_SPECIAL));
else
save_helem(hv, keysv, svp);
}
- else if (op->op_private & OPpDEREF)
- vivify_ref(*svp, op->op_private & OPpDEREF);
+ else if (PL_op->op_private & OPpDEREF)
+ vivify_ref(*svp, PL_op->op_private & OPpDEREF);
}
sv = (svp ? *svp : &PL_sv_undef);
/* This makes C<local $tied{foo} = $tied{foo}> possible.
PMOP *newpm;
I32 gimme;
- if (op->op_flags & OPf_SPECIAL) {
+ if (PL_op->op_flags & OPf_SPECIAL) {
cx = &cxstack[cxstack_ix];
cx->blk_oldpm = PL_curpm; /* fake block should preserve $1 et al */
}
POPBLOCK(cx,newpm);
- gimme = OP_GIMME(op, -1);
+ gimme = OP_GIMME(PL_op, -1);
if (gimme == -1) {
if (cxstack_ix >= 0)
gimme = cxstack[cxstack_ix].blk_gimme;
/* known replacement string? */
dstr = (pm->op_pmflags & PMf_CONST) ? POPs : Nullsv;
- if (op->op_flags & OPf_STACKED)
+ if (PL_op->op_flags & OPf_STACKED)
TARG = POPs;
else {
TARG = DEFSV;
DIE("panic: do_subst");
strend = s + len;
- maxiters = (strend - s) + 10;
+ maxiters = 2*(strend - s) + 10; /* We can match twice at each
+ position, once with zero-length,
+ second time with non-zero. */
if (!rx->prelen && PL_curpm) {
pm = PL_curpm;
register CV *cv;
register PERL_CONTEXT *cx;
I32 gimme;
- bool hasargs = (op->op_flags & OPf_STACKED) != 0;
+ bool hasargs = (PL_op->op_flags & OPf_STACKED) != 0;
if (!sv)
DIE("Not a CODE reference");
sym = SvPV(sv, PL_na);
if (!sym)
DIE(no_usym, "a subroutine");
- if (op->op_private & HINT_STRICT_REFS)
+ if (PL_op->op_private & HINT_STRICT_REFS)
DIE(no_symref, sym, "a subroutine");
cv = perl_get_cv(sym, TRUE);
break;
}
gimme = GIMME_V;
- if ((op->op_private & OPpENTERSUB_DB) && GvCV(PL_DBsub) && !CvNODEBUG(cv))
+ if ((PL_op->op_private & OPpENTERSUB_DB) && GvCV(PL_DBsub) && !CvNODEBUG(cv))
cv = get_db_sub(&sv, cv);
if (!cv)
DIE("No DBsub routine");
if (CvFLAGS(cv) & CVf_LOCKED) {
MAGIC *mg;
if (CvFLAGS(cv) & CVf_METHOD) {
- if (SP > stack_base + TOPMARK)
- sv = *(stack_base + TOPMARK + 1);
+ if (SP > PL_stack_base + TOPMARK)
+ sv = *(PL_stack_base + TOPMARK + 1);
else {
MUTEX_UNLOCK(CvMUTEXP(cv));
croak("no argument for locked method call");
* (3) instead of (2) so we'd have to clone. Would the fact
* that we released the mutex more quickly make up for this?
*/
- if (threadnum &&
+ if (PL_threadnum &&
(svp = hv_fetch(thr->cvcache, (char *)cv, sizeof(cv), FALSE)))
{
/* We already have a clone to use */
AV* av;
I32 items;
#ifdef USE_THREADS
- av = (AV*)curpad[0];
+ av = (AV*)PL_curpad[0];
#else
av = GvAV(PL_defgv);
#endif /* USE_THREADS */
register I32 items = SP - MARK;
AV* padlist = CvPADLIST(cv);
SV** svp = AvARRAY(padlist);
- push_return(op->op_next);
+ push_return(PL_op->op_next);
PUSHBLOCK(cx, CXt_SUB, MARK);
PUSHSUB(cx);
CvDEPTH(cv)++;
}
#ifdef USE_THREADS
if (!hasargs) {
- AV* av = (AV*)curpad[0];
+ AV* av = (AV*)PL_curpad[0];
items = AvFILLp(av) + 1;
if (items) {
SV** svp;
I32 elem = POPi;
AV* av = (AV*)POPs;
- U32 lval = op->op_flags & OPf_MOD;
- U32 defer = (op->op_private & OPpLVAL_DEFER) && (elem > AvFILL(av));
+ U32 lval = PL_op->op_flags & OPf_MOD;
+ U32 defer = (PL_op->op_private & OPpLVAL_DEFER) && (elem > AvFILL(av));
SV *sv;
if (elem > 0)
PUSHs(lv);
RETURN;
}
- if (op->op_private & OPpLVAL_INTRO)
+ if (PL_op->op_private & OPpLVAL_INTRO)
save_aelem(av, elem, svp);
- else if (op->op_private & OPpDEREF)
- vivify_ref(*svp, op->op_private & OPpDEREF);
+ else if (PL_op->op_private & OPpDEREF)
+ vivify_ref(*svp, PL_op->op_private & OPpDEREF);
}
sv = (svp ? *svp : &PL_sv_undef);
if (!lval && SvGMAGICAL(sv)) /* see note in pp_helem() */