# define dNOOP
#endif
+#ifndef dVAR
+# define dVAR dNOOP
+#endif
+
+#ifndef MUTABLE_SV
+# define MUTABLE_SV(S) ((SV *) (S))
+#endif
+
+#ifndef MUTABLE_AV
+# define MUTABLE_AV(A) ((AV *) (A))
+#endif
+
+#ifndef MUTABLE_CV
+# define MUTABLE_CV(C) ((CV *) (C))
+#endif
+
#ifndef PERL_UNUSED_VAR
# define PERL_UNUSED_VAR(V)
#endif
# define SU_POISON(D, N, T) NOOP
#endif
+#ifndef newSV_type
+STATIC SV *su_newSV_type(pTHX_ svtype t) {
+ SV *sv = newSV(0);
+ SvUPGRADE(sv, t);
+ return sv;
+}
+# define newSV_type(T) su_newSV_type(aTHX_ (T))
+#endif
+
#ifndef SvPV_const
# define SvPV_const(S, L) SvPV(S, L)
#endif
+#ifndef SvPVX_const
+# define SvPVX_const(S) SvPVX(S)
+#endif
+
#ifndef SvPV_nolen_const
# define SvPV_nolen_const(S) SvPV_nolen(S)
#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 CvGV_set(C, G) (CvGV(C) = (G))
#endif
+#ifndef CvSTASH_set
+# define CvSTASH_set(C, S) (CvSTASH(C) = (S))
+#endif
+
+#ifndef CvISXSUB
+# define CvISXSUB(C) CvXSUB(C)
+#endif
+
#ifndef CxHASARGS
# define CxHASARGS(C) ((C)->blk_sub.hasargs)
#endif
# define gv_fetchpvn_flags(A, B, C, D) gv_fetchpv((A), (C), (D))
#endif
-#ifndef cv_clone
-# define cv_clone(P) Perl_cv_clone(aTHX_ (P))
-#endif
-
#ifndef PERL_MAGIC_tied
# define PERL_MAGIC_tied 'P'
#endif
# 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;
bool died;
+ CV *target;
+ I32 target_depth;
+
+ CV *callback;
+ I32 callback_depth;
+ CV *renamed;
+
+ AV *fake_argarray;
+
PERL_SI *si;
PERL_SI *old_curstackinfo;
AV *old_mainstack;
- I32 old_depth;
COP *old_curcop;
bool old_catch;
OP *old_op;
- CV *cloned_cv;
} su_uplevel_ud;
STATIC su_uplevel_ud *su_uplevel_ud_new(pTHX) {
si->si_stack = newAV();
AvREAL_off(si->si_stack);
si->si_cxstack = NULL;
+ si->si_cxmax = 0;
+
sud->si = si;
return sud;
#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_UPLEVEL_SAVE(f, t) STMT_START { sud->old_##f = PL_##f; PL_##f = (t); } STMT_END
#define SU_UPLEVEL_RESTORE(f) STMT_START { PL_##f = sud->old_##f; } STMT_END
+STATIC su_uplevel_ud *su_uplevel_storage_new(pTHX) {
+#define su_uplevel_storage_new() su_uplevel_storage_new(aTHX)
+ su_uplevel_ud *sud;
+ dMY_CXT;
+
+ sud = MY_CXT.uplevel_storage.root;
+ if (sud) {
+ MY_CXT.uplevel_storage.root = sud->next;
+ MY_CXT.uplevel_storage.count--;
+ } else {
+ sud = su_uplevel_ud_new();
+ }
+
+ return sud;
+}
+
+STATIC void su_uplevel_storage_delete(pTHX_ su_uplevel_ud *sud) {
+#define su_uplevel_storage_delete(S) su_uplevel_storage_delete(aTHX_ (S))
+ dMY_CXT;
+
+ if (MY_CXT.uplevel_storage.count >= SU_UPLEVEL_STORAGE_SIZE) {
+ su_uplevel_ud_delete(sud);
+ } else {
+ sud->next = MY_CXT.uplevel_storage.root;
+ MY_CXT.uplevel_storage.root = sud;
+ MY_CXT.uplevel_storage.count++;
+ }
+}
+
+#define SU_HAS_EXT_MAGIC SU_HAS_PERL(5, 8, 0)
+
+#if SU_HAS_EXT_MAGIC && !SU_HAS_PERL(5, 13, 7)
+
STATIC int su_uplevel_restore_free(pTHX_ SV *sv, MAGIC *mg) {
- su_uplevel_ud_delete((su_uplevel_ud *) mg->mg_ptr);
+ su_uplevel_storage_delete((su_uplevel_ud *) mg->mg_ptr);
return 0;
}
su_uplevel_restore_free
};
+#endif /* SU_HAS_EXT_MAGIC && !SU_HAS_PERL(5, 13, 7) */
+
STATIC void su_uplevel_restore(pTHX_ void *sus_) {
su_uplevel_ud *sud = sus_;
PERL_SI *cur = sud->old_curstackinfo;
PERL_SI *si = sud->si;
- dMY_CXT;
/* 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
* 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(sud->fake_argarray);
+
+ /* 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) = sud->callback_depth))
+ LEAVESUB(sud->callback);
+
+ /* Free the renamed cv. */
+ if (sud->renamed) {
+ CvDEPTH(sud->renamed) = 0;
+ SvREFCNT_dec(sud->renamed);
+ }
CATCH_SET(sud->old_catch);
- SvREFCNT_dec(sud->cloned_cv);
-
SU_UPLEVEL_RESTORE(op);
/* stack_grow() wants PL_curstack so restore the old stack first */
SU_UPLEVEL_RESTORE(curstackinfo);
if (sud->died) {
- CV *target_cv = sud->target;
+ CV *target = sud->target;
I32 levels = 0, i;
/* When we die, the depth of the target CV is not updated because of the
register const PERL_CONTEXT *cx = cxstack + i;
if (CxTYPE(cx) == CXt_SUB) {
- if (cx->blk_sub.cv == target_cv)
+ if (cx->blk_sub.cv == target)
++levels;
}
}
switch (CxTYPE(cx)) {
case CXt_SUB:
- if (cx->blk_sub.cv == target_cv)
+ if (cx->blk_sub.cv == target)
++levels;
break;
case CXt_EVAL:
}
found_it:
- CvDEPTH(target_cv) = sud->old_depth - levels;
+ CvDEPTH(target) = sud->target_depth - levels;
PL_curstackinfo->si_cxix = i - 1;
#if !SU_HAS_PERL(5, 13, 1)
* reset $@ to its proper value. Note that the the call to
* su_uplevel_restore() must happen before the "reset $@" item of the save
* stack is processed, as uplevel was called after the localization.
- * Andrew's change to how $@ was treated, which were mainly integrated
+ * Andrew's changes to how $@ was handled, which were mainly integrated
* between perl 5.13.0 and 5.13.1, fixed this. */
if (ERRSV && SvTRUE(ERRSV)) {
register const PERL_CONTEXT *cx = cxstack + i; /* This is the eval scope */
PL_stack_sp = PL_stack_base + AvFILLp(cur->si_stack);
PL_stack_max = PL_stack_base + AvMAX(cur->si_stack);
-#if SU_HAS_PERL(5, 8, 0)
- if (MY_CXT.uplevel_storage.count >= SU_UPLEVEL_STORAGE_SIZE) {
- /* When an exception is thrown from the uplevel'd subroutine,
- * su_uplevel_restore() may be called by the LEAVE in die_unwind() (called
- * die_where() in more recent perls), which has the sad habit of keeping a
- * pointer to the current context frame across this call. This means that
- * we can't free the temporary context stack we used for the uplevel call
- * right now, or that pointer upwards would point to garbage. We work around
- * this by attaching the state data to a scalar that will be freed "soon".
- * This issue has been fixed in perl with commit 8f89e5a9. */
+ /* When an exception is thrown from the uplevel'd subroutine,
+ * su_uplevel_restore() may be called by the LEAVE in die_unwind() (renamed
+ * die_where() in more recent perls), which has the sad habit of keeping a
+ * pointer to the current context frame across this call. This means that we
+ * can't free the temporary context stack we used for the uplevel call right
+ * now, or that pointer upwards would point to garbage. */
+#if SU_HAS_PERL(5, 13, 7)
+ /* This issue has been fixed in perl with commit 8f89e5a9, which was made
+ * public in perl 5.13.7. */
+ su_uplevel_storage_delete(sud);
+#elif SU_HAS_EXT_MAGIC
+ /* If 'ext' magic is available, we work around this by attaching the state
+ * data to a scalar that will be freed "soon". */
+ {
SV *sv = sv_newmortal();
+
sv_magicext(sv, NULL, PERL_MAGIC_ext, &su_uplevel_restore_vtbl,
(const char *) sud, 0);
- } else {
-#endif
+ }
+#else
+ /* Otherwise, we just enqueue it back in the global storage list. */
+ {
+ dMY_CXT;
+
sud->next = MY_CXT.uplevel_storage.root;
MY_CXT.uplevel_storage.root = sud;
MY_CXT.uplevel_storage.count++;
-#if SU_HAS_PERL(5, 8, 0)
}
#endif
return;
}
-STATIC CV *su_cv_clone(pTHX_ CV *old_cv) {
-#define su_cv_clone(C) su_cv_clone(aTHX_ (C))
- CV *new_cv;
-
- /* Starting from commit b5c19bd7, cv_clone() has an assert that checks whether
- * CvDEPTH(CvOUTSIDE(proto)) > 0, so we have to fool cv_clone() with a little
- * dance. */
-#if defined(DEBUGGING) && SU_HAS_PERL(5, 9, 0)
- I32 old_depth;
- CV *outside = CvOUTSIDE(old_cv);
-
- if (outside && CvCLONE(outside) && !CvCLONED(outside))
- outside = find_runcv(NULL);
- old_depth = CvDEPTH(outside);
- if (!old_depth)
- CvDEPTH(outside) = 1;
+STATIC CV *su_cv_clone(pTHX_ CV *proto, GV *gv) {
+#define su_cv_clone(P, G) su_cv_clone(aTHX_ (P), (G))
+ dVAR;
+ AV *protopadlist = CvPADLIST(proto);
+ const AV *protopadname = (const AV *) *av_fetch(protopadlist, 0, FALSE);
+ SV **pname = AvARRAY(protopadname);
+ const I32 fpadlist = AvFILLp(protopadlist);
+ const I32 fpadname = AvFILLp(protopadname);
+ AV *padlist, *padname;
+ CV *cv;
+
+ cv = MUTABLE_CV(newSV_type(SvTYPE(proto)));
+
+ CvFLAGS(cv) = CvFLAGS(proto);
+#ifdef CVf_CVGV_RC
+ CvFLAGS(cv) &= ~CVf_CVGV_RC;
+#endif
+ CvDEPTH(cv) = CvDEPTH(proto);
+#ifdef USE_ITHREADS
+ CvFILE(cv) = CvISXSUB(proto) ? CvFILE(proto) : savepv(CvFILE(proto));
+#else
+ CvFILE(cv) = CvFILE(proto);
#endif
- new_cv = cv_clone(old_cv);
+ CvGV_set(cv, gv);
+ CvSTASH_set(cv, CvSTASH(proto));
+ /* Commit 4c74a7df, publicized with perl 5.13.3, began to add backrefs to
+ * stashes. CvSTASH_set() started to do it as well with commit c68d95645
+ * (which was part of perl 5.13.7). */
+#if SU_HAS_PERL(5, 13, 3) && !SU_HAS_PERL(5, 13, 7)
+ if (CvSTASH(proto))
+ Perl_sv_add_backref(aTHX_ CvSTASH(proto), MUTABLE_SV(cv));
+#endif
-#if defined(DEBUGGING) && SU_HAS_PERL(5, 9, 0)
- CvDEPTH(outside) = old_depth;
+ OP_REFCNT_LOCK;
+ CvROOT(cv) = OpREFCNT_inc(CvROOT(proto));
+ OP_REFCNT_UNLOCK;
+ CvSTART(cv) = CvSTART(proto);
+ CvOUTSIDE(cv) = CvOUTSIDE(proto);
+#ifdef CVf_WEAKOUTSIDE
+ if (!(CvFLAGS(proto) & CVf_WEAKOUTSIDE))
+#endif
+ SvREFCNT_inc_simple_void(CvOUTSIDE(cv));
+#ifdef CvOUTSIDE_SEQ
+ CvOUTSIDE_SEQ(cv) = CvOUTSIDE_SEQ(proto);
#endif
- /* Starting from perl 5.9 (more exactly commit b5c19bd7), cv_clone() is no
- * longer able to clone named subs propery. With this commit, pad_findlex()
- * stores the parent index of a fake pad entry in the NV slot of the
- * corresponding pad name SV, but only for anonymous subs (since named subs
- * aren't supposed to be cloned in pure Perl land). To fix this, we just
- * manually relink the new fake pad entries to the new ones.
- * For some reason perl 5.8 crashes too without this, supposedly because of
- * other closure bugs. Hence we enable it everywhere. */
- if (!CvCLONE(old_cv)) {
- const AV *old_padname = (const AV *) AvARRAY(CvPADLIST(old_cv))[0];
- AV *old_pad = (AV *) AvARRAY(CvPADLIST(old_cv))[1];
- AV *new_pad = (AV *) AvARRAY(CvPADLIST(new_cv))[1];
- const SV **old_aryname = (const SV **) AvARRAY(old_padname);
- SV **old_ary = AvARRAY(old_pad);
- SV **new_ary = AvARRAY(new_pad);
- I32 fname = AvFILLp(old_padname);
- I32 fpad = AvFILLp(old_pad);
- I32 ix;
-
- for (ix = fpad; ix > 0; ix--) {
- const SV *namesv = (ix <= fname) ? old_aryname[ix] : NULL;
-
- if (namesv && namesv != &PL_sv_undef && SvFAKE(namesv)) {
- SvREFCNT_dec(new_ary[ix]);
- new_ary[ix] = SvREFCNT_inc(old_ary[ix]);
+ if (SvPOK(proto))
+ sv_setpvn(MUTABLE_SV(cv), SvPVX_const(proto), SvCUR(proto));
+
+ padlist = newAV();
+ AvREAL_off(padlist);
+ av_fill(padlist, fpadlist);
+ CvPADLIST(cv) = padlist;
+
+ padname = newAV();
+ av_fill(padname, fpadname);
+ if (fpadname >= 0) {
+ I32 j;
+ SV **psvp = AvARRAY(protopadname);
+ SV **svp = AvARRAY(padname);
+
+ svp[0] = &PL_sv_undef;
+ for (j = 1; j <= fpadname; ++j)
+ svp[j] = SvREFCNT_inc(psvp[j]);
+ }
+ AvARRAY(padlist)[0] = MUTABLE_SV(padname);
+
+ if (fpadlist >= 1) {
+ I32 i;
+
+ for (i = 1; i <= fpadlist; ++i) {
+ AV *protoframe = MUTABLE_AV(AvARRAY(protopadlist)[i]);
+ AV *frame = newAV();
+ SV **psvp = AvARRAY(protoframe);
+ SV **svp;
+ I32 j, fframe = AvFILLp(protoframe);
+
+ av_fill(frame, fframe);
+ svp = AvARRAY(frame);
+ if (i == 1) {
+ AV *a0 = newAV(); /* will be @_ */
+ AvREAL_off(a0);
+ AvREIFY_on(a0);
+ svp[0] = MUTABLE_SV(a0);
+ } else {
+ svp[0] = SvREFCNT_inc(psvp[0]);
}
+ for (j = 1; j <= fframe; ++j)
+ svp[j] = SvREFCNT_inc(psvp[j]);
+
+ AvARRAY(padlist)[i] = MUTABLE_SV(frame);
}
}
- return new_cv;
+#ifdef CvCONST
+ if (CvCONST(cv))
+ CvCONST_off(cv);
+#endif
+
+ return cv;
}
-STATIC I32 su_uplevel(pTHX_ CV *cv, I32 cxix, I32 args) {
+STATIC I32 su_uplevel(pTHX_ CV *callback, I32 cxix, I32 args) {
#define su_uplevel(C, I, A) su_uplevel(aTHX_ (C), (I), (A))
su_uplevel_ud *sud;
const PERL_CONTEXT *cx = cxstack + cxix;
PERL_SI *si;
PERL_SI *cur = PL_curstackinfo;
SV **old_stack_sp;
- CV *target_cv;
+ CV *target;
UNOP sub_op;
- I32 marksize;
I32 gimme;
I32 old_mark, new_mark;
I32 ret;
dSP;
- dMY_CXT;
ENTER;
old_mark = AvFILLp(PL_curstack) = PL_stack_sp - PL_stack_base;
SPAGAIN;
- sud = MY_CXT.uplevel_storage.root;
- if (sud) {
- MY_CXT.uplevel_storage.root = sud->next;
- MY_CXT.uplevel_storage.count--;
- } else {
- sud = su_uplevel_ud_new();
- }
- si = sud->si;
+ sud = su_uplevel_storage_new();
- sud->cxix = cxix;
- sud->died = 1;
+ sud->cxix = cxix;
+ sud->died = 1;
+ sud->callback = callback;
+ sud->renamed = NULL;
+ sud->fake_argarray = NULL;
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);
- /* The max size must be at least two so that GROW(max) = (max * 3) / 2 > max */
- si->si_cxmax = (cxix < 4) ? 4 : cxix;
- Renew(si->si_cxstack, si->si_cxmax + 1, PERL_CONTEXT);
+ si->si_cxix = (cxix < 0) ? -1 : (cxix - 1);
+ if (si->si_cxmax < cxix) {
+ /* The max size must be at least two so that GROW(max) = (max*3)/2 > max */
+ si->si_cxmax = (cxix < 4) ? 4 : cxix;
+ Renew(si->si_cxstack, si->si_cxmax + 1, PERL_CONTEXT);
+ }
Copy(cur->si_cxstack, si->si_cxstack, cxix, PERL_CONTEXT);
SU_POISON(si->si_cxstack + cxix, si->si_cxmax + 1 - cxix, PERL_CONTEXT);
- target_cv = cx->blk_sub.cv;
- sud->target = (CV *) SvREFCNT_inc(target_cv);
- sud->old_depth = CvDEPTH(target_cv);
+ target = cx->blk_sub.cv;
+ sud->target = (CV *) SvREFCNT_inc(target);
+ sud->target_depth = CvDEPTH(target);
/* blk_oldcop is essentially needed for caller() and stack traces. It has no
* run-time implication, since PL_curcop will be overwritten as soon as we
* reports the right file name, line number and lexical hints. */
SU_UPLEVEL_SAVE(curcop, cx->blk_oldcop);
/* Don't reset PL_markstack_ptr, or we would overwrite the mark stack below
- * this point. */
- /* Don't reset PL_curpm, we want the most recent matches. */
+ * this point. Don't reset PL_curpm either, we want the most recent matches. */
SU_UPLEVEL_SAVE(curstackinfo, si);
/* If those two are equal, we need to fool POPSTACK_TO() */
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 points just before the CV. */
+ /* Both SP and old_stack_sp point just before the CV. */
Copy(old_stack_sp + 2, SP + 1, args, SV *);
SP += args;
- PUSHs((SV *) cv);
+ PUSHs((SV *) callback);
PUTBACK;
Zero(&sub_op, 1, UNOP);
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 = cxstack + cxstack_ix;
+ CV *renamed;
+
+ sud->callback_depth = sub_cx->blk_sub.olddepth;
+
+ renamed = su_cv_clone(callback, CvGV(target));
+ sud->renamed = renamed;
+
+ sub_cx->blk_sub.cv = renamed;
+ if (!sub_cx->blk_sub.olddepth) {
+ SvREFCNT_inc_simple_void(renamed);
+ SvREFCNT_inc_simple_void(renamed);
+ SAVEFREESV(renamed);
+ }
+
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
av_extend(av, AvMAX(cx->blk_sub.argarray));
AvFILLp(av) = AvFILLp(cx->blk_sub.argarray);
Copy(AvARRAY(cx->blk_sub.argarray), AvARRAY(av), AvFILLp(av) + 1, SV *);
- cxstack[cxix].blk_sub.argarray = av;
+ sub_cx->blk_sub.argarray = av;
} else {
- SvREFCNT_inc(cxstack[cxix].blk_sub.argarray);
+ SvREFCNT_inc_simple_void(sub_cx->blk_sub.argarray);
}
+ sud->fake_argarray = sub_cx->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