#endif
#ifndef SvREFCNT_inc_simple_void
-# define SvREFCNT_inc_simple_void(sv) SvREFCNT_inc(sv)
+# define SvREFCNT_inc_simple_void(sv) ((void) SvREFCNT_inc(sv))
+#endif
+
+#ifndef mPUSHi
+# define mPUSHi(I) PUSHs(sv_2mortal(newSViv(I)))
#endif
#ifndef GvCV_set
# define MY_CXT_CLONE NOOP
#endif
-/* --- uplevel() data tokens ----------------------------------------------- */
+/* --- unwind() global storage --------------------------------------------- */
+
+typedef struct {
+ I32 cxix;
+ I32 items;
+ SV **savesp;
+ LISTOP return_op;
+ OP proxy_op;
+} su_unwind_storage;
+
+/* --- uplevel() data tokens and global storage ---------------------------- */
typedef struct {
void *next;
I32 cxix;
CV *target;
+ CV *callback;
bool died;
PERL_SI *si;
bool old_catch;
OP *old_op;
- CV *cloned_cv;
} su_uplevel_ud;
STATIC su_uplevel_ud *su_uplevel_ud_new(pTHX) {
#define MY_CXT_KEY __PACKAGE__ "::_guts" XS_VERSION
typedef struct {
- char *stack_placeholder;
-
- I32 cxix;
- I32 items;
- SV **savesp;
- LISTOP return_op;
- OP proxy_op;
-
- su_uplevel_storage uplevel_storage;
+ char *stack_placeholder;
+ su_unwind_storage unwind_storage;
+ su_uplevel_storage uplevel_storage;
} my_cxt_t;
START_MY_CXT
STATIC void su_unwind(pTHX_ void *ud_) {
dMY_CXT;
- I32 cxix = MY_CXT.cxix;
- I32 items = MY_CXT.items - 1;
- SV **savesp = MY_CXT.savesp;
+ I32 cxix = MY_CXT.unwind_storage.cxix;
+ I32 items = MY_CXT.unwind_storage.items - 1;
+ SV **savesp = MY_CXT.unwind_storage.savesp;
I32 mark;
PERL_UNUSED_VAR(ud_);
items, PL_stack_sp - PL_stack_base, *PL_markstack_ptr, mark);
});
- PL_op = (OP *) &(MY_CXT.return_op);
+ PL_op = (OP *) &(MY_CXT.unwind_storage.return_op);
PL_op = PL_op->op_ppaddr(aTHX);
*PL_markstack_ptr = mark;
- MY_CXT.proxy_op.op_next = PL_op;
- PL_op = &(MY_CXT.proxy_op);
+ MY_CXT.unwind_storage.proxy_op.op_next = PL_op;
+ PL_op = &(MY_CXT.unwind_storage.proxy_op);
}
/* --- Uplevel ------------------------------------------------------------- */
#define SU_HAS_EXT_MAGIC SU_HAS_PERL(5, 8, 0)
-#if SU_HAS_EXT_MAGIC
+#if SU_HAS_EXT_MAGIC && !SU_HAS_PERL(5, 13, 7)
STATIC int su_uplevel_restore_free(pTHX_ SV *sv, MAGIC *mg) {
su_uplevel_storage_delete((su_uplevel_ud *) mg->mg_ptr);
su_uplevel_restore_free
};
-#endif /* SU_HAS_EXT_MAGIC */
+#endif /* SU_HAS_EXT_MAGIC && !SU_HAS_PERL(5, 13, 7) */
STATIC void su_uplevel_restore(pTHX_ void *sus_) {
su_uplevel_ud *sud = sus_;
+ const PERL_CONTEXT *sub_cx;
PERL_SI *cur = sud->old_curstackinfo;
PERL_SI *si = sud->si;
+ sub_cx = cxstack + sud->cxix;
+
/* When we reach this place, POPSUB has already been called (with our fake
* argarray). GvAV(PL_defgv) points to the savearray (that is, what @_ was
* before uplevel). argarray is either the fake AV we created in su_uplevel()
* or some empty replacement POPSUB creates when @_ is reified. In both cases
* we have to destroy it before the context stack is swapped back to its
* original state. */
- SvREFCNT_dec(cxstack[sud->cxix].blk_sub.argarray);
+ SvREFCNT_dec(sub_cx->blk_sub.argarray);
- CATCH_SET(sud->old_catch);
+ /* PUSHSUB was exerted with the original callback, but after calling
+ * pp_entersub() we hijacked the blk_sub.cv member of the fresh sub context
+ * with the renamed CV. Thus POPSUB and LEAVESUB applied to this CV, not the
+ * original. Repair this imbalance right now. */
+ if (!(CvDEPTH(sud->callback) = sub_cx->blk_sub.olddepth))
+ LEAVESUB(sud->callback);
+
+ /* Free the renamed cv. */
+ {
+ CV *renamed_cv = sub_cx->blk_sub.cv;
+ CvDEPTH(renamed_cv) = 0;
+ SvREFCNT_dec(renamed_cv);
+ }
- SvREFCNT_dec(sud->cloned_cv);
+ CATCH_SET(sud->old_catch);
SU_UPLEVEL_RESTORE(op);
SV **old_stack_sp;
CV *target_cv;
UNOP sub_op;
- I32 marksize;
I32 gimme;
I32 old_mark, new_mark;
I32 ret;
SPAGAIN;
sud = su_uplevel_storage_new();
- si = sud->si;
- sud->cxix = cxix;
- sud->died = 1;
+ sud->cxix = cxix;
+ sud->died = 1;
+ sud->callback = cv;
SAVEDESTRUCTOR_X(su_uplevel_restore, sud);
- si->si_type = cur->si_type;
- si->si_next = NULL;
- si->si_prev = cur->si_prev;
+ si = sud->si;
+
+ si->si_type = cur->si_type;
+ si->si_next = NULL;
+ si->si_prev = cur->si_prev;
+#ifdef DEBUGGING
+ si->si_markoff = cx->blk_oldmarksp;
+#endif
/* Allocate enough space for all the elements of the original stack up to the
* target context, plus the forthcoming arguments. */
PL_stack_max = PL_stack_base + AvMAX(si->si_stack);
SPAGAIN;
-#ifdef DEBUGGING
- si->si_markoff = cx->blk_oldmarksp;
-#endif
-
/* Copy the context stack up to the context just below the target. */
si->si_cxix = (cxix < 0) ? -1 : (cxix - 1);
if (si->si_cxmax < cxix) {
sud->old_mainstack = NULL;
PL_curstack = si->si_stack;
- cv = su_cv_clone(cv);
- sud->cloned_cv = cv;
- CvGV_set(cv, CvGV(target_cv));
-
PUSHMARK(SP);
/* Both SP and old_stack_sp point just before the CV. */
Copy(old_stack_sp + 2, SP + 1, args, SV *);
sud->old_catch = CATCH_GET;
CATCH_SET(TRUE);
- if (PL_op = PL_ppaddr[OP_ENTERSUB](aTHX)) {
+ if ((PL_op = PL_ppaddr[OP_ENTERSUB](aTHX))) {
+ PERL_CONTEXT *sub_cx;
+ CV *renamed_cv;
+
+ renamed_cv = su_cv_clone(cv);
+ CvDEPTH(renamed_cv) = CvDEPTH(cv);
+ CvGV_set(renamed_cv, CvGV(target_cv));
+
+ sub_cx = cxstack + cxstack_ix;
+ sub_cx->blk_sub.cv = renamed_cv;
+ if (!sub_cx->blk_sub.olddepth) {
+ SvREFCNT_inc_simple_void(renamed_cv);
+ SvREFCNT_inc_simple_void(renamed_cv);
+ SAVEFREESV(renamed_cv);
+ }
+
if (CxHASARGS(cx) && cx->blk_sub.argarray) {
/* The call to pp_entersub() has saved the current @_ (in XS terms,
* GvAV(PL_defgv)) in the savearray member, and has created a new argarray
Copy(AvARRAY(cx->blk_sub.argarray), AvARRAY(av), AvFILLp(av) + 1, SV *);
cxstack[cxix].blk_sub.argarray = av;
} else {
- SvREFCNT_inc(cxstack[cxix].blk_sub.argarray);
+ SvREFCNT_inc_simple_void(cxstack[cxix].blk_sub.argarray);
}
CALLRUNOPS(aTHX);
/* --- Interpreter setup/teardown ------------------------------------------ */
STATIC void su_teardown(pTHX_ void *param) {
- su_uplevel_ud *cur, *prev;
+ su_uplevel_ud *cur;
dMY_CXT;
cur = MY_CXT.uplevel_storage.root;
MY_CXT.stack_placeholder = NULL;
/* NewOp() calls calloc() which just zeroes the memory with memset(). */
- Zero(&(MY_CXT.return_op), 1, sizeof(MY_CXT.return_op));
- MY_CXT.return_op.op_type = OP_RETURN;
- MY_CXT.return_op.op_ppaddr = PL_ppaddr[OP_RETURN];
+ Zero(&(MY_CXT.unwind_storage.return_op), 1, LISTOP);
+ MY_CXT.unwind_storage.return_op.op_type = OP_RETURN;
+ MY_CXT.unwind_storage.return_op.op_ppaddr = PL_ppaddr[OP_RETURN];
- Zero(&(MY_CXT.proxy_op), 1, sizeof(MY_CXT.proxy_op));
- MY_CXT.proxy_op.op_type = OP_STUB;
- MY_CXT.proxy_op.op_ppaddr = NULL;
+ Zero(&(MY_CXT.unwind_storage.proxy_op), 1, OP);
+ MY_CXT.unwind_storage.proxy_op.op_type = OP_STUB;
+ MY_CXT.unwind_storage.proxy_op.op_ppaddr = NULL;
MY_CXT.uplevel_storage.root = NULL;
MY_CXT.uplevel_storage.count = 0;
continue;
case CXt_EVAL:
case CXt_FORMAT:
- MY_CXT.cxix = cxix;
- MY_CXT.items = items;
+ MY_CXT.unwind_storage.cxix = cxix;
+ MY_CXT.unwind_storage.items = items;
/* pp_entersub will want to sanitize the stack after returning from there
* Screw that, we're insane */
if (GIMME_V == G_SCALAR) {
- MY_CXT.savesp = PL_stack_sp;
+ MY_CXT.unwind_storage.savesp = PL_stack_sp;
/* dXSARGS calls POPMARK, so we need to match PL_markstack_ptr[1] */
PL_stack_sp = PL_stack_base + PL_markstack_ptr[1] + 1;
} else {
- MY_CXT.savesp = NULL;
+ MY_CXT.unwind_storage.savesp = NULL;
}
SAVEDESTRUCTOR_X(su_unwind, NULL);
return;
#endif /* SU_THREADSAFE */
-SV *
+void
HERE()
PROTOTYPE:
PREINIT:
I32 cxix = cxstack_ix;
-CODE:
+PPCODE:
if (PL_DBsub)
SU_SKIP_DB(cxix);
- RETVAL = newSViv(cxix);
-OUTPUT:
- RETVAL
+ EXTEND(SP, 1);
+ mPUSHi(cxix);
+ XSRETURN(1);
-SV *
+void
UP(...)
PROTOTYPE: ;$
PREINIT:
I32 cxix;
-CODE:
+PPCODE:
SU_GET_CONTEXT(0, 0);
if (--cxix < 0)
cxix = 0;
if (PL_DBsub)
SU_SKIP_DB(cxix);
- RETVAL = newSViv(cxix);
-OUTPUT:
- RETVAL
+ EXTEND(SP, 1);
+ mPUSHi(cxix);
+ XSRETURN(1);
void
SUB(...)
I32 cxix;
PPCODE:
SU_GET_CONTEXT(0, 0);
+ EXTEND(SP, 1);
for (; cxix >= 0; --cxix) {
PERL_CONTEXT *cx = cxstack + cxix;
switch (CxTYPE(cx)) {
case CXt_SUB:
if (PL_DBsub && cx->blk_sub.cv == GvCV(PL_DBsub))
continue;
- ST(0) = sv_2mortal(newSViv(cxix));
+ mPUSHi(cxix);
XSRETURN(1);
}
}
I32 cxix;
PPCODE:
SU_GET_CONTEXT(0, 0);
+ EXTEND(SP, 1);
for (; cxix >= 0; --cxix) {
PERL_CONTEXT *cx = cxstack + cxix;
switch (CxTYPE(cx)) {
default:
continue;
case CXt_EVAL:
- ST(0) = sv_2mortal(newSViv(cxix));
+ mPUSHi(cxix);
XSRETURN(1);
}
}
if (cxix < 0)
cxix = 0;
}
- ST(0) = sv_2mortal(newSViv(cxix));
+ EXTEND(SP, 1);
+ mPUSHi(cxix);
XSRETURN(1);
void
}
}
done:
- ST(0) = sv_2mortal(newSViv(cxix));
+ EXTEND(SP, 1);
+ mPUSHi(cxix);
XSRETURN(1);
void
I32 cxix;
PPCODE:
SU_GET_CONTEXT(0, 0);
+ EXTEND(SP, 1);
while (cxix > 0) {
PERL_CONTEXT *cx = cxstack + cxix--;
switch (CxTYPE(cx)) {
PL_stack_sp--;
args = items - 2;
}
+ /* su_uplevel() takes care of extending the stack if needed. */
ret = su_uplevel((CV *) code, cxix, args);
XSRETURN(ret);
default:
projects / perl / modules / Scope-Upper.git / blobdiff