summary |
shortlog |
log |
commit | commitdiff |
tree
raw |
patch |
inline | side by side (from parent 1:
ef58899)
Rename all the context-popping macros such as POPBLOCK and POPSUB, by
giving them a CX_ prefix. (Do TOPBLOCK too).
This is principally to deliberately break any existing non-core use of
these non-API macros, as their behaviour has changed in this branch.
In particular, POPBLOCK(cx) no longer decrements the cxt stack pointer
nor sets cx; instead, cx is now expected to already point to the stack
frame which POPBLOCK should process.
At the same time, giving them a CX_ prefix makes it clearer that these
are all part of a family of macros that manipulate the context stack.
The PUSHFOO() macros will be renamed in a later commit.
SvREFCNT_inc_void(cx->blk_format.dfoutgv)
/* Restore old @_ */
SvREFCNT_inc_void(cx->blk_format.dfoutgv)
/* Restore old @_ */
-#define POP_SAVEARRAY(cx) \
+#define CX_POP_SAVEARRAY(cx) \
STMT_START { \
AV *av = GvAV(PL_defgv); \
GvAV(PL_defgv) = cx->blk_sub.savearray; \
STMT_START { \
AV *av = GvAV(PL_defgv); \
GvAV(PL_defgv) = cx->blk_sub.savearray; \
+/* subsets of CX_POPSUB */
-#define POPSUB_COMMON(cx) \
+#define CX_POPSUB_COMMON(cx) \
STMT_START { \
CV *cv; \
PL_comppad = cx->blk_sub.prevcomppad; \
STMT_START { \
CV *cv; \
PL_comppad = cx->blk_sub.prevcomppad; \
/* handle the @_ part of leaving a sub */
/* handle the @_ part of leaving a sub */
-#define POPSUB_ARGS(cx) \
+#define CX_POPSUB_ARGS(cx) \
STMT_START { \
AV *av; \
assert(AvARRAY(MUTABLE_AV( \
PadlistARRAY(CvPADLIST(cx->blk_sub.cv))[ \
CvDEPTH(cx->blk_sub.cv)])) == PL_curpad); \
STMT_START { \
AV *av; \
assert(AvARRAY(MUTABLE_AV( \
PadlistARRAY(CvPADLIST(cx->blk_sub.cv))[ \
CvDEPTH(cx->blk_sub.cv)])) == PL_curpad); \
+ CX_POP_SAVEARRAY(cx); \
av = MUTABLE_AV(PAD_SVl(0)); \
if (UNLIKELY(AvREAL(av))) \
/* abandon @_ if it got reified */ \
av = MUTABLE_AV(PAD_SVl(0)); \
if (UNLIKELY(AvREAL(av))) \
/* abandon @_ if it got reified */ \
STMT_START { \
RETURN_PROBE(CvNAMED(cx->blk_sub.cv) \
? HEK_KEY(CvNAME_HEK(cx->blk_sub.cv)) \
STMT_START { \
RETURN_PROBE(CvNAMED(cx->blk_sub.cv) \
? HEK_KEY(CvNAME_HEK(cx->blk_sub.cv)) \
CopSTASHPV((COP*)CvSTART((const CV*)cx->blk_sub.cv))); \
\
if (CxHASARGS(cx)) { \
CopSTASHPV((COP*)CvSTART((const CV*)cx->blk_sub.cv))); \
\
if (CxHASARGS(cx)) { \
+ CX_POPSUB_COMMON(cx); \
+#define CX_POPFORMAT(cx) \
STMT_START { \
CV *cv; \
GV * const dfout = cx->blk_format.dfoutgv; \
STMT_START { \
CV *cv; \
GV * const dfout = cx->blk_format.dfoutgv; \
cx->blk_eval.cur_top_env = PL_top_env; \
} STMT_END
cx->blk_eval.cur_top_env = PL_top_env; \
} STMT_END
+#define CX_POPEVAL(cx) \
STMT_START { \
SV *sv; \
PL_in_eval = CxOLD_IN_EVAL(cx); \
STMT_START { \
SV *sv; \
PL_in_eval = CxOLD_IN_EVAL(cx); \
SvREFCNT_dec_NN(sv); \
} \
sv = cx->blk_eval.old_namesv; \
SvREFCNT_dec_NN(sv); \
} \
sv = cx->blk_eval.old_namesv; \
- if (sv && !SvTEMP(sv))/* TEMP => POPEVAL re-entrantly called */ \
+ if (sv && !SvTEMP(sv))/* TEMP implies CX_POPEVAL re-entrantly called */ \
sv_2mortal(sv); \
} STMT_END
sv_2mortal(sv); \
} STMT_END
cx->blk_loop.itersave = isave; \
PUSHLOOP_FOR_setpad(cx);
cx->blk_loop.itersave = isave; \
PUSHLOOP_FOR_setpad(cx);
+#define CX_POPLOOP(cx) \
if ( CxTYPE(cx) == CXt_LOOP_ARY \
|| CxTYPE(cx) == CXt_LOOP_LAZYSV) \
{ \
if ( CxTYPE(cx) == CXt_LOOP_ARY \
|| CxTYPE(cx) == CXt_LOOP_LAZYSV) \
{ \
PUSHWHEN(cx); \
cx->blk_givwhen.defsv_save = orig_var;
PUSHWHEN(cx); \
cx->blk_givwhen.defsv_save = orig_var;
+#define CX_POPWHEN(cx) \
+#define CX_POPGIVEN(cx) \
STMT_START { \
SV *sv = GvSV(PL_defgv); \
GvSV(PL_defgv) = cx->blk_givwhen.defsv_save; \
STMT_START { \
SV *sv = GvSV(PL_defgv); \
GvSV(PL_defgv) = cx->blk_givwhen.defsv_save; \
#define PUSHBASICBLK(cx) \
cx->blk_oldsaveix = PL_savestack_ix;
#define PUSHBASICBLK(cx) \
cx->blk_oldsaveix = PL_savestack_ix;
-#define POPBASICBLK(cx) \
+#define CX_POPBASICBLK(cx) \
PL_tmps_floor = PL_tmps_ix; \
CX_DEBUG(cx, "PUSH");
PL_tmps_floor = PL_tmps_ix; \
CX_DEBUG(cx, "PUSH");
-#define _POPBLOCK_COMMON(cx) \
+#define _CX_POPBLOCK_COMMON(cx) \
PL_markstack_ptr = PL_markstack + cx->blk_oldmarksp, \
PL_scopestack_ix = cx->blk_oldscopesp, \
PL_curpm = cx->blk_oldpm,
/* Exit a block (RETURN and LAST). */
PL_markstack_ptr = PL_markstack + cx->blk_oldmarksp, \
PL_scopestack_ix = cx->blk_oldscopesp, \
PL_curpm = cx->blk_oldpm,
/* Exit a block (RETURN and LAST). */
+#define CX_POPBLOCK(cx) \
+ _CX_POPBLOCK_COMMON(cx) \
/* LEAVE_SCOPE() should have made this true. /(?{})/ cheats
* and leaves a CX entry lying around for repeated use, so
* skip for multicall */ \
/* LEAVE_SCOPE() should have made this true. /(?{})/ cheats
* and leaves a CX entry lying around for repeated use, so
* skip for multicall */ \
PL_tmps_floor = cx->cx_u.cx_blk.blku_old_tmpsfloor; \
/* Continue a block elsewhere (e.g. NEXT, REDO, GOTO).
PL_tmps_floor = cx->cx_u.cx_blk.blku_old_tmpsfloor; \
/* Continue a block elsewhere (e.g. NEXT, REDO, GOTO).
- * Whereas POPBLOCK restores the state to the point just before PUSHBLOCK
- * was called, TOPBLOCK restores it to the point just *after* PUSHBLOCK
+ * Whereas CX_POPBLOCK restores the state to the point just before PUSHBLOCK
+ * was called, CX_TOPBLOCK restores it to the point just *after* PUSHBLOCK
+#define CX_TOPBLOCK(cx) \
+ _CX_POPBLOCK_COMMON(cx) \
PL_stack_sp = PL_stack_base + cx->blk_oldsp;
/* substitution context */
PL_stack_sp = PL_stack_base + cx->blk_oldsp;
/* substitution context */
(void)ReREFCNT_inc(rx); \
SvREFCNT_inc_void_NN(targ)
(void)ReREFCNT_inc(rx); \
SvREFCNT_inc_void_NN(targ)
+# define CX_POPSUBST(cx) \
STMT_START { \
REGEXP *re; \
rxres_free(&cx->sb_rxres); \
STMT_START { \
REGEXP *re; \
rxres_free(&cx->sb_rxres); \
- SV **newsp; /* set by POPBLOCK */ \
+ SV **newsp; /* set by CX_POPBLOCK */ \
PERL_CONTEXT *cx; \
CV *multicall_cv; \
OP *multicall_cop; \
PERL_CONTEXT *cx; \
CV *multicall_cv; \
OP *multicall_cop; \
STMT_START { \
cx = CX_CUR(); \
CX_LEAVE_SCOPE(cx); \
STMT_START { \
cx = CX_CUR(); \
CX_LEAVE_SCOPE(cx); \
+ CX_POPSUB_COMMON(cx); \
newsp = PL_stack_base + cx->blk_oldsp; \
gimme = cx->blk_gimme; \
PERL_UNUSED_VAR(newsp); /* for API */ \
PERL_UNUSED_VAR(gimme); /* for API */ \
newsp = PL_stack_base + cx->blk_oldsp; \
gimme = cx->blk_gimme; \
PERL_UNUSED_VAR(newsp); /* for API */ \
PERL_UNUSED_VAR(gimme); /* for API */ \
CX_POP(cx); \
POPSTACK; \
CATCH_SET(multicall_oldcatch); \
CX_POP(cx); \
POPSTACK; \
CATCH_SET(multicall_oldcatch); \
PADLIST * const padlist = CvPADLIST(cv); \
cx = CX_CUR(); \
assert(CxMULTICALL(cx)); \
PADLIST * const padlist = CvPADLIST(cv); \
cx = CX_CUR(); \
assert(CxMULTICALL(cx)); \
+ CX_POPSUB_COMMON(cx); \
cx->cx_type = (CXt_SUB|CXp_MULTICALL|flags); \
PUSHSUB(cx); \
if (!(flags & CXp_SUB_RE_FAKE)) \
cx->cx_type = (CXt_SUB|CXp_MULTICALL|flags); \
PUSHSUB(cx); \
if (!(flags & CXp_SUB_RE_FAKE)) \
POPSTACK_TO(PL_mainstack);
if (cxstack_ix >= 0) {
dounwind(-1);
POPSTACK_TO(PL_mainstack);
if (cxstack_ix >= 0) {
dounwind(-1);
}
LEAVE_SCOPE(0);
PL_scopestack_ix = oldscope;
}
LEAVE_SCOPE(0);
PL_scopestack_ix = oldscope;
o->op_flags |= flags;
o = op_scope(o);
o->op_flags |= flags;
o = op_scope(o);
- o->op_flags |= OPf_SPECIAL; /* suppress POPBLOCK curpm restoration*/
+ o->op_flags |= OPf_SPECIAL; /* suppress CX_POPBLOCK curpm restoration*/
POPSTACK_TO(PL_mainstack);
if (cxstack_ix >= 0) {
dounwind(-1);
POPSTACK_TO(PL_mainstack);
if (cxstack_ix >= 0) {
dounwind(-1);
PERL_CONTEXT *cx = CX_CUR();
assert(CxHASARGS(cx));
PERL_CONTEXT *cx = CX_CUR();
assert(CxHASARGS(cx));
cx->cx_type &= ~CXp_HASARGS;
}
}
cx->cx_type &= ~CXp_HASARGS;
}
}
TAINT_NOT;
CX_LEAVE_SCOPE(cx);
TAINT_NOT;
CX_LEAVE_SCOPE(cx);
CX_POP(cx);
PERL_ASYNC_CHECK();
CX_POP(cx);
PERL_ASYNC_CHECK();
/* dounwind(): pop all contexts above (but not including) cxix.
* Note that it clears the savestack frame associated with each popped
* context entry, but doesn't free any temps.
/* dounwind(): pop all contexts above (but not including) cxix.
* Note that it clears the savestack frame associated with each popped
* context entry, but doesn't free any temps.
- * It does a POPBLOCK of the last frame that it pops, and leaves
+ * It does a CX_POPBLOCK of the last frame that it pops, and leaves
* cxstack_ix equal to cxix.
*/
* cxstack_ix equal to cxix.
*/
switch (CxTYPE(cx)) {
case CXt_SUBST:
switch (CxTYPE(cx)) {
case CXt_SUBST:
break;
case CXt_LOOP_PLAIN:
case CXt_LOOP_LAZYIV:
case CXt_LOOP_LAZYSV:
case CXt_LOOP_LIST:
case CXt_LOOP_ARY:
break;
case CXt_LOOP_PLAIN:
case CXt_LOOP_LAZYIV:
case CXt_LOOP_LAZYSV:
case CXt_LOOP_LIST:
case CXt_LOOP_ARY:
- /* there isn't a POPNULL ! */
+ /* there isn't a CX_POPNULL ! */
break;
}
if (cxstack_ix == cxix + 1) {
break;
}
if (cxstack_ix == cxix + 1) {
PL_stack_sp = oldsp;
CX_LEAVE_SCOPE(cx);
PL_stack_sp = oldsp;
CX_LEAVE_SCOPE(cx);
- POPEVAL(cx);
- POPBLOCK(cx);
+ CX_POPEVAL(cx);
+ CX_POPBLOCK(cx);
restartjmpenv = cx->blk_eval.cur_top_env;
restartop = cx->blk_eval.retop;
if (CxOLD_OP_TYPE(cx) == OP_REQUIRE)
restartjmpenv = cx->blk_eval.cur_top_env;
restartop = cx->blk_eval.retop;
if (CxOLD_OP_TYPE(cx) == OP_REQUIRE)
PL_op->op_private & OPpLVALUE ? 3 : 1);
CX_LEAVE_SCOPE(cx);
PL_op->op_private & OPpLVALUE ? 3 : 1);
CX_LEAVE_SCOPE(cx);
- POPBASICBLK(cx);
- POPBLOCK(cx);
+ CX_POPBASICBLK(cx);
+ CX_POPBLOCK(cx);
CX_POP(cx);
return NORMAL;
CX_POP(cx);
return NORMAL;
PL_op->op_private & OPpLVALUE ? 3 : 1);
CX_LEAVE_SCOPE(cx);
PL_op->op_private & OPpLVALUE ? 3 : 1);
CX_LEAVE_SCOPE(cx);
- POPLOOP(cx); /* Stack values are safe: release loop vars ... */
- POPBLOCK(cx);
+ CX_POPLOOP(cx); /* Stack values are safe: release loop vars ... */
+ CX_POPBLOCK(cx);
CX_POP(cx);
return NORMAL;
CX_POP(cx);
return NORMAL;
- POPSUB(cx); /* Stack values are safe: release CV and @_ ... */
- POPBLOCK(cx);
+ CX_POPSUB(cx); /* Stack values are safe: release CV and @_ ... */
+ CX_POPBLOCK(cx);
retop = cx->blk_sub.retop;
CX_POP(cx);
retop = cx->blk_sub.retop;
CX_POP(cx);
/* Stack values are safe: */
CX_LEAVE_SCOPE(cx);
/* Stack values are safe: */
CX_LEAVE_SCOPE(cx);
- POPLOOP(cx); /* release loop vars ... */
- POPBLOCK(cx);
+ CX_POPLOOP(cx); /* release loop vars ... */
+ CX_POPBLOCK(cx);
nextop = cx->blk_loop.my_op->op_lastop->op_next;
CX_POP(cx);
nextop = cx->blk_loop.my_op->op_lastop->op_next;
CX_POP(cx);
if (!((PL_op->op_flags & OPf_SPECIAL) && CxTYPE_is_LOOP(cx)))
cx = S_unwind_loop(aTHX);
if (!((PL_op->op_flags & OPf_SPECIAL) && CxTYPE_is_LOOP(cx)))
cx = S_unwind_loop(aTHX);
PL_curcop = cx->blk_oldcop;
PERL_ASYNC_CHECK();
return (cx)->blk_loop.my_op->op_nextop;
PL_curcop = cx->blk_oldcop;
PERL_ASYNC_CHECK();
return (cx)->blk_loop.my_op->op_nextop;
FREETMPS;
CX_LEAVE_SCOPE(cx);
FREETMPS;
CX_LEAVE_SCOPE(cx);
PL_curcop = cx->blk_oldcop;
PERL_ASYNC_CHECK();
return redo_op;
PL_curcop = cx->blk_oldcop;
PERL_ASYNC_CHECK();
return redo_op;
dounwind(cxix);
}
cx = CX_CUR();
dounwind(cxix);
}
cx = CX_CUR();
SPAGAIN;
/* protect @_ during save stack unwind. */
SPAGAIN;
/* protect @_ during save stack unwind. */
CX_LEAVE_SCOPE(cx);
if (CxTYPE(cx) == CXt_SUB && CxHASARGS(cx)) {
CX_LEAVE_SCOPE(cx);
if (CxTYPE(cx) == CXt_SUB && CxHASARGS(cx)) {
- /* this is part of POPSUB_ARGS() */
+ /* this is part of CX_POPSUB_ARGS() */
AV* av = MUTABLE_AV(PAD_SVl(0));
assert(AvARRAY(MUTABLE_AV(
PadlistARRAY(CvPADLIST(cx->blk_sub.cv))[
AV* av = MUTABLE_AV(PAD_SVl(0));
assert(AvARRAY(MUTABLE_AV(
PadlistARRAY(CvPADLIST(cx->blk_sub.cv))[
SP += items;
if (CxTYPE(cx) == CXt_SUB && CxHASARGS(cx)) {
/* Restore old @_ */
SP += items;
if (CxTYPE(cx) == CXt_SUB && CxHASARGS(cx)) {
/* Restore old @_ */
}
retop = cx->blk_sub.retop;
}
retop = cx->blk_sub.retop;
PL_curpad = LIKELY(PL_comppad) ? AvARRAY(PL_comppad) : NULL;
/* XS subs don't have a CXt_SUB, so pop it;
PL_curpad = LIKELY(PL_comppad) ? AvARRAY(PL_comppad) : NULL;
/* XS subs don't have a CXt_SUB, so pop it;
- * this is a POPBLOCK(), less all the stuff we already did
- * for TOPBLOCK() earlier */
+ * this is a CX_POPBLOCK(), less all the stuff we already did
+ * for CX_TOPBLOCK() earlier */
PL_curcop = cx->blk_oldcop;
CX_POP(cx);
PL_curcop = cx->blk_oldcop;
CX_POP(cx);
DIE(aTHX_ "panic: docatch: illegal ix=%ld", (long)ix);
dounwind(ix);
cx = CX_CUR();
DIE(aTHX_ "panic: docatch: illegal ix=%ld", (long)ix);
dounwind(ix);
cx = CX_CUR();
}
/* push wanted frames */
}
/* push wanted frames */
SP = PL_stack_base + POPMARK; /* pop original mark */
cx = CX_CUR();
CX_LEAVE_SCOPE(cx);
SP = PL_stack_base + POPMARK; /* pop original mark */
cx = CX_CUR();
CX_LEAVE_SCOPE(cx);
- POPEVAL(cx);
- POPBLOCK(cx);
+ CX_POPEVAL(cx);
+ CX_POPBLOCK(cx);
if (in_require)
namesv = cx->blk_eval.old_namesv;
CX_POP(cx);
if (in_require)
namesv = cx->blk_eval.old_namesv;
CX_POP(cx);
OP *retop;
SV *namesv = NULL;
CV *evalcv;
OP *retop;
SV *namesv = NULL;
CV *evalcv;
- /* grab this value before POPEVAL restores old PL_in_eval */
+ /* grab this value before CX_POPEVAL restores old PL_in_eval */
bool keep = cBOOL(PL_in_eval & EVAL_KEEPERR);
PERL_ASYNC_CHECK();
bool keep = cBOOL(PL_in_eval & EVAL_KEEPERR);
PERL_ASYNC_CHECK();
else
leave_adjust_stacks(oldsp, oldsp, gimme, 0);
else
leave_adjust_stacks(oldsp, oldsp, gimme, 0);
- /* the POPEVAL does a leavescope, which frees the optree associated
+ /* the CX_POPEVAL does a leavescope, which frees the optree associated
* with eval, which if it frees the nextstate associated with
* PL_curcop, sets PL_curcop to NULL. Which can mess up freeing a
* regex when running under 'use re Debug' because it needs PL_curcop
* with eval, which if it frees the nextstate associated with
* PL_curcop, sets PL_curcop to NULL. Which can mess up freeing a
* regex when running under 'use re Debug' because it needs PL_curcop
PL_curcop = cx->blk_oldcop;
CX_LEAVE_SCOPE(cx);
PL_curcop = cx->blk_oldcop;
CX_LEAVE_SCOPE(cx);
- POPEVAL(cx);
- POPBLOCK(cx);
+ CX_POPEVAL(cx);
+ CX_POPBLOCK(cx);
retop = cx->blk_eval.retop;
evalcv = cx->blk_eval.cv;
CX_POP(cx);
retop = cx->blk_eval.retop;
evalcv = cx->blk_eval.cv;
CX_POP(cx);
cx = CX_CUR();
CX_LEAVE_SCOPE(cx);
cx = CX_CUR();
CX_LEAVE_SCOPE(cx);
- POPEVAL(cx);
- POPBLOCK(cx);
+ CX_POPEVAL(cx);
+ CX_POPBLOCK(cx);
else
leave_adjust_stacks(oldsp, oldsp, gimme, 1);
CX_LEAVE_SCOPE(cx);
else
leave_adjust_stacks(oldsp, oldsp, gimme, 1);
CX_LEAVE_SCOPE(cx);
- POPEVAL(cx);
- POPBLOCK(cx);
+ CX_POPEVAL(cx);
+ CX_POPBLOCK(cx);
retop = cx->blk_eval.retop;
CX_POP(cx);
retop = cx->blk_eval.retop;
CX_POP(cx);
leave_adjust_stacks(oldsp, oldsp, gimme, 1);
CX_LEAVE_SCOPE(cx);
leave_adjust_stacks(oldsp, oldsp, gimme, 1);
CX_LEAVE_SCOPE(cx);
- POPGIVEN(cx);
- POPBLOCK(cx);
+ CX_POPGIVEN(cx);
+ CX_POPBLOCK(cx);
CX_POP(cx);
return NORMAL;
CX_POP(cx);
return NORMAL;
/* emulate pp_next. Note that any stack(s) cleanup will be
* done by the pp_unstack which op_nextop should point to */
cx = CX_CUR();
/* emulate pp_next. Note that any stack(s) cleanup will be
* done by the pp_unstack which op_nextop should point to */
cx = CX_CUR();
PL_curcop = cx->blk_oldcop;
return cx->blk_loop.my_op->op_nextop;
}
PL_curcop = cx->blk_oldcop;
return cx->blk_loop.my_op->op_nextop;
}
assert(CxTYPE(cx) == CXt_WHEN);
PL_stack_sp = PL_stack_base + cx->blk_oldsp;
CX_LEAVE_SCOPE(cx);
assert(CxTYPE(cx) == CXt_WHEN);
PL_stack_sp = PL_stack_base + cx->blk_oldsp;
CX_LEAVE_SCOPE(cx);
- POPWHEN(cx);
- POPBLOCK(cx);
+ CX_POPWHEN(cx);
+ CX_POPBLOCK(cx);
nextop = cx->blk_givwhen.leave_op->op_next;
CX_POP(cx);
nextop = cx->blk_givwhen.leave_op->op_next;
CX_POP(cx);
leave_adjust_stacks(oldsp, oldsp, gimme, 0);
CX_LEAVE_SCOPE(cx);
leave_adjust_stacks(oldsp, oldsp, gimme, 0);
CX_LEAVE_SCOPE(cx);
- POPSUB(cx); /* Stack values are safe: release CV and @_ ... */
- POPBLOCK(cx);
+ CX_POPSUB(cx); /* Stack values are safe: release CV and @_ ... */
+ CX_POPBLOCK(cx);
retop = cx->blk_sub.retop;
CX_POP(cx);
retop = cx->blk_sub.retop;
CX_POP(cx);
/* it's the responsibility of whoever leaves a sub to ensure
* that a clean, empty AV is left in pad[0]. This is normally
/* it's the responsibility of whoever leaves a sub to ensure
* that a clean, empty AV is left in pad[0]. This is normally
+ * done by CX_POPSUB() */
assert(!AvREAL(av) && AvFILLp(av) == -1);
items = SP - MARK;
assert(!AvREAL(av) && AvFILLp(av) == -1);
items = SP - MARK;
CX_LEAVE_SCOPE(cx);
if (!(flags & OPf_SPECIAL)) {
assert(CxTYPE(cx) == CXt_SUB);
CX_LEAVE_SCOPE(cx);
if (!(flags & OPf_SPECIAL)) {
assert(CxTYPE(cx) == CXt_SUB);
}
else
assert(CxTYPE(cx) == CXt_NULL);
/* there isn't a POPNULL ! */
}
else
assert(CxTYPE(cx) == CXt_NULL);
/* there isn't a POPNULL ! */
CX_POP(cx);
POPSTACK;
CATCH_SET(oldcatch);
CX_POP(cx);
POPSTACK;
CATCH_SET(oldcatch);
assert(CxTYPE(cx) == CXt_FORMAT);
SP = PL_stack_base + cx->blk_oldsp; /* ignore retval of formline */
CX_LEAVE_SCOPE(cx);
assert(CxTYPE(cx) == CXt_FORMAT);
SP = PL_stack_base + cx->blk_oldsp; /* ignore retval of formline */
CX_LEAVE_SCOPE(cx);
- POPFORMAT(cx);
- POPBLOCK(cx);
+ CX_POPFORMAT(cx);
+ CX_POPBLOCK(cx);
retop = cx->blk_sub.retop;
CX_POP(cx);
retop = cx->blk_sub.retop;
CX_POP(cx);
SV **svp;
assert (ARG1_PTR);
svp = AvARRAY((PAD*)ARG1_PTR) + (PADOFFSET)arg0.any_uv;
SV **svp;
assert (ARG1_PTR);
svp = AvARRAY((PAD*)ARG1_PTR) + (PADOFFSET)arg0.any_uv;
- /* This mortalizing used to be done by POPLOOP() via itersave.
- But as we have all the information here, we can do it here,
- save even having to have itersave in the struct. */
+ /* This mortalizing used to be done by CX_POOPLOOP() via
+ itersave. But as we have all the information here, we
+ can do it here, save even having to have itersave in
+ the struct.
+ */
sv_2mortal(*svp);
*svp = ARG2_SV;
}
sv_2mortal(*svp);
*svp = ARG2_SV;
}
is("@$y","a b c y", 'goto: multiple elements');
}
is("@$y","a b c y", 'goto: multiple elements');
}
-# see if POPSUB gets to see the right pad across a dounwind() with
+# see if CX_POPSUB gets to see the right pad across a dounwind() with
# a reified @_
sub methimpl {
# a reified @_
sub methimpl {
for (1..5) { try() }
is($failcount, 5,
for (1..5) { try() }
is($failcount, 5,
- 'POPSUB sees right pad across a dounwind() with reified @_');
+ 'CX_POPSUB sees right pad across a dounwind() with reified @_');
# bug #21542 local $_[0] causes reify problems and coredumps
# bug #21542 local $_[0] causes reify problems and coredumps