#if LT_HAS_PERL(5, 10, 0) || defined(PL_parser)
# ifndef PL_in_my_stash
# define PL_in_my_stash PL_parser->in_my_stash
+# define PL_tokenbuf PL_parser->tokenbuf
# endif
#else
# ifndef PL_in_my_stash
# define PL_in_my_stash PL_Iin_my_stash
+# define PL_tokenbuf PL_Itokenbuf
# endif
#endif
# define LT_HAS_RPEEP LT_HAS_PERL(5, 13, 5)
#endif
+#ifndef STR_WITH_LEN
+# define STR_WITH_LEN(s) ("" s ""), (sizeof(s)-1)
+#endif
+
+#ifndef newSVpvs
+# define newSVpvs(S) Perl_newSVpvn(aTHX_ STR_WITH_LEN(S))
+#endif
+
#ifndef HvNAME_get
# define HvNAME_get(H) HvNAME(H)
#endif
# define HvNAMELEN_get(H) strlen(HvNAME_get(H))
#endif
-#ifndef SvREFCNT_inc_simple_NN
-# define SvREFCNT_inc_simple_NN SvREFCNT_inc
+#ifndef SvREFCNT_inc_simple_void_NN
+# define SvREFCNT_inc_simple_void_NN(S) ((void) SvREFCNT_inc(S))
#endif
/* ... Thread safety and multiplicity ...................................... */
+/* Safe unless stated otherwise in Makefile.PL */
+#ifndef LT_FORKSAFE
+# define LT_FORKSAFE 1
+#endif
+
#ifndef LT_MULTIPLICITY
# if defined(MULTIPLICITY) || defined(PERL_IMPLICIT_CONTEXT)
# define LT_MULTIPLICITY 1
# define aMY_CXT_
#endif
+#if defined(OP_CHECK_MUTEX_LOCK) && defined(OP_CHECK_MUTEX_UNLOCK)
+# define LT_CHECK_MUTEX_LOCK OP_CHECK_MUTEX_LOCK
+# define LT_CHECK_MUTEX_UNLOCK OP_CHECK_MUTEX_UNLOCK
+#else
+# define LT_CHECK_MUTEX_LOCK OP_REFCNT_LOCK
+# define LT_CHECK_MUTEX_UNLOCK OP_REFCNT_UNLOCK
+#endif
+
+typedef OP *(*lt_ck_t)(pTHX_ OP *);
+
+#ifdef wrap_op_checker
+
+# define lt_ck_replace(T, NC, OCP) wrap_op_checker((T), (NC), (OCP))
+
+#else
+
+STATIC void lt_ck_replace(pTHX_ OPCODE type, lt_ck_t new_ck, lt_ck_t *old_ck_p){
+#define lt_ck_replace(T, NC, OCP) lt_ck_replace(aTHX_ (T), (NC), (OCP))
+ LT_CHECK_MUTEX_LOCK;
+ if (!*old_ck_p) {
+ *old_ck_p = PL_check[type];
+ PL_check[type] = new_ck;
+ }
+ LT_CHECK_MUTEX_UNLOCK;
+}
+
+#endif
+
+STATIC void lt_ck_restore(pTHX_ OPCODE type, lt_ck_t *old_ck_p) {
+#define lt_ck_restore(T, OCP) lt_ck_restore(aTHX_ (T), (OCP))
+ LT_CHECK_MUTEX_LOCK;
+ if (*old_ck_p) {
+ PL_check[type] = *old_ck_p;
+ *old_ck_p = 0;
+ }
+ LT_CHECK_MUTEX_UNLOCK;
+}
+
/* --- Helpers ------------------------------------------------------------- */
/* ... Thread-safe hints ................................................... */
/* ... "Seen" pointer table ................................................ */
-#if !LT_HAS_RPEEP
-
#define PTABLE_NAME ptable_seen
#define PTABLE_VAL_FREE(V) NOOP
#include "ptable.h"
-#endif /* !LT_HAS_RPEEP */
+/* PerlMemShared_free() needs the [ap]PTBLMS_? default values */
+#define ptable_seen_store(T, K, V) ptable_seen_store(aPTBLMS_ (T), (K), (V))
+#define ptable_seen_clear(T) ptable_seen_clear(aPTBLMS_ (T))
+#define ptable_seen_free(T) ptable_seen_free(aPTBLMS_ (T))
/* ... Global data ......................................................... */
#define MY_CXT_KEY __PACKAGE__ "::_guts" XS_VERSION
+#define LT_TYPE_SCALAR 0
+
+#if LT_HAS_PERL(5, 11, 1)
+
+#define LT_TYPE_ARRAY 1
+#define LT_TYPE_HASH 2
+
+#define LT_TYPE_COUNT 3
+
+#else
+
+#define LT_TYPE_COUNT 1
+
+#endif
+
typedef struct {
#if LT_THREADSAFE
ptable *tbl; /* It really is a ptable_hints */
tTHX owner;
#endif
-#if !LT_HAS_RPEEP
ptable *seen; /* It really is a ptable_seen */
-#endif
- SV *default_meth;
+ SV *default_meth[LT_TYPE_COUNT];
} my_cxt_t;
START_MY_CXT
dMY_CXT;
ptable_hints_free(MY_CXT.tbl);
-#if !LT_HAS_RPEEP
ptable_seen_free(MY_CXT.seen);
-#endif /* !LT_HAS_RPEEP */
}
#endif /* LT_THREADSAFE */
value = SvRV(value);
if (SvTYPE(value) >= SVt_PVCV) {
code = value;
- SvREFCNT_inc_simple_NN(code);
+ SvREFCNT_inc_simple_void_NN(code);
}
}
0,
lt_hash);
#else
- SV **val = hv_fetch(GvHV(PL_hintgv), __PACKAGE__, __PACKAGE_LEN__, lt_hash);
+ SV **val = hv_fetch(GvHV(PL_hintgv), __PACKAGE__, __PACKAGE_LEN__, 0);
if (!val)
return 0;
hint = *val;
/* PerlMemShared_free() needs the [ap]PTBLMS_? default values */
#define ptable_map_store(T, K, V) ptable_map_store(aPTBLMS_ (T), (K), (V))
-
-STATIC ptable *lt_op_map = NULL;
+#define ptable_map_delete(T, K) ptable_map_delete(aPTBLMS_ (T), (K))
#ifdef USE_ITHREADS
#endif /* !USE_ITHREADS */
+STATIC ptable *lt_op_padxv_map = NULL;
+
typedef struct {
+ OP *(*old_pp)(pTHX);
#ifdef MULTIPLICITY
STRLEN buf_size, orig_pkg_len, type_pkg_len, type_meth_len;
char *buf;
SV *type_pkg;
SV *type_meth;
#endif /* !MULTIPLICITY */
- OP *(*old_pp_padsv)(pTHX);
-} lt_op_info;
+} lt_op_padxv_info;
+
+STATIC const char lt_type_desc_scalar[] = "scalar";
+STATIC const char lt_type_desc_array[] = "array";
+STATIC const char lt_type_desc_hash[] = "hash";
+
+STATIC void lt_op_padxv_info_call(pTHX_ const lt_op_padxv_info *oi, SV *sv) {
+#define lt_op_padxv_info_call(O, S) lt_op_padxv_info_call(aTHX_ (O), (S))
+ SV *orig_pkg, *type_pkg, *type_meth;
+ svtype var_type;
+ int items;
+ dSP;
-STATIC void lt_map_store(pTHX_ const OP *o, SV *orig_pkg, SV *type_pkg, SV *type_meth, OP *(*old_pp_padsv)(pTHX)) {
-#define lt_map_store(O, OP, TP, TM, PP) lt_map_store(aTHX_ (O), (OP), (TP), (TM), (PP))
- lt_op_info *oi;
+ ENTER;
+ SAVETMPS;
+
+#ifdef MULTIPLICITY
+ {
+ STRLEN op_len = oi->orig_pkg_len, tp_len = oi->type_pkg_len;
+ char *buf = oi->buf;
+ orig_pkg = sv_2mortal(newSVpvn(buf, op_len));
+ SvREADONLY_on(orig_pkg);
+ buf += op_len;
+ type_pkg = sv_2mortal(newSVpvn(buf, tp_len));
+ SvREADONLY_on(type_pkg);
+ buf += tp_len;
+ type_meth = sv_2mortal(newSVpvn(buf, oi->type_meth_len));
+ SvREADONLY_on(type_meth);
+ }
+#else /* MULTIPLICITY */
+ orig_pkg = oi->orig_pkg;
+ type_pkg = oi->type_pkg;
+ type_meth = oi->type_meth;
+#endif /* !MULTIPLICITY */
+
+ PUSHMARK(SP);
+ EXTEND(SP, 3);
+ PUSHs(type_pkg);
+ var_type = SvTYPE(sv);
+ switch (var_type) {
+ case SVt_PVAV:
+ case SVt_PVHV:
+ PUSHs(sv_2mortal(newRV_inc(sv)));
+ break;
+ default:
+ PUSHs(sv);
+ break;
+ }
+ PUSHs(orig_pkg);
+ PUTBACK;
+
+ items = call_sv(type_meth, G_ARRAY | G_METHOD);
+
+ SPAGAIN;
+ switch (items) {
+ case 0:
+ break;
+ case 1: {
+ SV *rsv = POPs;
+ switch (var_type) {
+ case SVt_PVAV:
+ if (SvROK(rsv) && SvTYPE(SvRV(rsv)) == var_type) {
+ AV *av = (AV *) SvRV(rsv);
+ SV **src, **dst;
+ I32 len = av_len(av);
+ I32 i;
+ av_fill((AV *) sv, len);
+ src = AvARRAY(av);
+ dst = AvARRAY(sv);
+ for (i = 0; i <= len; ++i, ++src, ++dst) {
+ SvREFCNT_dec(*dst);
+ *dst = SvREFCNT_inc(*src);
+ }
+ } else {
+ goto type_mismatch;
+ }
+ break;
+ case SVt_PVHV:
+ if (SvROK(rsv) && SvTYPE(SvRV(rsv)) == var_type) {
+ HV *hv = (HV *) SvRV(rsv);
+ HE *he;
+ hv_iterinit(hv);
+ hv_clear((HV *) sv);
+ while ((he = hv_iternext(hv)) != NULL) {
+ SV *val = SvREFCNT_inc(HeVAL(he));
+ if (!hv_store((HV *) sv, HeKEY(he), HeKLEN(he), val, HeHASH(he)))
+ SvREFCNT_dec(val);
+ }
+ } else {
+ goto type_mismatch;
+ }
+ break;
+ default:
+ sv_setsv(sv, rsv);
+ break;
+ }
+ break;
+type_mismatch:
+ croak("Type mismatch");
+ }
+ default: {
+ const char *type_desc;
+ switch (var_type) {
+ case SVt_PVAV:
+ type_desc = lt_type_desc_array;
+ break;
+ case SVt_PVHV:
+ type_desc = lt_type_desc_hash;
+ break;
+ default:
+ type_desc = lt_type_desc_scalar;
+ break;
+ }
+ croak("Typed %s initializer method should return zero or one scalar, but got %d", type_desc, items);
+ }
+ }
+ PUTBACK;
+
+ FREETMPS;
+ LEAVE;
+
+ return;
+}
+
+STATIC void lt_padxv_map_store(pTHX_ const OP *o, SV *orig_pkg, SV *type_pkg, SV *type_meth, OP *(*old_pp)(pTHX)) {
+#define lt_padxv_map_store(O, OP, TP, TM, PP) lt_padxv_map_store(aTHX_ (O), (OP), (TP), (TM), (PP))
+ lt_op_padxv_info *oi;
LT_LOCK(<_op_map_mutex);
- if (!(oi = ptable_fetch(lt_op_map, o))) {
+ if (!(oi = ptable_fetch(lt_op_padxv_map, o))) {
oi = PerlMemShared_malloc(sizeof *oi);
- ptable_map_store(lt_op_map, o, oi);
+ ptable_map_store(lt_op_padxv_map, o, oi);
#ifdef MULTIPLICITY
oi->buf = NULL;
oi->buf_size = 0;
oi->type_meth = type_meth;
#endif /* !MULTIPLICITY */
- oi->old_pp_padsv = old_pp_padsv;
+ oi->old_pp = old_pp;
+
+ LT_UNLOCK(<_op_map_mutex);
+}
+
+STATIC const lt_op_padxv_info *lt_padxv_map_fetch(const OP *o, lt_op_padxv_info *oi) {
+ const lt_op_padxv_info *val;
+
+ LT_LOCK(<_op_map_mutex);
+
+ val = ptable_fetch(lt_op_padxv_map, o);
+ if (val) {
+ *oi = *val;
+ val = oi;
+ }
+
+ LT_UNLOCK(<_op_map_mutex);
+
+ return val;
+}
+
+#if LT_HAS_PERL(5, 17, 6)
+
+STATIC ptable *lt_op_padrange_map = NULL;
+
+typedef struct {
+ OP *(*old_pp)(pTHX);
+ const OP *padxv_start;
+} lt_op_padrange_info;
+
+STATIC void lt_padrange_map_store(pTHX_ const OP *o, const OP *s, OP *(*old_pp)(pTHX)) {
+#define lt_padrange_map_store(O, S, PP) lt_padrange_map_store(aTHX_ (O), (S), (PP))
+ lt_op_padrange_info *oi;
+
+ LT_LOCK(<_op_map_mutex);
+
+ if (!(oi = ptable_fetch(lt_op_padrange_map, o))) {
+ oi = PerlMemShared_malloc(sizeof *oi);
+ ptable_map_store(lt_op_padrange_map, o, oi);
+ }
+
+ oi->old_pp = old_pp;
+ oi->padxv_start = s;
LT_UNLOCK(<_op_map_mutex);
}
-STATIC const lt_op_info *lt_map_fetch(const OP *o, lt_op_info *oi) {
- const lt_op_info *val;
+STATIC const lt_op_padrange_info *lt_padrange_map_fetch(const OP *o, lt_op_padrange_info *oi) {
+ const lt_op_padrange_info *val;
LT_LOCK(<_op_map_mutex);
- val = ptable_fetch(lt_op_map, o);
+ val = ptable_fetch(lt_op_padrange_map, o);
if (val) {
*oi = *val;
val = oi;
return val;
}
+#endif
+
STATIC void lt_map_delete(pTHX_ const OP *o) {
#define lt_map_delete(O) lt_map_delete(aTHX_ (O))
LT_LOCK(<_op_map_mutex);
- ptable_map_delete(lt_op_map, o);
+ ptable_map_delete(lt_op_padxv_map, o);
+#if LT_HAS_PERL(5, 17, 6)
+ ptable_map_delete(lt_op_padrange_map, o);
+#endif
LT_UNLOCK(<_op_map_mutex);
}
/* ... Our pp_padsv ........................................................ */
-STATIC OP *lt_pp_padsv(pTHX) {
- lt_op_info oi;
+STATIC OP *lt_pp_padxv(pTHX) {
+ lt_op_padxv_info oi;
- if (lt_map_fetch(PL_op, &oi)) {
- SV *orig_pkg, *type_pkg, *type_meth;
- int items;
- dSP;
+ if (lt_padxv_map_fetch(PL_op, &oi)) {
dTARGET;
+ lt_op_padxv_info_call(&oi, TARG);
+ return oi.old_pp(aTHX);
+ }
- ENTER;
- SAVETMPS;
+ return PL_op->op_ppaddr(aTHX);
+}
-#ifdef MULTIPLICITY
- {
- STRLEN op_len = oi.orig_pkg_len, tp_len = oi.type_pkg_len;
- char *buf = oi.buf;
- orig_pkg = sv_2mortal(newSVpvn(buf, op_len));
- SvREADONLY_on(orig_pkg);
- buf += op_len;
- type_pkg = sv_2mortal(newSVpvn(buf, tp_len));
- SvREADONLY_on(type_pkg);
- buf += tp_len;
- type_meth = sv_2mortal(newSVpvn(buf, oi.type_meth_len));
- SvREADONLY_on(type_meth);
- }
-#else /* MULTIPLICITY */
- orig_pkg = oi.orig_pkg;
- type_pkg = oi.type_pkg;
- type_meth = oi.type_meth;
-#endif /* !MULTIPLICITY */
+/* ... Our pp_padrange (on perl 5.17.6 and above) .......................... */
- PUSHMARK(SP);
- EXTEND(SP, 3);
- PUSHs(type_pkg);
- PUSHTARG;
- PUSHs(orig_pkg);
- PUTBACK;
+#if LT_HAS_PERL(5, 17, 6)
- items = call_sv(type_meth, G_ARRAY | G_METHOD);
+STATIC OP *lt_pp_padrange(pTHX) {
+ lt_op_padrange_info roi;
- SPAGAIN;
- switch (items) {
- case 0:
- break;
- case 1:
- sv_setsv(TARG, POPs);
- break;
- default:
- croak("Typed scalar initializer method should return zero or one scalar, but got %d", items);
- }
- PUTBACK;
+ if (lt_padrange_map_fetch(PL_op, &roi)) {
+ PADOFFSET i, base, count;
+ const OP *p;
- FREETMPS;
- LEAVE;
+ base = PL_op->op_targ;
+ count = PL_op->op_private & OPpPADRANGE_COUNTMASK;
- return oi.old_pp_padsv(aTHX);
+ for (i = 0, p = roi.padxv_start; i < count && p; ++i, p = p->op_sibling) {
+ lt_op_padxv_info oi;
+
+ switch (p->op_type) {
+ case OP_PADSV:
+#if LT_HAS_PERL(5, 11, 1)
+ case OP_PADAV:
+ case OP_PADHV:
+#endif
+ if (lt_padxv_map_fetch(p, &oi))
+ lt_op_padxv_info_call(&oi, PAD_SV(base + i));
+ break;
+ default:
+ break;
+ }
+ }
+
+ return roi.old_pp(aTHX);
}
return PL_op->op_ppaddr(aTHX);
}
-/* ... Our ck_pad{any,sv} .................................................. */
+#endif
-/* Sadly, the padsv OPs we are interested in don't trigger the padsv check
- * function, but are instead manually mutated from a padany. So we store
+/* ... Our ck_pad{any,sv,av,hv} ............................................ */
+
+/* Sadly, the padxv OPs we are interested in don't trigger the padxv check
+ * functions, but are instead manually mutated from a padany. So we store
* the op entry in the op map in the padany check function, and we set their
* op_ppaddr member in our peephole optimizer replacement below. */
if (stash && (code = lt_hint())) {
dMY_CXT;
SV *orig_pkg = newSVpvn(HvNAME_get(stash), HvNAMELEN_get(stash));
- SV *orig_meth = MY_CXT.default_meth;
+ SV *orig_meth = NULL;
SV *type_pkg = NULL;
SV *type_meth = NULL;
+ unsigned int type;
+ const char *s;
int items;
+ s = PL_tokenbuf;
+ while (*s && isSPACE(*s))
+ ++s;
+ switch (*s) {
+ case '$':
+ type = LT_TYPE_SCALAR;
+ break;
+#if LT_HAS_PERL(5, 11, 1)
+ case '@':
+ type = LT_TYPE_ARRAY;
+ break;
+ case '%':
+ type = LT_TYPE_HASH;
+ break;
+#endif
+ default:
+ croak("Unsupported sigil '%c'", *s);
+ break;
+ }
+ orig_meth = MY_CXT.default_meth[type];
+
dSP;
SvREADONLY_on(orig_pkg);
if (!type_pkg) {
type_pkg = orig_pkg;
- SvREFCNT_inc(orig_pkg);
+ SvREFCNT_inc_simple_void_NN(orig_pkg);
}
if (!type_meth) {
type_meth = orig_meth;
- SvREFCNT_inc(orig_meth);
+ SvREFCNT_inc_simple_void_NN(orig_meth);
}
- lt_map_store(o, orig_pkg, type_pkg, type_meth, o->op_ppaddr);
+ lt_padxv_map_store(o, orig_pkg, type_pkg, type_meth, o->op_ppaddr);
} else {
skip:
lt_map_delete(o);
return lt_old_ck_padsv(aTHX_ o);
}
+#if LT_HAS_PERL(5, 11, 1)
+
+STATIC OP *(*lt_old_ck_padav)(pTHX_ OP *) = 0;
+
+STATIC OP *lt_ck_padav(pTHX_ OP *o) {
+ lt_map_delete(o);
+
+ return lt_old_ck_padav(aTHX_ o);
+}
+
+STATIC OP *(*lt_old_ck_padhv)(pTHX_ OP *) = 0;
+
+STATIC OP *lt_ck_padhv(pTHX_ OP *o) {
+ lt_map_delete(o);
+
+ return lt_old_ck_padhv(aTHX_ o);
+}
+
+#endif
+
/* ... Our peephole optimizer .............................................. */
-STATIC peep_t lt_old_peep = 0; /* This is actually the rpeep past 5.13.5 */
+#if LT_HAS_PERL(5, 17, 6)
-#if !LT_HAS_RPEEP
-# define LT_PEEP_REC_PROTO STATIC void lt_peep_rec(pTHX_ OP *o, ptable *seen)
-#else /* !LT_HAS_RPEEP */
-# define LT_PEEP_REC_PROTO STATIC void lt_peep_rec(pTHX_ OP *o)
-#endif /* LT_HAS_RPEEP */
+STATIC int lt_maybe_padrange_setup(pTHX_ OP *o, const OP *start) {
+#define lt_maybe_padrange_setup(O, S) lt_maybe_padrange_setup(aTHX_ (O), (S))
+ PADOFFSET i, count;
+ const OP *p;
-LT_PEEP_REC_PROTO;
-LT_PEEP_REC_PROTO {
-#if !LT_HAS_RPEEP
-# define lt_peep_rec(O) lt_peep_rec(aTHX_ (O), seen)
-#else /* !LT_HAS_RPEEP */
-# define lt_peep_rec(O) lt_peep_rec(aTHX_ (O))
-#endif /* LT_HAS_RPEEP */
+ count = o->op_private & OPpPADRANGE_COUNTMASK;
+
+ for (i = 0, p = start; i < count && p; ++i, p = p->op_sibling) {
+ switch (p->op_type) {
+ case OP_PADSV:
+#if LT_HAS_PERL(5, 11, 1)
+ case OP_PADAV:
+ case OP_PADHV:
+#endif
+ /* In a padrange sequence, either all lexicals are typed, or none are.
+ * Thus we can stop at the first padsv op. However, note that these
+ * lexicals can need to call different methods in different packages. */
+ LT_LOCK(<_op_map_mutex);
+ if (ptable_fetch(lt_op_padxv_map, p)) {
+ LT_UNLOCK(<_op_map_mutex);
+ lt_padrange_map_store(o, start, o->op_ppaddr);
+ o->op_ppaddr = lt_pp_padrange;
+ } else {
+ LT_UNLOCK(<_op_map_mutex);
+ }
+ return 1;
+ break;
+ default:
+ break;
+ }
+ }
+
+ return 0;
+}
-#if !LT_HAS_RPEEP
- if (ptable_fetch(seen, o))
- return;
#endif
- for (; o; o = o->op_next) {
- lt_op_info *oi = NULL;
+STATIC peep_t lt_old_peep = 0; /* This is actually the rpeep past 5.13.5 */
-#if !LT_HAS_RPEEP
+STATIC void lt_peep_rec(pTHX_ OP *o, ptable *seen) {
+#define lt_peep_rec(O) lt_peep_rec(aTHX_ (O), seen)
+ for (; o; o = o->op_next) {
+ if (ptable_fetch(seen, o))
+ break;
ptable_seen_store(seen, o, o);
-#endif
+
switch (o->op_type) {
case OP_PADSV:
- if (o->op_ppaddr != lt_pp_padsv && o->op_private & OPpLVAL_INTRO) {
+#if LT_HAS_PERL(5, 11, 1)
+ case OP_PADAV:
+ case OP_PADHV:
+#endif
+ if (o->op_ppaddr != lt_pp_padxv && o->op_private & OPpLVAL_INTRO) {
+ lt_op_padxv_info *oi;
LT_LOCK(<_op_map_mutex);
- oi = ptable_fetch(lt_op_map, o);
+ oi = ptable_fetch(lt_op_padxv_map, o);
if (oi) {
- oi->old_pp_padsv = o->op_ppaddr;
- o->op_ppaddr = lt_pp_padsv;
+ oi->old_pp = o->op_ppaddr;
+ o->op_ppaddr = lt_pp_padxv;
}
LT_UNLOCK(<_op_map_mutex);
}
break;
+#if LT_HAS_PERL(5, 17, 6)
+ case OP_PADRANGE:
+ /* We deal with special padrange ops later, in the aassign op they belong
+ * to. */
+ if (o->op_ppaddr != lt_pp_padrange && o->op_private & OPpLVAL_INTRO
+ && !(o->op_flags & OPf_SPECIAL)) {
+ /* A padrange op is guaranteed to have previously been a pushmark.
+ * Moreover, for non-special padrange ops (i.e. that aren't for
+ * my (...) = @_), the original padxv ops are its siblings. */
+ lt_maybe_padrange_setup(o, o->op_sibling);
+ }
+ break;
+ case OP_AASSIGN: {
+ OP *op;
+ if (cBINOPo->op_first && cBINOPo->op_first->op_flags & OPf_KIDS
+ && (op = cUNOPx(cBINOPo->op_first)->op_first)
+ && op->op_type == OP_PADRANGE
+ && op->op_ppaddr != lt_pp_padrange
+ && op->op_private & OPpLVAL_INTRO
+ && op->op_flags & OPf_SPECIAL) {
+ const OP *start = cUNOPx(cBINOPo->op_last)->op_first;
+ if (start->op_type == OP_PUSHMARK)
+ start = start->op_sibling;
+ lt_maybe_padrange_setup(op, start);
+ }
+ break;
+ }
+#endif
#if !LT_HAS_RPEEP
case OP_MAPWHILE:
case OP_GREPWHILE:
}
STATIC void lt_peep(pTHX_ OP *o) {
-#if !LT_HAS_RPEEP
dMY_CXT;
ptable *seen = MY_CXT.seen;
- ptable_seen_clear(seen);
-#endif /* !LT_HAS_RPEEP */
-
lt_old_peep(aTHX_ o);
+
+ ptable_seen_clear(seen);
lt_peep_rec(o);
+ ptable_seen_clear(seen);
}
/* --- Interpreter setup/teardown ------------------------------------------ */
#endif
{
+ unsigned int i;
dMY_CXT;
#if LT_THREADSAFE
ptable_hints_free(MY_CXT.tbl);
#endif
-#if !LT_HAS_RPEEP
ptable_seen_free(MY_CXT.seen);
-#endif
- SvREFCNT_dec(MY_CXT.default_meth);
+ for (i = 0; i < LT_TYPE_COUNT; ++i)
+ SvREFCNT_dec(MY_CXT.default_meth[i]);
}
- PL_check[OP_PADANY] = MEMBER_TO_FPTR(lt_old_ck_padany);
- lt_old_ck_padany = 0;
- PL_check[OP_PADSV] = MEMBER_TO_FPTR(lt_old_ck_padsv);
- lt_old_ck_padsv = 0;
+ lt_ck_restore(OP_PADANY, <_old_ck_padany);
+ lt_ck_restore(OP_PADSV, <_old_ck_padsv);
+#if LT_HAS_PERL(5, 11, 1)
+ lt_ck_restore(OP_PADAV, <_old_ck_padav);
+ lt_ck_restore(OP_PADHV, <_old_ck_padhv);
+#endif
#if LT_HAS_RPEEP
PL_rpeepp = lt_old_peep;
{
MY_CXT_INIT;
#if LT_THREADSAFE
- MY_CXT.tbl = ptable_new();
- MY_CXT.owner = aTHX;
+ MY_CXT.tbl = ptable_new();
+ MY_CXT.owner = aTHX;
#endif
-#if !LT_HAS_RPEEP
- MY_CXT.seen = ptable_new();
+ MY_CXT.seen = ptable_new();
+ MY_CXT.default_meth[LT_TYPE_SCALAR] = newSVpvs("TYPEDSCALAR");
+ SvREADONLY_on(MY_CXT.default_meth[LT_TYPE_SCALAR]);
+#if LT_HAS_PERL(5, 11, 1)
+ MY_CXT.default_meth[LT_TYPE_ARRAY] = newSVpvs("TYPEDARRAY");
+ SvREADONLY_on(MY_CXT.default_meth[LT_TYPE_ARRAY]);
+ MY_CXT.default_meth[LT_TYPE_HASH] = newSVpvs("TYPEDHASH");
+ SvREADONLY_on(MY_CXT.default_meth[LT_TYPE_HASH]);
#endif
- MY_CXT.default_meth = newSVpvn("TYPEDSCALAR", 11);
- SvREADONLY_on(MY_CXT.default_meth);
}
- lt_old_ck_padany = PL_check[OP_PADANY];
- PL_check[OP_PADANY] = MEMBER_TO_FPTR(lt_ck_padany);
- lt_old_ck_padsv = PL_check[OP_PADSV];
- PL_check[OP_PADSV] = MEMBER_TO_FPTR(lt_ck_padsv);
+ lt_ck_replace(OP_PADANY, lt_ck_padany, <_old_ck_padany);
+ lt_ck_replace(OP_PADSV, lt_ck_padsv, <_old_ck_padsv);
+#if LT_HAS_PERL(5, 11, 1)
+ lt_ck_replace(OP_PADAV, lt_ck_padav, <_old_ck_padav);
+ lt_ck_replace(OP_PADHV, lt_ck_padhv, <_old_ck_padhv);
+#endif
#if LT_HAS_RPEEP
lt_old_peep = PL_rpeepp;
if (!lt_booted++) {
HV *stash;
- lt_op_map = ptable_new();
+ lt_op_padxv_map = ptable_new();
+#if LT_HAS_PERL(5, 17, 6)
+ lt_op_padrange_map = ptable_new();
+#endif
#ifdef USE_ITHREADS
MUTEX_INIT(<_op_map_mutex);
#endif
stash = gv_stashpvn(__PACKAGE__, __PACKAGE_LEN__, 1);
newCONSTSUB(stash, "LT_THREADSAFE", newSVuv(LT_THREADSAFE));
+ newCONSTSUB(stash, "LT_FORKSAFE", newSVuv(LT_FORKSAFE));
}
lt_setup();
CLONE(...)
PROTOTYPE: DISABLE
PREINIT:
- ptable *t;
-#if !LT_HAS_RPEEP
- ptable *s;
-#endif
- SV *cloned_default_meth;
+ ptable *t;
+ ptable *s;
+ SV *cloned_default_meth[LT_TYPE_COUNT];
+ unsigned int i;
PPCODE:
{
{
t = ptable_new();
lt_ptable_clone_ud_init(ud, t, MY_CXT.owner);
ptable_walk(MY_CXT.tbl, lt_ptable_clone, &ud);
- cloned_default_meth = lt_dup_inc(MY_CXT.default_meth, &ud);
+ for (i = 0; i < LT_TYPE_COUNT; ++i)
+ cloned_default_meth[i] = lt_dup_inc(MY_CXT.default_meth[i], &ud);
lt_ptable_clone_ud_deinit(ud);
}
-#if !LT_HAS_RPEEP
s = ptable_new();
-#endif
}
{
MY_CXT_CLONE;
- MY_CXT.tbl = t;
- MY_CXT.owner = aTHX;
-#if !LT_HAS_RPEEP
- MY_CXT.seen = s;
-#endif
- MY_CXT.default_meth = cloned_default_meth;
+ MY_CXT.tbl = t;
+ MY_CXT.owner = aTHX;
+ MY_CXT.seen = s;
+ for (i = 0; i < LT_TYPE_COUNT; ++i)
+ MY_CXT.default_meth[i] = cloned_default_meth[i];
}
reap(3, lt_thread_cleanup, NULL);
XSRETURN(0);
projects / perl / modules / Lexical-Types.git / blobdiff