#endif
#ifndef VMG_MULTIPLICITY
-# if defined(MULTIPLICITY) || defined(PERL_IMPLICIT_CONTEXT)
+# if defined(MULTIPLICITY)
# define VMG_MULTIPLICITY 1
# else
# define VMG_MULTIPLICITY 0
# endif
#endif
+#if VMG_MULTIPLICITY
+# ifndef PERL_IMPLICIT_CONTEXT
+# error MULTIPLICITY builds must set PERL_IMPLICIT_CONTEXT
+# endif
+#endif
#if VMG_MULTIPLICITY && defined(USE_ITHREADS) && defined(dMY_CXT) && defined(MY_CXT) && defined(START_MY_CXT) && defined(MY_CXT_INIT) && (defined(MY_CXT_CLONE) || defined(dMY_CXT_SV))
-# define VMG_THREADSAFE 1
+# ifndef VMG_THREADSAFE
+# define VMG_THREADSAFE 1
+# endif
# ifndef MY_CXT_CLONE
# define MY_CXT_CLONE \
dMY_CXT_SV; \
sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))
# endif
#else
+# undef VMG_THREADSAFE
# define VMG_THREADSAFE 0
# undef dMY_CXT
# define dMY_CXT dNOOP
# define IN_PERL_COMPILETIME (PL_curcop == &PL_compiling)
#endif
+#ifndef OP_NAME
+# define OP_NAME(O) (PL_op_name[(O)->op_type])
+#endif
+
+#ifndef OP_CLASS
+# define OP_CLASS(O) (PL_opargs[(O)->op_type] & OA_CLASS_MASK)
+#endif
+
+#ifdef DEBUGGING
+# define VMG_ASSERT(C) assert(C)
+#else
+# define VMG_ASSERT(C)
+#endif
+
/* uvar magic and Hash::Util::FieldHash were commited with 28419, but we only
* enable them on 5.10 */
#if VMG_HAS_PERL(5, 10, 0)
# define VMG_COMPAT_HASH_DELETE_NOUVAR_VOID 0
#endif
+#if VMG_HAS_PERL(5, 17, 0)
+# define VMG_COMPAT_CODE_COPY_CLONE 1
+#else
+# define VMG_COMPAT_CODE_COPY_CLONE 0
+#endif
+
#if VMG_HAS_PERL(5, 13, 2)
# define VMG_COMPAT_GLOB_GET 1
#else
#else
-STATIC void vmg_mg_magical(SV *sv) {
+static void vmg_mg_magical(SV *sv) {
const MAGIC *mg;
SvMAGICAL_off(sv);
SVOP target;
} vmg_trampoline;
-STATIC void vmg_trampoline_init(vmg_trampoline *t, OP *(*cb)(pTHX)) {
+static void vmg_trampoline_init(vmg_trampoline *t, OP *(*cb)(pTHX)) {
t->temp.op_type = OP_STUB;
t->temp.op_ppaddr = 0;
t->temp.op_next = (OP *) &t->target;
t->target.op_sv = NULL;
}
-STATIC OP *vmg_trampoline_bump(pTHX_ vmg_trampoline *t, SV *sv, OP *o) {
+static OP *vmg_trampoline_bump(pTHX_ vmg_trampoline *t, SV *sv, OP *o) {
#define vmg_trampoline_bump(T, S, O) vmg_trampoline_bump(aTHX_ (T), (S), (O))
t->temp = *o;
t->temp.op_next = (OP *) &t->target;
#endif /* VMG_NEEDS_TRAMPOLINE */
+/* --- Cleaner version of sv_magicext() ------------------------------------ */
+
+static MAGIC *vmg_sv_magicext(pTHX_ SV *sv, SV *obj, const MGVTBL *vtbl, const void *ptr, I32 len) {
+#define vmg_sv_magicext(S, O, V, P, L) vmg_sv_magicext(aTHX_ (S), (O), (V), (P), (L))
+ MAGIC *mg;
+
+ mg = sv_magicext(sv, obj, PERL_MAGIC_ext, vtbl, ptr, len);
+ if (!mg)
+ return NULL;
+
+ mg->mg_private = 0;
+
+ if (vtbl->svt_copy)
+ mg->mg_flags |= MGf_COPY;
+#if MGf_DUP
+ if (vtbl->svt_dup)
+ mg->mg_flags |= MGf_DUP;
+#endif /* MGf_DUP */
+#if MGf_LOCAL
+ if (vtbl->svt_local)
+ mg->mg_flags |= MGf_LOCAL;
+#endif /* MGf_LOCAL */
+
+ if (mg->mg_flags & MGf_REFCOUNTED)
+ SvREFCNT_dec(obj);
+
+ return mg;
+}
+
/* --- Safe version of call_sv() ------------------------------------------- */
-STATIC I32 vmg_call_sv(pTHX_ SV *sv, I32 flags, int (*cleanup)(pTHX_ void *), void *ud) {
+static I32 vmg_call_sv(pTHX_ SV *sv, I32 flags, int (*cleanup)(pTHX_ void *), void *ud) {
#define vmg_call_sv(S, F, C, U) vmg_call_sv(aTHX_ (S), (F), (C), (U))
- I32 ret, cxix;
- PERL_CONTEXT saved_cx;
+ I32 ret;
SV *old_err = NULL;
if (SvTRUE(ERRSV)) {
- old_err = ERRSV;
- ERRSV = newSV(0);
+ old_err = newSVsv(ERRSV);
+ sv_setsv(ERRSV, &PL_sv_undef);
}
- cxix = (cxstack_ix < cxstack_max) ? (cxstack_ix + 1) : Perl_cxinc(aTHX);
- /* The last popped context will be reused by call_sv(), but our callers may
- * still need its previous value. Back it up so that it isn't clobbered. */
- saved_cx = cxstack[cxix];
-
ret = call_sv(sv, flags | G_EVAL);
- cxstack[cxix] = saved_cx;
-
if (SvTRUE(ERRSV)) {
- if (old_err) {
- sv_setsv(old_err, ERRSV);
- SvREFCNT_dec(ERRSV);
- ERRSV = old_err;
- }
+ SvREFCNT_dec(old_err);
+
if (IN_PERL_COMPILETIME) {
if (!PL_in_eval) {
if (PL_errors)
}
} else {
if (old_err) {
- SvREFCNT_dec(ERRSV);
- ERRSV = old_err;
+ sv_setsv(ERRSV, old_err);
+ SvREFCNT_dec(old_err);
}
}
/* --- Stolen chunk of B --------------------------------------------------- */
typedef enum {
- OPc_NULL = 0,
- OPc_BASEOP = 1,
- OPc_UNOP = 2,
- OPc_BINOP = 3,
- OPc_LOGOP = 4,
- OPc_LISTOP = 5,
- OPc_PMOP = 6,
- OPc_SVOP = 7,
- OPc_PADOP = 8,
- OPc_PVOP = 9,
- OPc_LOOP = 10,
- OPc_COP = 11,
- OPc_MAX = 12
+ OPc_NULL,
+ OPc_BASEOP,
+ OPc_UNOP,
+ OPc_BINOP,
+ OPc_LOGOP,
+ OPc_LISTOP,
+ OPc_PMOP,
+ OPc_SVOP,
+ OPc_PADOP,
+ OPc_PVOP,
+ OPc_LOOP,
+ OPc_COP,
+#if VMG_HAS_PERL(5, 21, 5)
+ OPc_METHOP,
+#endif
+#if VMG_HAS_PERL(5, 21, 7)
+ OPc_UNOP_AUX,
+#endif
+ OPc_MAX
} opclass;
-STATIC const char *const vmg_opclassnames[] = {
+static const char *const vmg_opclassnames[] = {
"B::NULL",
"B::OP",
"B::UNOP",
"B::PADOP",
"B::PVOP",
"B::LOOP",
- "B::COP"
+ "B::COP",
+#if VMG_HAS_PERL(5, 21, 5)
+ "B::METHOP",
+#endif
+#if VMG_HAS_PERL(5, 21, 7)
+ "B::UNOP_AUX",
+#endif
+ NULL
};
-STATIC opclass vmg_opclass(const OP *o) {
+static opclass vmg_opclass(pTHX_ const OP *o) {
+#define vmg_opclass(O) vmg_opclass(aTHX_ (O))
#if 0
if (!o)
return OPc_NULL;
#endif
- if (o->op_type == 0)
+ if (o->op_type == 0) {
+#if VMG_HAS_PERL(5, 21, 7)
+ if (o->op_targ == OP_NEXTSTATE || o->op_targ == OP_DBSTATE)
+ return OPc_COP;
+#endif
return (o->op_flags & OPf_KIDS) ? OPc_UNOP : OPc_BASEOP;
+ }
if (o->op_type == OP_SASSIGN)
return ((o->op_private & OPpASSIGN_BACKWARDS) ? OPc_UNOP : OPc_BINOP);
return OPc_PADOP;
#endif
- switch (PL_opargs[o->op_type] & OA_CLASS_MASK) {
+ switch (OP_CLASS(o)) {
case OA_BASEOP:
return OPc_BASEOP;
case OA_UNOP:
case OA_PADOP:
return OPc_PADOP;
case OA_PVOP_OR_SVOP:
- return (o->op_private & (OPpTRANS_TO_UTF|OPpTRANS_FROM_UTF)) ? OPc_SVOP : OPc_PVOP;
+ return (
+#if VMG_HAS_PERL(5, 13, 7)
+ (o->op_type != OP_CUSTOM) &&
+#endif
+ (o->op_private & (OPpTRANS_TO_UTF|OPpTRANS_FROM_UTF)))
+#if defined(USE_ITHREADS) && VMG_HAS_PERL(5, 8, 9)
+ ? OPc_PADOP : OPc_PVOP;
+#else
+ ? OPc_SVOP : OPc_PVOP;
+#endif
case OA_LOOP:
return OPc_LOOP;
case OA_COP:
return OPc_BASEOP;
else
return OPc_PVOP;
+#if VMG_HAS_PERL(5, 21, 5)
+ case OA_METHOP:
+ return OPc_METHOP;
+#endif
+#if VMG_HAS_PERL(5, 21, 7)
+ case OA_UNOP_AUX:
+ return OPc_UNOP_AUX;
+#endif
}
return OPc_BASEOP;
/* --- Error messages ------------------------------------------------------ */
-STATIC const char vmg_invalid_wiz[] = "Invalid wizard object";
-STATIC const char vmg_wrongargnum[] = "Wrong number of arguments";
-STATIC const char vmg_argstorefailed[] = "Error while storing arguments";
+static const char vmg_invalid_wiz[] = "Invalid wizard object";
+static const char vmg_wrongargnum[] = "Wrong number of arguments";
/* --- Context-safe global data -------------------------------------------- */
U32 refcount;
} vmg_vtable;
-STATIC vmg_vtable *vmg_vtable_alloc(pTHX) {
+static vmg_vtable *vmg_vtable_alloc(pTHX) {
#define vmg_vtable_alloc() vmg_vtable_alloc(aTHX)
vmg_vtable *t;
#define vmg_vtable_vtbl(T) (T)->vtbl
-STATIC perl_mutex vmg_vtable_refcount_mutex;
+static perl_mutex vmg_vtable_refcount_mutex;
-STATIC vmg_vtable *vmg_vtable_dup(pTHX_ vmg_vtable *t) {
+static vmg_vtable *vmg_vtable_dup(pTHX_ vmg_vtable *t) {
#define vmg_vtable_dup(T) vmg_vtable_dup(aTHX_ (T))
VMG_LOCK(&vmg_vtable_refcount_mutex);
++t->refcount;
return t;
}
-STATIC void vmg_vtable_free(pTHX_ vmg_vtable *t) {
+static void vmg_vtable_free(pTHX_ vmg_vtable *t) {
#define vmg_vtable_free(T) vmg_vtable_free(aTHX_ (T))
U32 refcount;
typedef MGVTBL vmg_vtable;
-STATIC vmg_vtable *vmg_vtable_alloc(pTHX) {
+static vmg_vtable *vmg_vtable_alloc(pTHX) {
#define vmg_vtable_alloc() vmg_vtable_alloc(aTHX)
vmg_vtable *t;
#endif /* VMG_UVAR */
} vmg_wizard;
-STATIC void vmg_op_info_init(pTHX_ unsigned int opinfo);
+static void vmg_op_info_init(pTHX_ unsigned int opinfo);
-STATIC vmg_wizard *vmg_wizard_alloc(pTHX_ UV opinfo) {
+static vmg_wizard *vmg_wizard_alloc(pTHX_ UV opinfo) {
#define vmg_wizard_alloc(O) vmg_wizard_alloc(aTHX_ (O))
vmg_wizard *w;
return w;
}
-STATIC void vmg_wizard_free(pTHX_ vmg_wizard *w) {
+static void vmg_wizard_free(pTHX_ vmg_wizard *w) {
#define vmg_wizard_free(W) vmg_wizard_free(aTHX_ (W))
if (!w)
return;
z->cb_ ## N = (w->cb_ ## N) ? SvREFCNT_inc(sv_dup(w->cb_ ## N, params)) \
: NULL;
-STATIC const vmg_wizard *vmg_wizard_dup(pTHX_ const vmg_wizard *w, CLONE_PARAMS *params) {
+static const vmg_wizard *vmg_wizard_dup(pTHX_ const vmg_wizard *w, CLONE_PARAMS *params) {
#define vmg_wizard_dup(W, P) vmg_wizard_dup(aTHX_ (W), (P))
vmg_wizard *z;
/* --- Wizard SV objects --------------------------------------------------- */
-STATIC int vmg_wizard_sv_free(pTHX_ SV *sv, MAGIC *mg) {
+static int vmg_wizard_sv_free(pTHX_ SV *sv, MAGIC *mg) {
vmg_wizard_free((vmg_wizard *) mg->mg_ptr);
return 0;
#if VMG_THREADSAFE
-STATIC int vmg_wizard_sv_dup(pTHX_ MAGIC *mg, CLONE_PARAMS *params) {
+static int vmg_wizard_sv_dup(pTHX_ MAGIC *mg, CLONE_PARAMS *params) {
mg->mg_ptr = (char *) vmg_wizard_dup((const vmg_wizard *) mg->mg_ptr, params);
return 0;
#endif /* VMG_THREADSAFE */
-STATIC MGVTBL vmg_wizard_sv_vtbl = {
+static MGVTBL vmg_wizard_sv_vtbl = {
NULL, /* get */
NULL, /* set */
NULL, /* len */
#endif /* MGf_LOCAL */
};
-STATIC SV *vmg_wizard_sv_new(pTHX_ const vmg_wizard *w) {
+static SV *vmg_wizard_sv_new(pTHX_ const vmg_wizard *w) {
#define vmg_wizard_sv_new(W) vmg_wizard_sv_new(aTHX_ (W))
SV *wiz;
wiz = newSViv(PTR2IV(w));
#endif
- if (w) {
- MAGIC *mg = sv_magicext(wiz, NULL, PERL_MAGIC_ext, &vmg_wizard_sv_vtbl,
- (const char *) w, 0);
- mg->mg_private = 0;
-#if VMG_THREADSAFE
- mg->mg_flags |= MGf_DUP;
-#endif
- }
+ vmg_sv_magicext(wiz, NULL, &vmg_wizard_sv_vtbl, w, 0);
+
SvREADONLY_on(wiz);
return wiz;
#define vmg_sv_has_wizard_type(S) (SvTYPE(S) >= SVt_PVMG)
-STATIC const vmg_wizard *vmg_wizard_from_sv_nocheck(const SV *wiz) {
+static const vmg_wizard *vmg_wizard_from_sv_nocheck(const SV *wiz) {
MAGIC *mg;
for (mg = SvMAGIC(wiz); mg; mg = mg->mg_moremagic) {
#define vmg_wizard_from_sv(W) (vmg_sv_has_wizard_type(W) ? vmg_wizard_from_sv_nocheck(W) : NULL)
-STATIC const vmg_wizard *vmg_wizard_from_mg(const MAGIC *mg) {
+static const vmg_wizard *vmg_wizard_from_mg(const MAGIC *mg) {
if (mg->mg_type == PERL_MAGIC_ext && mg->mg_len == HEf_SVKEY) {
SV *sv = (SV *) mg->mg_ptr;
/* --- User-level functions implementation --------------------------------- */
-STATIC const MAGIC *vmg_find(const SV *sv, const vmg_wizard *w) {
+static const MAGIC *vmg_find(const SV *sv, const vmg_wizard *w) {
const MAGIC *mg;
IV wid;
/* ... Construct private data .............................................. */
-STATIC SV *vmg_data_new(pTHX_ SV *ctor, SV *sv, SV **args, I32 items) {
+static SV *vmg_data_new(pTHX_ SV *ctor, SV *sv, SV **args, I32 items) {
#define vmg_data_new(C, S, A, I) vmg_data_new(aTHX_ (C), (S), (A), (I))
I32 i;
SV *nsv;
ENTER;
SAVETMPS;
+ PUSHSTACKi(PERLSI_MAGIC);
+
PUSHMARK(SP);
EXTEND(SP, items + 1);
PUSHs(sv_2mortal(newRV_inc(sv)));
#endif
PUTBACK;
+ POPSTACK;
+
FREETMPS;
LEAVE;
return nsv;
}
-STATIC SV *vmg_data_get(pTHX_ SV *sv, const vmg_wizard *w) {
+static SV *vmg_data_get(pTHX_ SV *sv, const vmg_wizard *w) {
#define vmg_data_get(S, W) vmg_data_get(aTHX_ (S), (W))
const MAGIC *mg = vmg_find(sv, w);
#if VMG_UVAR
-STATIC I32 vmg_svt_val(pTHX_ IV, SV *);
+static I32 vmg_svt_val(pTHX_ IV, SV *);
typedef struct {
struct ufuncs new_uf;
#endif /* VMG_UVAR */
-STATIC void vmg_mg_del(pTHX_ SV *sv, MAGIC *prevmagic, MAGIC *mg, MAGIC *moremagic) {
+static void vmg_mg_del(pTHX_ SV *sv, MAGIC *prevmagic, MAGIC *mg, MAGIC *moremagic) {
#define vmg_mg_del(S, P, M, N) vmg_mg_del(aTHX_ (S), (P), (M), (N))
dMY_CXT;
}
}
-STATIC int vmg_magic_chain_free(pTHX_ MAGIC *mg, MAGIC *skip) {
+static int vmg_magic_chain_free(pTHX_ MAGIC *mg, MAGIC *skip) {
#define vmg_magic_chain_free(M, S) vmg_magic_chain_free(aTHX_ (M), (S))
int skipped = 0;
return skipped;
}
-STATIC UV vmg_cast(pTHX_ SV *sv, const vmg_wizard *w, const SV *wiz, SV **args, I32 items) {
+static UV vmg_cast(pTHX_ SV *sv, const vmg_wizard *w, const SV *wiz, SV **args, I32 items) {
#define vmg_cast(S, W, WIZ, A, I) vmg_cast(aTHX_ (S), (W), (WIZ), (A), (I))
MAGIC *mg;
MGVTBL *t;
data = (w->cb_data) ? vmg_data_new(w->cb_data, sv, args, items) : NULL;
t = vmg_vtable_vtbl(w->vtable);
- mg = sv_magicext(sv, data, PERL_MAGIC_ext, t, (const char *) wiz, HEf_SVKEY);
- mg->mg_private = 0;
-
- /* sv_magicext() calls mg_magical and increments data's refcount */
- SvREFCNT_dec(data);
-
- if (t->svt_copy)
- mg->mg_flags |= MGf_COPY;
-#if 0
- if (t->svt_dup)
- mg->mg_flags |= MGf_DUP;
-#endif
-#if MGf_LOCAL
- if (t->svt_local)
- mg->mg_flags |= MGf_LOCAL;
-#endif /* MGf_LOCAL */
+ mg = vmg_sv_magicext(sv, data, t, wiz, HEf_SVKEY);
if (SvTYPE(sv) < SVt_PVHV)
goto done;
return 1;
}
-STATIC UV vmg_dispell(pTHX_ SV *sv, const vmg_wizard *w) {
+static UV vmg_dispell(pTHX_ SV *sv, const vmg_wizard *w) {
#define vmg_dispell(S, W) vmg_dispell(aTHX_ (S), (W))
#if VMG_UVAR
U32 uvars = 0;
#define VMG_OP_INFO_OBJECT 2
#if VMG_THREADSAFE
-STATIC perl_mutex vmg_op_name_init_mutex;
+static perl_mutex vmg_op_name_init_mutex;
#endif
-STATIC U32 vmg_op_name_init = 0;
-STATIC unsigned char vmg_op_name_len[MAXO] = { 0 };
+static U32 vmg_op_name_init = 0;
+static unsigned char vmg_op_name_len[MAXO] = { 0 };
-STATIC void vmg_op_info_init(pTHX_ unsigned int opinfo) {
+static void vmg_op_info_init(pTHX_ unsigned int opinfo) {
#define vmg_op_info_init(W) vmg_op_info_init(aTHX_ (W))
switch (opinfo) {
case VMG_OP_INFO_NAME:
}
}
-STATIC SV *vmg_op_info(pTHX_ unsigned int opinfo) {
+static SV *vmg_op_info(pTHX_ unsigned int opinfo) {
#define vmg_op_info(W) vmg_op_info(aTHX_ (W))
if (!PL_op)
return &PL_sv_undef;
switch (opinfo) {
case VMG_OP_INFO_NAME: {
- OPCODE t = PL_op->op_type;
- return sv_2mortal(newSVpvn(PL_op_name[t], vmg_op_name_len[t]));
+ const char *name;
+ STRLEN name_len;
+ OPCODE t = PL_op->op_type;
+ name = OP_NAME(PL_op);
+ name_len = (t == OP_CUSTOM) ? strlen(name) : vmg_op_name_len[t];
+ return sv_2mortal(newSVpvn(name, name_len));
}
case VMG_OP_INFO_OBJECT: {
dMY_CXT;
#define VMG_CB_CALL_OPINFO (VMG_OP_INFO_NAME|VMG_OP_INFO_OBJECT) /* 1|2 */
#define VMG_CB_CALL_GUARD 4
-STATIC int vmg_dispell_guard_oncroak(pTHX_ void *ud) {
+static int vmg_dispell_guard_oncroak(pTHX_ void *ud) {
dMY_CXT;
MY_CXT.depth--;
return 1;
}
-STATIC int vmg_dispell_guard_free(pTHX_ SV *sv, MAGIC *mg) {
+static int vmg_dispell_guard_free(pTHX_ SV *sv, MAGIC *mg) {
vmg_magic_chain_free((MAGIC *) mg->mg_ptr, NULL);
return 0;
#if VMG_THREADSAFE
-STATIC int vmg_dispell_guard_dup(pTHX_ MAGIC *mg, CLONE_PARAMS *params) {
+static int vmg_dispell_guard_dup(pTHX_ MAGIC *mg, CLONE_PARAMS *params) {
/* The freed magic tokens aren't cloned by perl because it cannot reach them
* (they have been detached from their parent SV when they were enqueued).
* Hence there's nothing to purge in the new thread. */
#endif /* VMG_THREADSAFE */
-STATIC MGVTBL vmg_dispell_guard_vtbl = {
+static MGVTBL vmg_dispell_guard_vtbl = {
NULL, /* get */
NULL, /* set */
NULL, /* len */
#endif /* MGf_LOCAL */
};
-STATIC SV *vmg_dispell_guard_new(pTHX_ MAGIC *root) {
+static SV *vmg_dispell_guard_new(pTHX_ MAGIC *root) {
#define vmg_dispell_guard_new(R) vmg_dispell_guard_new(aTHX_ (R))
SV *guard;
guard = sv_newmortal();
- sv_magicext(guard, NULL, PERL_MAGIC_ext, &vmg_dispell_guard_vtbl,
- (char *) root, 0);
+ vmg_sv_magicext(guard, NULL, &vmg_dispell_guard_vtbl, root, 0);
return guard;
}
-STATIC int vmg_cb_call(pTHX_ SV *cb, unsigned int flags, SV *sv, ...) {
+static int vmg_cb_call(pTHX_ SV *cb, unsigned int flags, SV *sv, ...) {
va_list ap;
int ret = 0;
unsigned int i, args, opinfo;
ENTER;
SAVETMPS;
+ PUSHSTACKi(PERLSI_MAGIC);
+
PUSHMARK(SP);
EXTEND(SP, args + 1);
PUSHs(sv_2mortal(newRV_inc(sv)));
svr = POPs;
if (SvOK(svr))
ret = (int) SvIV(svr);
+ if (SvROK(svr))
+ SvREFCNT_inc(svr);
+ else
+ svr = NULL;
PUTBACK;
+ POPSTACK;
+
FREETMPS;
LEAVE;
+ if (svr && !SvTEMP(svr))
+ sv_2mortal(svr);
+
if (chain) {
vmg_dispell_guard_new(*chain);
*chain = NULL;
/* ... Default no-op magic callback ........................................ */
-STATIC int vmg_svt_default_noop(pTHX_ SV *sv, MAGIC *mg) {
+static int vmg_svt_default_noop(pTHX_ SV *sv, MAGIC *mg) {
return 0;
}
/* ... get magic ........................................................... */
-STATIC int vmg_svt_get(pTHX_ SV *sv, MAGIC *mg) {
+static int vmg_svt_get(pTHX_ SV *sv, MAGIC *mg) {
const vmg_wizard *w = vmg_wizard_from_mg_nocheck(mg);
return vmg_cb_call1(w->cb_get, w->opinfo, sv, mg->mg_obj);
/* ... set magic ........................................................... */
-STATIC int vmg_svt_set(pTHX_ SV *sv, MAGIC *mg) {
+static int vmg_svt_set(pTHX_ SV *sv, MAGIC *mg) {
const vmg_wizard *w = vmg_wizard_from_mg_nocheck(mg);
return vmg_cb_call1(w->cb_set, w->opinfo, sv, mg->mg_obj);
/* ... len magic ........................................................... */
-STATIC U32 vmg_sv_len(pTHX_ SV *sv) {
+static U32 vmg_sv_len(pTHX_ SV *sv) {
#define vmg_sv_len(S) vmg_sv_len(aTHX_ (S))
STRLEN len;
#if VMG_HAS_PERL(5, 9, 3)
return DO_UTF8(sv) ? utf8_length(s, s + len) : len;
}
-STATIC U32 vmg_svt_len(pTHX_ SV *sv, MAGIC *mg) {
+static U32 vmg_svt_len(pTHX_ SV *sv, MAGIC *mg) {
const vmg_wizard *w = vmg_wizard_from_mg_nocheck(mg);
unsigned int opinfo = w->opinfo;
U32 len, ret;
ENTER;
SAVETMPS;
+ PUSHSTACKi(PERLSI_MAGIC);
+
PUSHMARK(SP);
EXTEND(SP, 3);
PUSHs(sv_2mortal(newRV_inc(sv)));
--ret;
PUTBACK;
+ POPSTACK;
+
FREETMPS;
LEAVE;
return ret;
}
-STATIC U32 vmg_svt_len_noop(pTHX_ SV *sv, MAGIC *mg) {
+static U32 vmg_svt_len_noop(pTHX_ SV *sv, MAGIC *mg) {
U32 len = 0;
svtype t = SvTYPE(sv);
/* ... clear magic ......................................................... */
-STATIC int vmg_svt_clear(pTHX_ SV *sv, MAGIC *mg) {
+static int vmg_svt_clear(pTHX_ SV *sv, MAGIC *mg) {
const vmg_wizard *w = vmg_wizard_from_mg_nocheck(mg);
unsigned int flags = w->opinfo;
#if VMG_PROPAGATE_ERRSV_NEEDS_TRAMPOLINE
-STATIC OP *vmg_pp_propagate_errsv(pTHX) {
+static OP *vmg_pp_propagate_errsv(pTHX) {
SVOP *o = cSVOPx(PL_op);
if (o->op_sv) {
- SvREFCNT_dec(ERRSV);
- ERRSV = o->op_sv;
+ sv_setsv(ERRSV, o->op_sv);
+ SvREFCNT_dec(o->op_sv);
o->op_sv = NULL;
}
#endif /* VMG_PROPAGATE_ERRSV_NEEDS_TRAMPOLINE */
-STATIC int vmg_propagate_errsv_free(pTHX_ SV *sv, MAGIC *mg) {
- if (mg->mg_obj) {
- ERRSV = mg->mg_obj;
- mg->mg_obj = NULL;
- mg->mg_flags &= ~MGf_REFCOUNTED;
- }
+static int vmg_propagate_errsv_free(pTHX_ SV *sv, MAGIC *mg) {
+ if (mg->mg_obj)
+ sv_setsv(ERRSV, mg->mg_obj);
return 0;
}
/* perl is already kind enough to handle the cloning of the mg_obj member,
hence we don't need to define a dup magic callback. */
-STATIC MGVTBL vmg_propagate_errsv_vtbl = {
+static MGVTBL vmg_propagate_errsv_vtbl = {
0, /* get */
0, /* set */
0, /* len */
I32 base;
} vmg_svt_free_cleanup_ud;
-STATIC int vmg_svt_free_cleanup(pTHX_ void *ud_) {
+static int vmg_svt_free_cleanup(pTHX_ void *ud_) {
vmg_svt_free_cleanup_ud *ud = VOID2(vmg_svt_free_cleanup_ud *, ud_);
if (ud->in_eval) {
PL_op = vmg_trampoline_bump(&MY_CXT.propagate_errsv, errsv, PL_op);
} else if (optype == OP_LEAVEEVAL) {
SV *guard = sv_newmortal();
- sv_magicext(guard, errsv, PERL_MAGIC_ext, &vmg_propagate_errsv_vtbl,
- NULL, 0);
+ vmg_sv_magicext(guard, errsv, &vmg_propagate_errsv_vtbl, NULL, 0);
}
#else /* !VMG_PROPAGATE_ERRSV_NEEDS_TRAMPOLINE */
# if !VMG_HAS_PERL(5, 8, 9)
{
SV *guard = sv_newmortal();
- sv_magicext(guard, errsv, PERL_MAGIC_ext, &vmg_propagate_errsv_vtbl,
- NULL, 0);
+ vmg_sv_magicext(guard, errsv, &vmg_propagate_errsv_vtbl, NULL, 0);
}
# else
- sv_magicext(ERRSV, errsv, PERL_MAGIC_ext, &vmg_propagate_errsv_vtbl,
- NULL, 0);
- SvREFCNT_dec(errsv);
+ vmg_sv_magicext(ERRSV, errsv, &vmg_propagate_errsv_vtbl, NULL, 0);
# endif
#endif /* VMG_PROPAGATE_ERRSV_NEEDS_TRAMPOLINE */
}
}
-STATIC int vmg_svt_free(pTHX_ SV *sv, MAGIC *mg) {
+static int vmg_svt_free(pTHX_ SV *sv, MAGIC *mg) {
vmg_svt_free_cleanup_ud ud;
const vmg_wizard *w;
int ret = 0;
ENTER;
SAVETMPS;
+ PUSHSTACKi(PERLSI_MAGIC);
+
PUSHMARK(SP);
EXTEND(SP, 2);
PUSHs(sv_2mortal(newRV_inc(sv)));
ret = (int) SvIV(svr);
PUTBACK;
+ POPSTACK;
+
FREETMPS;
LEAVE;
/* ... copy magic .......................................................... */
-STATIC int vmg_svt_copy(pTHX_ SV *sv, MAGIC *mg, SV *nsv, const char *key, VMG_SVT_COPY_KEYLEN_TYPE keylen) {
+static int vmg_svt_copy(pTHX_ SV *sv, MAGIC *mg, SV *nsv, const char *key, VMG_SVT_COPY_KEYLEN_TYPE keylen) {
const vmg_wizard *w = vmg_wizard_from_mg_nocheck(mg);
SV *keysv;
int ret;
keysv = newSVpvn(key, keylen);
}
+ if (SvTYPE(sv) >= SVt_PVCV)
+ nsv = sv_2mortal(newRV_inc(nsv));
+
ret = vmg_cb_call3(w->cb_copy, w->opinfo, sv, mg->mg_obj, keysv, nsv);
if (keylen != HEf_SVKEY) {
return ret;
}
-STATIC int vmg_svt_copy_noop(pTHX_ SV *sv, MAGIC *mg, SV *nsv, const char *key, VMG_SVT_COPY_KEYLEN_TYPE keylen) {
+static int vmg_svt_copy_noop(pTHX_ SV *sv, MAGIC *mg, SV *nsv, const char *key, VMG_SVT_COPY_KEYLEN_TYPE keylen) {
return 0;
}
/* ... dup magic ........................................................... */
#if 0
-STATIC int vmg_svt_dup(pTHX_ MAGIC *mg, CLONE_PARAMS *param) {
+static int vmg_svt_dup(pTHX_ MAGIC *mg, CLONE_PARAMS *param) {
return 0;
}
#define vmg_svt_dup_noop vmg_svt_dup
#if MGf_LOCAL
-STATIC int vmg_svt_local(pTHX_ SV *nsv, MAGIC *mg) {
+static int vmg_svt_local(pTHX_ SV *nsv, MAGIC *mg) {
const vmg_wizard *w = vmg_wizard_from_mg_nocheck(mg);
return vmg_cb_call1(w->cb_local, w->opinfo, nsv, mg->mg_obj);
#if VMG_UVAR
-STATIC OP *vmg_pp_reset_rmg(pTHX) {
+static OP *vmg_pp_reset_rmg(pTHX) {
SVOP *o = cSVOPx(PL_op);
SvRMAGICAL_on(o->op_sv);
return NORMAL;
}
-STATIC I32 vmg_svt_val(pTHX_ IV action, SV *sv) {
+static I32 vmg_svt_val(pTHX_ IV action, SV *sv) {
vmg_uvar_ud *ud;
MAGIC *mg, *umg, *moremagic;
SV *key = NULL, *newkey = NULL;
#endif /* VMG_UVAR */
-/* --- Macros for the XS section ------------------------------------------- */
+/* --- Module setup/teardown ----------------------------------------------- */
-#ifdef CvISXSUB
-# define VMG_CVOK(C) \
- ((CvISXSUB(C) ? (void *) CvXSUB(C) : (void *) CvROOT(C)) ? 1 : 0)
-#else
-# define VMG_CVOK(C) (CvROOT(C) || CvXSUB(C))
-#endif
+#if VMG_THREADSAFE
-#define VMG_CBOK(S) ((SvTYPE(S) == SVt_PVCV) ? VMG_CVOK(S) : SvOK(S))
+static I32 vmg_loaded = 0;
-#define VMG_SET_CB(S, N) { \
- SV *cb = (S); \
- if (SvOK(cb) && SvROK(cb)) { \
- cb = SvRV(cb); \
- if (VMG_CBOK(cb)) \
- SvREFCNT_inc_simple_void(cb); \
- else \
- cb = NULL; \
- } else { \
- cb = NULL; \
- } \
- w->cb_ ## N = cb; \
+/* We must use preexistent global mutexes or we will never be able to destroy
+ * them. */
+# if VMG_HAS_PERL(5, 9, 3)
+# define VMG_LOADED_LOCK MUTEX_LOCK(&PL_my_ctx_mutex)
+# define VMG_LOADED_UNLOCK MUTEX_UNLOCK(&PL_my_ctx_mutex)
+# else
+# define VMG_LOADED_LOCK OP_REFCNT_LOCK
+# define VMG_LOADED_UNLOCK OP_REFCNT_UNLOCK
+# endif
+
+static void vmg_global_teardown_late_locked(pTHX) {
+#define vmg_global_teardown_late_locked() vmg_global_teardown_late_locked(aTHX)
+ MUTEX_DESTROY(&vmg_op_name_init_mutex);
+ MUTEX_DESTROY(&vmg_vtable_refcount_mutex);
+
+ return;
}
-#define VMG_SET_SVT_CB(S, N) { \
- SV *cb = (S); \
- if (SvOK(cb) && SvROK(cb)) { \
- cb = SvRV(cb); \
- if (VMG_CBOK(cb)) { \
- t->svt_ ## N = vmg_svt_ ## N; \
- SvREFCNT_inc_simple_void(cb); \
- } else { \
- t->svt_ ## N = vmg_svt_ ## N ## _noop; \
- cb = NULL; \
- } \
- } else { \
- t->svt_ ## N = NULL; \
- cb = NULL; \
- } \
- w->cb_ ## N = cb; \
+static int vmg_global_teardown_free(pTHX_ SV *sv, MAGIC *mg) {
+ VMG_LOADED_LOCK;
+
+ if (vmg_loaded == 0)
+ vmg_global_teardown_late_locked();
+
+ VMG_LOADED_UNLOCK;
+
+ return 0;
}
-/* --- XS ------------------------------------------------------------------ */
+static MGVTBL vmg_global_teardown_vtbl = {
+ 0,
+ 0,
+ 0,
+ 0,
+ vmg_global_teardown_free
+#if MGf_COPY
+ , 0
+#endif
+#if MGf_DUP
+ , 0
+#endif
+#if MGf_LOCAL
+ , 0
+#endif
+};
-MODULE = Variable::Magic PACKAGE = Variable::Magic
+static signed char vmg_destruct_level(pTHX) {
+#define vmg_destruct_level() vmg_destruct_level(aTHX)
+ signed char lvl;
-PROTOTYPES: ENABLE
+ lvl = PL_perl_destruct_level;
-BOOT:
-{
+#ifdef DEBUGGING
+ {
+ const char *s = PerlEnv_getenv("PERL_DESTRUCT_LEVEL");
+ if (s) {
+ int i;
+#if VMG_HAS_PERL(5, 21, 3)
+ if (strEQ(s, "-1")) {
+ i = -1;
+ } else {
+# if VMG_HAS_PERL(5, 21, 10)
+ UV uv;
+ if (Perl_grok_atoUV(s, &uv, NULL) && uv <= INT_MAX)
+ i = (int) uv;
+ else
+ i = 0;
+# else /* VMG_HAS_PERL(5, 21, 3) && !VMG_HAS_PERL(5, 21, 10) */
+ i = Perl_grok_atou(s, NULL);
+# endif
+ }
+#else /* !VMG_HAS_PERL(5, 21, 3) */
+ i = atoi(s);
+#endif
+ if (lvl < i)
+ lvl = i;
+ }
+ }
+#endif
+
+ return lvl;
+}
+
+#endif /* VMG_THREADSAFE */
+
+static void vmg_teardown(pTHX_ void *param) {
+ dMY_CXT;
+
+#if VMG_THREADSAFE
+ VMG_LOADED_LOCK;
+
+ if (vmg_loaded == 1) {
+ vmg_loaded = 0;
+ if (vmg_destruct_level() == 0) {
+ vmg_global_teardown_late_locked();
+ } else {
+ if (!PL_strtab)
+ PL_strtab = newHV();
+ vmg_sv_magicext((SV *) PL_strtab, NULL, &vmg_global_teardown_vtbl, NULL, 0);
+ }
+ } else {
+ VMG_ASSERT(vmg_loaded > 1);
+ --vmg_loaded;
+ }
+
+ VMG_LOADED_UNLOCK;
+#endif
+
+ if (MY_CXT.depth == 0 && MY_CXT.freed_tokens) {
+ vmg_magic_chain_free(MY_CXT.freed_tokens, NULL);
+ MY_CXT.freed_tokens = NULL;
+ }
+
+ return;
+}
+
+static void vmg_setup(pTHX) {
+#define vmg_setup() vmg_setup(aTHX)
HV *stash;
int c;
-
MY_CXT_INIT;
+
+#if VMG_THREADSAFE
+ VMG_LOADED_LOCK;
+
+ if (vmg_loaded == 0) {
+ MUTEX_INIT(&vmg_vtable_refcount_mutex);
+ MUTEX_INIT(&vmg_op_name_init_mutex);
+ vmg_loaded = 1;
+ } else {
+ VMG_ASSERT(vmg_loaded > 0);
+ ++vmg_loaded;
+ }
+
+ VMG_LOADED_UNLOCK;
+#endif
+
for (c = OPc_NULL; c < OPc_MAX; ++c)
MY_CXT.b__op_stashes[c] = NULL;
MY_CXT.depth = 0;
MY_CXT.freed_tokens = NULL;
- /* XS doesn't like a blank line here */
#if VMG_PROPAGATE_ERRSV_NEEDS_TRAMPOLINE
vmg_trampoline_init(&MY_CXT.propagate_errsv, vmg_pp_propagate_errsv);
#endif
vmg_trampoline_init(&MY_CXT.reset_rmg, vmg_pp_reset_rmg);
#endif
- /* XS doesn't like a blank line here */
-#if VMG_THREADSAFE
- MUTEX_INIT(&vmg_vtable_refcount_mutex);
- MUTEX_INIT(&vmg_op_name_init_mutex);
-#endif
-
stash = gv_stashpv(__PACKAGE__, 1);
newCONSTSUB(stash, "MGf_COPY", newSVuv(MGf_COPY));
newCONSTSUB(stash, "MGf_DUP", newSVuv(MGf_DUP));
newSVuv(VMG_COMPAT_ARRAY_UNDEF_CLEAR));
newCONSTSUB(stash, "VMG_COMPAT_HASH_DELETE_NOUVAR_VOID",
newSVuv(VMG_COMPAT_HASH_DELETE_NOUVAR_VOID));
+ newCONSTSUB(stash, "VMG_COMPAT_CODE_COPY_CLONE",
+ newSVuv(VMG_COMPAT_CODE_COPY_CLONE));
newCONSTSUB(stash, "VMG_COMPAT_GLOB_GET", newSVuv(VMG_COMPAT_GLOB_GET));
newCONSTSUB(stash, "VMG_PERL_PATCHLEVEL", newSVuv(VMG_PERL_PATCHLEVEL));
newCONSTSUB(stash, "VMG_THREADSAFE", newSVuv(VMG_THREADSAFE));
newCONSTSUB(stash, "VMG_FORKSAFE", newSVuv(VMG_FORKSAFE));
newCONSTSUB(stash, "VMG_OP_INFO_NAME", newSVuv(VMG_OP_INFO_NAME));
newCONSTSUB(stash, "VMG_OP_INFO_OBJECT", newSVuv(VMG_OP_INFO_OBJECT));
+
+ call_atexit(vmg_teardown, NULL);
+
+ return;
+}
+
+/* --- Macros for the XS section ------------------------------------------- */
+
+#ifdef CvISXSUB
+# define VMG_CVOK(C) \
+ ((CvISXSUB(C) ? (void *) CvXSUB(C) : (void *) CvROOT(C)) ? 1 : 0)
+#else
+# define VMG_CVOK(C) (CvROOT(C) || CvXSUB(C))
+#endif
+
+#define VMG_CBOK(S) ((SvTYPE(S) == SVt_PVCV) ? VMG_CVOK(S) : SvOK(S))
+
+#define VMG_SET_CB(S, N) { \
+ SV *cb = (S); \
+ if (SvOK(cb) && SvROK(cb)) { \
+ cb = SvRV(cb); \
+ if (VMG_CBOK(cb)) \
+ SvREFCNT_inc_simple_void(cb); \
+ else \
+ cb = NULL; \
+ } else { \
+ cb = NULL; \
+ } \
+ w->cb_ ## N = cb; \
+}
+
+#define VMG_SET_SVT_CB(S, N) { \
+ SV *cb = (S); \
+ if (SvOK(cb) && SvROK(cb)) { \
+ cb = SvRV(cb); \
+ if (VMG_CBOK(cb)) { \
+ t->svt_ ## N = vmg_svt_ ## N; \
+ SvREFCNT_inc_simple_void(cb); \
+ } else { \
+ t->svt_ ## N = vmg_svt_ ## N ## _noop; \
+ cb = NULL; \
+ } \
+ } else { \
+ t->svt_ ## N = NULL; \
+ cb = NULL; \
+ } \
+ w->cb_ ## N = cb; \
+}
+
+/* --- XS ------------------------------------------------------------------ */
+
+MODULE = Variable::Magic PACKAGE = Variable::Magic
+
+PROTOTYPES: ENABLE
+
+BOOT:
+{
+ vmg_setup();
}
#if VMG_THREADSAFE
}
MY_CXT.depth = old_depth;
MY_CXT.freed_tokens = NULL;
+ VMG_LOADED_LOCK;
+ VMG_ASSERT(vmg_loaded > 0);
+ ++vmg_loaded;
+ VMG_LOADED_UNLOCK;
}
XSRETURN(0);