struct block_sub {
OP * retop; /* op to execute on exit from sub */
/* Above here is the same for sub, format and eval. */
+ PAD *prevcomppad; /* the caller's PL_comppad */
CV * cv;
/* Above here is the same for sub and format. */
I32 olddepth;
- I32 old_savestack_ix; /* saved PL_savestack_ix (also CXt_NULL) */
AV *savearray;
- SSize_t old_tmpsfloor; /* also used in CXt_NULL sort block */
- PAD *prevcomppad; /* the caller's PL_comppad */
};
struct block_format {
OP * retop; /* op to execute on exit from sub */
/* Above here is the same for sub, format and eval. */
+ PAD *prevcomppad; /* the caller's PL_comppad */
CV * cv;
/* Above here is the same for sub and format. */
GV * gv;
GV * dfoutgv;
- PAD *prevcomppad; /* the caller's PL_comppad */
};
+/* free all savestack items back to the watermark of the specified context */
+
+#define CX_LEAVE_SCOPE(cx) LEAVE_SCOPE(cx->cx_old_savestack_ix)
+
/* base for the next two macros. Don't use directly.
* The context frame holds a reference to the CV so that it can't be
* freed while we're executing it */
cx->blk_sub.prevcomppad = PL_comppad; \
cx->cx_type |= (hasargs) ? CXp_HASARGS : 0; \
cx->blk_sub.retop = NULL; \
- SvREFCNT_inc_simple_void_NN(cv); \
- cx->blk_sub.old_tmpsfloor = PL_tmps_floor; \
- PL_tmps_floor = PL_tmps_ix;
+ SvREFCNT_inc_simple_void_NN(cv);
#define PUSHSUB_GET_LVALUE_MASK(func) \
/* If the context is indeterminate, then only the lvalue */ \
cx->blk_format.dfoutgv = PL_defoutgv; \
cx->blk_format.prevcomppad = PL_comppad; \
cx->blk_u16 = 0; \
+ cx->cx_old_savestack_ix = PL_savestack_ix; \
SvREFCNT_inc_simple_void_NN(cv); \
CvDEPTH(cv)++; \
SvREFCNT_inc_void(cx->blk_format.dfoutgv)
AvFILLp(ary) = -1; \
} STMT_END
-#define POPSUB(cx,sv) \
+#define POPSUB(cx) \
STMT_START { \
- LEAVE_SCOPE(cx->blk_sub.old_savestack_ix); \
if (!(cx->blk_u16 & CxPOPSUB_DONE)) { \
cx->blk_u16 |= CxPOPSUB_DONE; \
RETURN_PROBE(CvNAMED(cx->blk_sub.cv) \
} \
} \
} \
- PL_tmps_floor = cx->blk_sub.old_tmpsfloor; \
PL_comppad = cx->blk_sub.prevcomppad; \
PL_curpad = LIKELY(PL_comppad) ? AvARRAY(PL_comppad) : NULL; \
- sv = MUTABLE_SV(cx->blk_sub.cv); \
- CvDEPTH((const CV*)sv) = cx->blk_sub.olddepth; \
- } STMT_END
-
-#define LEAVESUB(sv) \
- STMT_START { \
- SvREFCNT_dec(sv); \
+ CvDEPTH((const CV*)cx->blk_sub.cv) = cx->blk_sub.olddepth; \
+ SvREFCNT_dec_NN(cx->blk_sub.cv); \
} STMT_END
#define POPFORMAT(cx) \
GV * const dfuot = cx->blk_format.dfoutgv; \
cx->blk_u16 |= CxPOPSUB_DONE; \
setdefout(dfuot); \
- LEAVE_SCOPE(PL_scopestack[cx->blk_oldscopesp-1]); \
PL_comppad = cx->blk_format.prevcomppad; \
PL_curpad = LIKELY(PL_comppad) ? AvARRAY(PL_comppad) : NULL; \
--CvDEPTH(cv); \
SV **svp; /* for lexicals: address of pad slot */
GV *gv; /* for package vars */
} itervar_u;
+ SV *itersave; /* the original iteration var */
union {
struct { /* valid if type is LOOP_FOR or LOOP_PLAIN (but {NULL,0})*/
AV * ary; /* use the stack if this is NULL */
#endif
};
-#define CxITERVAR(c) \
- (CxPADLOOP(c) \
- ? (c)->blk_loop.itervar_u.svp \
- : (c)->blk_loop.itervar_u.svp \
- ? isGV((c)->blk_loop.itervar_u.gv) \
- ? &GvSV((c)->blk_loop.itervar_u.gv) \
- : (SV **)&(c)->blk_loop.itervar_u.gv \
- : (SV**)NULL)
+#define CxITERVAR(c) \
+ (CxPADLOOP(c) \
+ ? (c)->blk_loop.itervar_u.svp \
+ : ((c)->cx_type & CXp_FOR_GV) \
+ ? &GvSV((c)->blk_loop.itervar_u.gv) \
+ : (SV **)&(c)->blk_loop.itervar_u.gv)
#define CxLABEL(c) (0 + CopLABEL((c)->blk_oldcop))
#define CxLABEL_len(c,len) (0 + CopLABEL_len((c)->blk_oldcop, len))
cx->blk_loop.my_op = cLOOP; \
cx->blk_loop.state_u.ary.ary = NULL; \
cx->blk_loop.state_u.ary.ix = 0; \
- cx->blk_loop.itervar_u.svp = NULL;
+ cx->cx_old_savestack_ix = PL_savestack_ix; \
+ cx->blk_loop.itervar_u.svp = NULL; \
+ cx->blk_loop.itersave = NULL;
#ifdef USE_ITHREADS
# define PUSHLOOP_FOR_setpad(c) (c)->blk_loop.oldcomppad = PL_comppad
# define PUSHLOOP_FOR_setpad(c) NOOP
#endif
-#define PUSHLOOP_FOR(cx, ivar, s) \
+#define PUSHLOOP_FOR(cx, ivar, isave, s) \
cx->blk_loop.resetsp = s - PL_stack_base; \
cx->blk_loop.my_op = cLOOP; \
cx->blk_loop.state_u.ary.ary = NULL; \
cx->blk_loop.state_u.ary.ix = 0; \
cx->blk_loop.itervar_u.svp = (SV**)(ivar); \
+ cx->cx_old_savestack_ix = PL_savestack_ix; \
+ cx->blk_loop.itersave = isave; \
PUSHLOOP_FOR_setpad(cx);
#define POPLOOP(cx) \
SvREFCNT_dec_NN(cx->blk_loop.state_u.lazysv.cur); \
SvREFCNT_dec_NN(cx->blk_loop.state_u.lazysv.end); \
} \
- if (CxTYPE(cx) == CXt_LOOP_FOR) \
- SvREFCNT_dec(cx->blk_loop.state_u.ary.ary);
+ else if (CxTYPE(cx) == CXt_LOOP_FOR) \
+ SvREFCNT_dec(cx->blk_loop.state_u.ary.ary); \
+ if (cx->cx_type & (CXp_FOR_PAD|CXp_FOR_GV)) { \
+ SV *cursv; \
+ SV **svp = (cx)->blk_loop.itervar_u.svp; \
+ if ((cx->cx_type & CXp_FOR_GV)) \
+ svp = &GvSV((GV*)svp); \
+ cursv = *svp; \
+ *svp = cx->blk_loop.itersave; \
+ SvREFCNT_dec(cursv); \
+ }
/* given/when context */
struct block_givwhen {
OP *leave_op;
+ SV *defsv_save; /* the original $_ */
};
-#define PUSHGIVEN(cx) \
+#define PUSHWHEN(cx) \
+ cx->cx_old_savestack_ix = PL_savestack_ix; \
cx->blk_givwhen.leave_op = cLOGOP->op_other;
-#define PUSHWHEN PUSHGIVEN
+#define PUSHGIVEN(cx, orig_var) \
+ PUSHWHEN(cx); \
+ cx->blk_givwhen.defsv_save = orig_var;
+
+#define POPWHEN(cx) \
+ NOOP;
+
+#define POPGIVEN(cx) \
+ SvREFCNT_dec(GvSV(PL_defgv)); \
+ GvSV(PL_defgv) = cx->blk_givwhen.defsv_save;
+
+
+/* basic block, i.e. pp_enter/leave */
+
+#define PUSHBASICBLK(cx) \
+ cx->cx_old_savestack_ix = PL_savestack_ix;
+
+#define POPBASICBLK(cx) \
+ NOOP;
+
/* context common to subroutines, evals and loops */
struct block {
I32 blku_oldmarksp; /* mark stack index */
I32 blku_oldscopesp; /* scope stack index */
PMOP * blku_oldpm; /* values of pattern match vars */
+ SSize_t blku_old_tmpsfloor; /* saved PL_tmps_floor */
union {
struct block_sub blku_sub;
#define DEBUG_CX(action) \
DEBUG_l( \
- Perl_deb(aTHX_ "CX %ld %s %s (scope %ld,%ld) at %s:%d\n", \
+ Perl_deb(aTHX_ "CX %ld %s %s (scope %ld,%ld) (save %ld,%ld) at %s:%d\n",\
(long)cxstack_ix, \
action, \
PL_block_type[CxTYPE(&cxstack[cxstack_ix])], \
(long)PL_scopestack_ix, \
(long)(cxstack[cxstack_ix].blk_oldscopesp), \
+ (long)PL_savestack_ix, \
+ (long)(cxstack[cxstack_ix].cx_old_savestack_ix), \
__FILE__, __LINE__));
/* Enter a block. */
cx->blk_oldscopesp = PL_scopestack_ix, \
cx->blk_oldpm = PL_curpm, \
cx->blk_gimme = (U8)gimme; \
+ cx->cx_u.cx_blk.blku_old_tmpsfloor = PL_tmps_floor; \
+ PL_tmps_floor = PL_tmps_ix; \
DEBUG_CX("PUSH");
/* Exit a block (RETURN and LAST). */
-#define POPBLOCK(cx,pm) \
+#define POPBLOCK(cx) \
DEBUG_CX("POP"); \
- cx = &cxstack[cxstack_ix--], \
- newsp = PL_stack_base + cx->blk_oldsp, \
PL_curcop = cx->blk_oldcop, \
PL_markstack_ptr = PL_markstack + cx->blk_oldmarksp, \
PL_scopestack_ix = cx->blk_oldscopesp, \
- pm = cx->blk_oldpm, \
- gimme = cx->blk_gimme;
+ /* LEAVE_SCOPE() should have made this true. /(?{})/ cheats
+ * and leaves a CX entry lying around for repeated use, so
+ * skip for multicall */ \
+ assert( (CxTYPE(cx) == CXt_SUB && CxMULTICALL(cx)) \
+ || PL_savestack_ix == cx->cx_old_savestack_ix); \
+ PL_tmps_floor = cx->cx_u.cx_blk.blku_old_tmpsfloor; \
+ PL_curpm = cx->blk_oldpm;
/* Continue a block elsewhere (NEXT and REDO). */
#define TOPBLOCK(cx) \
U8 sbu_type; /* what kind of context this is */
U8 sbu_rflags;
U16 sbu_rxtainted; /* matches struct block */
- I32 sbu_oldsave;
SSize_t sbu_iters;
SSize_t sbu_maxiters;
char * sbu_orig;
#define sb_iters cx_u.cx_subst.sbu_iters
#define sb_maxiters cx_u.cx_subst.sbu_maxiters
#define sb_rflags cx_u.cx_subst.sbu_rflags
-#define sb_oldsave cx_u.cx_subst.sbu_oldsave
#define sb_rxtainted cx_u.cx_subst.sbu_rxtainted
#define sb_orig cx_u.cx_subst.sbu_orig
#define sb_dstr cx_u.cx_subst.sbu_dstr
#ifdef PERL_CORE
# define PUSHSUBST(cx) CXINC, cx = &cxstack[cxstack_ix], \
+ cx->cx_old_savestack_ix = oldsave, \
cx->sb_iters = iters, \
cx->sb_maxiters = maxiters, \
cx->sb_rflags = r_flags, \
- cx->sb_oldsave = oldsave, \
cx->sb_rxtainted = rxtainted, \
cx->sb_orig = orig, \
cx->sb_dstr = dstr, \
#define CxONCE(cx) ((cx)->cx_type & CXp_ONCE)
struct context {
+ I32 cx_old_savestack_ix; /* saved PL_savestack_ix */
union {
struct block cx_blk;
struct subst cx_subst;
/* If you re-order these, there is also an array of uppercase names in perl.h
and a static array of context names in pp_ctl.c */
#define CXTYPEMASK 0xf
-#define CXt_NULL 0
+#define CXt_NULL 0 /* currently only used for sort BLOCK */
#define CXt_WHEN 1
#define CXt_BLOCK 2
/* When micro-optimising :-) keep GIVEN next to the LOOPs, as these 5 share a
#define CXt_SUBST 11
/* SUBST doesn't feature in all switch statements. */
-/* private flags for CXt_SUB and CXt_NULL
- However, this is checked in many places which do not check the type, so
- this bit needs to be kept clear for most everything else. For reasons I
- haven't investigated, it can coexist with CXp_FOR_DEF */
-#define CXp_MULTICALL 0x10 /* part of a multicall (so don't
- tear down context on exit). */
-
/* private flags for CXt_SUB and CXt_FORMAT */
+#define CXp_MULTICALL 0x10 /* part of a multicall (so don't tear down
+ context on exit). (not CXt_FORMAT) */
#define CXp_HASARGS 0x20
#define CXp_SUB_RE 0x40 /* code called within regex, i.e. (?{}) */
#define CXp_SUB_RE_FAKE 0x80 /* fake sub CX for (?{}) in current scope */
/* private flags for CXt_LOOP */
#define CXp_FOR_DEF 0x10 /* foreach using $_ */
#define CXp_FOR_LVREF 0x20 /* foreach using \$var */
-#define CxPADLOOP(c) ((c)->blk_loop.my_op->op_targ)
+#define CXp_FOR_GV 0x40 /* foreach using package var */
+#define CXp_FOR_PAD 0x80 /* foreach using lexical var */
+#define CxPADLOOP(c) ((c)->cx_type & CXp_FOR_PAD)
/* private flags for CXt_SUBST */
#define CXp_ONCE 0x10 /* What was sbu_once in struct subst */
#define CxTYPE(c) ((c)->cx_type & CXTYPEMASK)
#define CxTYPE_is_LOOP(c) (((c)->cx_type & 0xC) == 0x4)
-#define CxMULTICALL(c) (((c)->cx_type & CXp_MULTICALL) \
- == CXp_MULTICALL)
+#define CxMULTICALL(c) ((c)->cx_type & CXp_MULTICALL)
#define CxREALEVAL(c) (((c)->cx_type & (CXTYPEMASK|CXp_REAL)) \
== (CXt_EVAL|CXp_REAL))
#define CxTRYBLOCK(c) (((c)->cx_type & (CXTYPEMASK|CXp_TRYBLOCK)) \
PUSHSTACKi(PERLSI_MULTICALL); \
PUSHBLOCK(cx, (CXt_SUB|CXp_MULTICALL|flags), PL_stack_sp); \
PUSHSUB(cx); \
- cx->blk_sub.old_savestack_ix = PL_savestack_ix; \
+ cx->cx_old_savestack_ix = PL_savestack_ix; \
SAVEVPTR(PL_op); \
if (!(flags & CXp_SUB_RE_FAKE)) \
CvDEPTH(cv)++; \
STMT_START { \
cx = &cxstack[cxstack_ix]; \
CvDEPTH(multicall_cv) = cx->blk_sub.olddepth; \
- LEAVESUB(multicall_cv); \
- POPBLOCK(cx,PL_curpm); \
+ CX_LEAVE_SCOPE(cx); \
/* includes partial unrolled POPSUB(): */ \
- LEAVE_SCOPE(cx->blk_sub.old_savestack_ix); \
PL_comppad = cx->blk_sub.prevcomppad; \
PL_curpad = LIKELY(PL_comppad) ? AvARRAY(PL_comppad) : NULL; \
+ SvREFCNT_dec_NN(multicall_cv); \
+ /* these two set for backcompat by callers */ \
+ newsp = PL_stack_base + cx->blk_oldsp; \
+ gimme = cx->blk_gimme; \
+ POPBLOCK(cx); \
+ cxstack_ix--; \
POPSTACK; \
CATCH_SET(multicall_oldcatch); \
SPAGAIN; \
CV * const cv = _nOnclAshIngNamE_; \
PADLIST * const padlist = CvPADLIST(cv); \
cx = &cxstack[cxstack_ix]; \
- assert(cx->cx_type & CXp_MULTICALL); \
+ assert(CxMULTICALL(cx)); \
CvDEPTH(multicall_cv) = cx->blk_sub.olddepth; \
- LEAVESUB(multicall_cv); \
+ SvREFCNT_dec_NN(multicall_cv); \
cx->cx_type = (CXt_SUB|CXp_MULTICALL|flags); \
{ \
/* save a few things that we don't want PUSHSUB to zap */ \
PAD * const prevcomppad = cx->blk_sub.prevcomppad; \
- SSize_t old_floor = cx->blk_sub.old_tmpsfloor; \
- SSize_t floor = PL_tmps_floor; \
PUSHSUB(cx); \
/* undo the stuff that PUSHSUB zapped */ \
cx->blk_sub.prevcomppad = prevcomppad ; \
- cx->blk_sub.old_tmpsfloor = old_floor; \
- PL_tmps_floor = floor; \
} \
if (!(flags & CXp_SUB_RE_FAKE)) \
CvDEPTH(cv)++; \