X-Git-Url: http://git.vpit.fr/?p=perl%2Fmodules%2Findirect.git;a=blobdiff_plain;f=indirect.xs;h=4ce10e59ce0dc8fae193abf93f0f81aa471bc3ba;hp=00622a5c10f5b2d5b3488ed2ca40f8b600dfdffe;hb=ec48b957f1ab41d61e97f77b104a5b41f616af32;hpb=c07766a234204d78a80b6d75534e03ae3465b6f3

diff --git a/indirect.xs b/indirect.xs
index 00622a5..4ce10e5 100644
--- a/indirect.xs
+++ b/indirect.xs
@@ -95,6 +95,11 @@
 
 /* ... Thread safety and multiplicity ...................................... */
 
+/* Safe unless stated otherwise in Makefile.PL */
+#ifndef I_FORKSAFE
+# define I_FORKSAFE 1
+#endif
+
 #ifndef I_MULTIPLICITY
 # if defined(MULTIPLICITY) || defined(PERL_IMPLICIT_CONTEXT)
 #  define I_MULTIPLICITY 1
@@ -133,21 +138,39 @@
 
 /* ... Thread-safe hints ................................................... */
 
-/* If any of those are true, we need to store the hint in a global table. */
-
-#if I_THREADSAFE || I_WORKAROUND_REQUIRE_PROPAGATION
+#if I_WORKAROUND_REQUIRE_PROPAGATION
 
 typedef struct {
- SV  *code;
-#if I_WORKAROUND_REQUIRE_PROPAGATION
- I32  requires;
-#endif
+ SV *code;
+ IV  require_tag;
 } indirect_hint_t;
 
-#define PTABLE_NAME ptable_hints
+#define I_HINT_STRUCT 1
+
+#define I_HINT_CODE(H) ((H)->code)
+
+#define I_HINT_FREE(H) {   \
+ indirect_hint_t *h = (H); \
+ SvREFCNT_dec(h->code);    \
+ PerlMemShared_free(h);    \
+}
+
+#else  /*  I_WORKAROUND_REQUIRE_PROPAGATION */
 
-#define PTABLE_VAL_FREE(V) \
-   { indirect_hint_t *h = (V); SvREFCNT_dec(h->code); PerlMemShared_free(h); }
+typedef SV indirect_hint_t;
+
+#define I_HINT_STRUCT 0
+
+#define I_HINT_CODE(H) (H)
+
+#define I_HINT_FREE(H) SvREFCNT_dec(H);
+
+#endif /* !I_WORKAROUND_REQUIRE_PROPAGATION */
+
+#if I_THREADSAFE
+
+#define PTABLE_NAME        ptable_hints
+#define PTABLE_VAL_FREE(V) I_HINT_FREE(V)
 
 #define pPTBL  pTHX
 #define pPTBL_ pTHX_
@@ -159,7 +182,7 @@ typedef struct {
 #define ptable_hints_store(T, K, V) ptable_hints_store(aTHX_ (T), (K), (V))
 #define ptable_hints_free(T)        ptable_hints_free(aTHX_ (T))
 
-#endif /* I_THREADSAFE || I_WORKAROUND_REQUIRE_PROPAGATION */
+#endif /* I_THREADSAFE */
 
 /* Define the op->str ptable here because we need to be able to clean it during
  * thread cleanup. */
@@ -188,14 +211,12 @@ typedef struct {
 #define MY_CXT_KEY __PACKAGE__ "::_guts" XS_VERSION
 
 typedef struct {
-#if I_THREADSAFE || I_WORKAROUND_REQUIRE_PROPAGATION
+#if I_THREADSAFE
  ptable     *tbl; /* It really is a ptable_hints */
+ tTHX        owner;
 #endif
  ptable     *map;
  const char *linestr;
-#if I_THREADSAFE
- tTHX        owner;
-#endif
 } my_cxt_t;
 
 START_MY_CXT
@@ -228,38 +249,87 @@ STATIC SV *indirect_clone(pTHX_ SV *sv, tTHX owner) {
 STATIC void indirect_ptable_clone(pTHX_ ptable_ent *ent, void *ud_) {
  my_cxt_t        *ud = ud_;
  indirect_hint_t *h1 = ent->val;
- indirect_hint_t *h2 = PerlMemShared_malloc(sizeof *h2);
+ indirect_hint_t *h2;
 
- *h2 = *h1;
+ if (ud->owner == aTHX)
+  return;
 
- if (ud->owner != aTHX)
-  h2->code = indirect_clone(h1->code, ud->owner);
+#if I_HINT_STRUCT
 
- ptable_hints_store(ud->tbl, ent->key, h2);
+ h2       = PerlMemShared_malloc(sizeof *h2);
+ h2->code = indirect_clone(h1->code, ud->owner);
  SvREFCNT_inc(h2->code);
+#if I_WORKAROUND_REQUIRE_PROPAGATION
+ h2->require_tag = PTR2IV(indirect_clone(INT2PTR(SV *, h1->require_tag),
+                                         ud->owner));
+#endif
+
+#else  /*  I_HINT_STRUCT */
+
+ h2 = indirect_clone(h1, ud->owner);
+ SvREFCNT_inc(h2);
+
+#endif /* !I_HINT_STRUCT */
+
+ ptable_hints_store(ud->tbl, ent->key, h2);
 }
 
-STATIC void indirect_thread_cleanup(pTHX_ void *);
+#include "reap.h"
 
 STATIC void indirect_thread_cleanup(pTHX_ void *ud) {
- int *level = ud;
+ dMY_CXT;
 
- if (*level) {
-  *level = 0;
-  LEAVE;
-  SAVEDESTRUCTOR_X(indirect_thread_cleanup, level);
-  ENTER;
- } else {
-  dMY_CXT;
-  PerlMemShared_free(level);
-  ptable_free(MY_CXT.map);
-  ptable_hints_free(MY_CXT.tbl);
- }
+ ptable_free(MY_CXT.map);
+ ptable_hints_free(MY_CXT.tbl);
 }
 
 #endif /* I_THREADSAFE */
 
-#if I_THREADSAFE || I_WORKAROUND_REQUIRE_PROPAGATION
+#if I_WORKAROUND_REQUIRE_PROPAGATION
+STATIC IV indirect_require_tag(pTHX) {
+#define indirect_require_tag() indirect_require_tag(aTHX)
+ const CV *cv, *outside;
+
+ cv = PL_compcv;
+
+ if (!cv) {
+  /* If for some reason the pragma is operational at run-time, try to discover
+   * the current cv in use. */
+  const PERL_SI *si;
+
+  for (si = PL_curstackinfo; si; si = si->si_prev) {
+   I32 cxix;
+
+   for (cxix = si->si_cxix; cxix >= 0; --cxix) {
+    const PERL_CONTEXT *cx = si->si_cxstack + cxix;
+
+    switch (CxTYPE(cx)) {
+     case CXt_SUB:
+     case CXt_FORMAT:
+      /* The propagation workaround is only needed up to 5.10.0 and at that
+       * time format and sub contexts were still identical. And even later the
+       * cv members offsets should have been kept the same. */
+      cv = cx->blk_sub.cv;
+      goto get_enclosing_cv;
+     case CXt_EVAL:
+      cv = cx->blk_eval.cv;
+      goto get_enclosing_cv;
+     default:
+      break;
+    }
+   }
+  }
+
+  cv = PL_main_cv;
+ }
+
+get_enclosing_cv:
+ for (outside = CvOUTSIDE(cv); outside; outside = CvOUTSIDE(cv))
+  cv = outside;
+
+ return PTR2IV(cv);
+}
+#endif /* I_WORKAROUND_REQUIRE_PROPAGATION */
 
 STATIC SV *indirect_tag(pTHX_ SV *value) {
 #define indirect_tag(V) indirect_tag(aTHX_ (V))
@@ -271,39 +341,26 @@ STATIC SV *indirect_tag(pTHX_ SV *value) {
   value = SvRV(value);
   if (SvTYPE(value) >= SVt_PVCV) {
    code = value;
-   if (CvANON(code) && !CvCLONED(code))
-    CvCLONE_on(code);
    SvREFCNT_inc_simple_NN(code);
   }
  }
 
+#if I_HINT_STRUCT
  h = PerlMemShared_malloc(sizeof *h);
- h->code = code;
-
-#if I_WORKAROUND_REQUIRE_PROPAGATION
- {
-  const PERL_SI *si;
-  I32            requires = 0;
-
-  for (si = PL_curstackinfo; si; si = si->si_prev) {
-   I32 cxix;
-
-   for (cxix = si->si_cxix; cxix >= 0; --cxix) {
-    const PERL_CONTEXT *cx = si->si_cxstack + cxix;
-
-    if (CxTYPE(cx) == CXt_EVAL && cx->blk_eval.old_op_type == OP_REQUIRE)
-     ++requires;
-   }
-  }
-
-  h->requires = requires;
- }
-#endif
+ h->code        = code;
+# if I_WORKAROUND_REQUIRE_PROPAGATION
+ h->require_tag = indirect_require_tag();
+# endif /* I_WORKAROUND_REQUIRE_PROPAGATION */
+#else  /*  I_HINT_STRUCT */
+ h = code;
+#endif /* !I_HINT_STRUCT */
 
+#if I_THREADSAFE
  /* We only need for the key to be an unique tag for looking up the value later.
   * Allocated memory provides convenient unique identifiers, so that's why we
   * use the hint as the key itself. */
  ptable_hints_store(MY_CXT.tbl, h, h);
+#endif /* I_THREADSAFE */
 
  return newSViv(PTR2IV(h));
 }
@@ -316,49 +373,19 @@ STATIC SV *indirect_detag(pTHX_ const SV *hint) {
  if (!(hint && SvIOK(hint)))
   return NULL;
 
- h = ptable_fetch(MY_CXT.tbl, INT2PTR(void *, SvIVX(hint)));
+ h = INT2PTR(indirect_hint_t *, SvIVX(hint));
+#if I_THREADSAFE
+ h = ptable_fetch(MY_CXT.tbl, h);
+#endif /* I_THREADSAFE */
 
 #if I_WORKAROUND_REQUIRE_PROPAGATION
- {
-  const PERL_SI *si;
-  I32            requires = 0;
-
-  for (si = PL_curstackinfo; si; si = si->si_prev) {
-   I32 cxix;
-
-   for (cxix = si->si_cxix; cxix >= 0; --cxix) {
-    const PERL_CONTEXT *cx = si->si_cxstack + cxix;
-
-    if (CxTYPE(cx) == CXt_EVAL && cx->blk_eval.old_op_type == OP_REQUIRE
-                               && ++requires > h->requires)
-     return NULL;
-   }
-  }
- }
-#endif
-
- return h->code;
-}
-
-#else
-
-STATIC SV *indirect_tag(pTHX_ SV *value) {
-#define indirect_tag(V) indirect_tag(aTHX_ (V))
- UV tag = 0;
-
- if (SvROK(value)) {
-  value = SvRV(value);
-  SvREFCNT_inc_simple_NN(value);
-  tag = PTR2IV(value);
- }
+ if (indirect_require_tag() != h->require_tag)
+  return NULL;
+#endif /* I_WORKAROUND_REQUIRE_PROPAGATION */
 
- return newSViv(tag);
+ return I_HINT_CODE(h);
 }
 
-#define indirect_detag(H) (((H) && SvIOK(H)) ? INT2PTR(SV *, SvIVX(H)) : NULL)
-
-#endif /* I_THREADSAFE || I_WORKAROUND_REQUIRE_PROPAGATION */
-
 STATIC U32 indirect_hash = 0;
 
 STATIC SV *indirect_hint(pTHX) {
@@ -435,7 +462,6 @@ STATIC void indirect_map_store(pTHX_ const OP *o, const char *src, SV *sv, line_
 
 STATIC const indirect_op_info_t *indirect_map_fetch(pTHX_ const OP *o) {
 #define indirect_map_fetch(O) indirect_map_fetch(aTHX_ (O))
- const indirect_op_info_t *val;
  dMY_CXT;
 
  if (MY_CXT.linestr != SvPVX_const(PL_linestr))
@@ -623,28 +649,35 @@ STATIC OP *(*indirect_old_ck_method)(pTHX_ OP *) = 0;
 STATIC OP *indirect_ck_method(pTHX_ OP *o) {
  if (indirect_hint()) {
   OP *op = cUNOPo->op_first;
-  const indirect_op_info_t *oi = indirect_map_fetch(op);
-  const char *s = NULL;
-  line_t line;
-  SV *sv;
 
-  if (oi && (s = oi->pos)) {
-   sv   = sv_2mortal(newSVpvn(oi->buf, oi->len));
-   line = oi->line; /* Keep the old line so that we really point to the first */
-  } else {
-   sv = cSVOPx_sv(op);
-   if (!SvPOK(sv) || (SvTYPE(sv) < SVt_PV))
-    goto done;
-   sv   = sv_mortalcopy(sv);
-   s    = indirect_find(sv, PL_oldbufptr);
-   line = CopLINE(&PL_compiling);
-  }
+  /* Indirect method call is only possible when the method is a bareword, so
+   * don't trip up on $obj->$meth. */
+  if (op && op->op_type == OP_CONST) {
+   const indirect_op_info_t *oi = indirect_map_fetch(op);
+   const char *s = NULL;
+   line_t line;
+   SV *sv;
+
+   if (oi && (s = oi->pos)) {
+    sv   = sv_2mortal(newSVpvn(oi->buf, oi->len));
+    /* Keep the old line so that we really point to the first line of the
+     * expression. */
+    line = oi->line;
+   } else {
+    sv = cSVOPx_sv(op);
+    if (!SvPOK(sv) || (SvTYPE(sv) < SVt_PV))
+     goto done;
+    sv   = sv_mortalcopy(sv);
+    s    = indirect_find(sv, PL_oldbufptr);
+    line = CopLINE(&PL_compiling);
+   }
 
-  o = CALL_FPTR(indirect_old_ck_method)(aTHX_ o);
-  /* o may now be a method_named */
+   o = CALL_FPTR(indirect_old_ck_method)(aTHX_ o);
+   /* o may now be a method_named */
 
-  indirect_map_store(o, s, sv, line);
-  return o;
+   indirect_map_store(o, s, sv, line);
+   return o;
+  }
  }
 
 done:
@@ -751,6 +784,83 @@ done:
 
 STATIC U32 indirect_initialized = 0;
 
+STATIC void indirect_teardown(pTHX_ void *root) {
+ dMY_CXT;
+
+ if (!indirect_initialized)
+  return;
+
+#if I_MULTIPLICITY
+ if (aTHX != root)
+  return;
+#endif
+
+ ptable_free(MY_CXT.map);
+#if I_THREADSAFE
+ ptable_hints_free(MY_CXT.tbl);
+#endif
+
+ PL_check[OP_CONST]       = MEMBER_TO_FPTR(indirect_old_ck_const);
+ indirect_old_ck_const    = 0;
+ PL_check[OP_RV2SV]       = MEMBER_TO_FPTR(indirect_old_ck_rv2sv);
+ indirect_old_ck_rv2sv    = 0;
+ PL_check[OP_PADANY]      = MEMBER_TO_FPTR(indirect_old_ck_padany);
+ indirect_old_ck_padany   = 0;
+ PL_check[OP_SCOPE]       = MEMBER_TO_FPTR(indirect_old_ck_scope);
+ indirect_old_ck_scope    = 0;
+ PL_check[OP_LINESEQ]     = MEMBER_TO_FPTR(indirect_old_ck_lineseq);
+ indirect_old_ck_lineseq  = 0;
+
+ PL_check[OP_METHOD]      = MEMBER_TO_FPTR(indirect_old_ck_method);
+ indirect_old_ck_method   = 0;
+ PL_check[OP_ENTERSUB]    = MEMBER_TO_FPTR(indirect_old_ck_entersub);
+ indirect_old_ck_entersub = 0;
+
+ indirect_initialized = 0;
+}
+
+STATIC void indirect_setup(pTHX) {
+#define indirect_setup() indirect_setup(aTHX)
+ if (indirect_initialized)
+  return;
+
+ {
+  MY_CXT_INIT;
+#if I_THREADSAFE
+  MY_CXT.tbl     = ptable_new();
+  MY_CXT.owner   = aTHX;
+#endif
+  MY_CXT.map     = ptable_new();
+  MY_CXT.linestr = NULL;
+ }
+
+ indirect_old_ck_const    = PL_check[OP_CONST];
+ PL_check[OP_CONST]       = MEMBER_TO_FPTR(indirect_ck_const);
+ indirect_old_ck_rv2sv    = PL_check[OP_RV2SV];
+ PL_check[OP_RV2SV]       = MEMBER_TO_FPTR(indirect_ck_rv2sv);
+ indirect_old_ck_padany   = PL_check[OP_PADANY];
+ PL_check[OP_PADANY]      = MEMBER_TO_FPTR(indirect_ck_padany);
+ indirect_old_ck_scope    = PL_check[OP_SCOPE];
+ PL_check[OP_SCOPE]       = MEMBER_TO_FPTR(indirect_ck_scope);
+ indirect_old_ck_lineseq  = PL_check[OP_LINESEQ];
+ PL_check[OP_LINESEQ]     = MEMBER_TO_FPTR(indirect_ck_scope);
+
+ indirect_old_ck_method   = PL_check[OP_METHOD];
+ PL_check[OP_METHOD]      = MEMBER_TO_FPTR(indirect_ck_method);
+ indirect_old_ck_entersub = PL_check[OP_ENTERSUB];
+ PL_check[OP_ENTERSUB]    = MEMBER_TO_FPTR(indirect_ck_entersub);
+
+#if I_MULTIPLICITY
+ call_atexit(indirect_teardown, aTHX);
+#else
+ call_atexit(indirect_teardown, NULL);
+#endif
+
+ indirect_initialized = 1;
+}
+
+STATIC U32 indirect_booted = 0;
+
 /* --- XS ------------------------------------------------------------------ */
 
 MODULE = indirect      PACKAGE = indirect
@@ -759,40 +869,17 @@ PROTOTYPES: ENABLE
 
 BOOT:
 {
- if (!indirect_initialized++) {
+ if (!indirect_booted++) {
   HV *stash;
 
-  MY_CXT_INIT;
-  MY_CXT.map     = ptable_new();
-  MY_CXT.linestr = NULL;
-#if I_THREADSAFE || I_WORKAROUND_REQUIRE_PROPAGATION
-  MY_CXT.tbl     = ptable_new();
-#endif
-#if I_THREADSAFE
-  MY_CXT.owner   = aTHX;
-#endif
-
   PERL_HASH(indirect_hash, __PACKAGE__, __PACKAGE_LEN__);
 
-  indirect_old_ck_const    = PL_check[OP_CONST];
-  PL_check[OP_CONST]       = MEMBER_TO_FPTR(indirect_ck_const);
-  indirect_old_ck_rv2sv    = PL_check[OP_RV2SV];
-  PL_check[OP_RV2SV]       = MEMBER_TO_FPTR(indirect_ck_rv2sv);
-  indirect_old_ck_padany   = PL_check[OP_PADANY];
-  PL_check[OP_PADANY]      = MEMBER_TO_FPTR(indirect_ck_padany);
-  indirect_old_ck_scope    = PL_check[OP_SCOPE];
-  PL_check[OP_SCOPE]       = MEMBER_TO_FPTR(indirect_ck_scope);
-  indirect_old_ck_lineseq  = PL_check[OP_LINESEQ];
-  PL_check[OP_LINESEQ]     = MEMBER_TO_FPTR(indirect_ck_scope);
-
-  indirect_old_ck_method   = PL_check[OP_METHOD];
-  PL_check[OP_METHOD]      = MEMBER_TO_FPTR(indirect_ck_method);
-  indirect_old_ck_entersub = PL_check[OP_ENTERSUB];
-  PL_check[OP_ENTERSUB]    = MEMBER_TO_FPTR(indirect_ck_entersub);
-
   stash = gv_stashpvn(__PACKAGE__, __PACKAGE_LEN__, 1);
   newCONSTSUB(stash, "I_THREADSAFE", newSVuv(I_THREADSAFE));
+  newCONSTSUB(stash, "I_FORKSAFE",   newSVuv(I_FORKSAFE));
  }
+
+ indirect_setup();
 }
 
 #if I_THREADSAFE
@@ -802,8 +889,7 @@ CLONE(...)
 PROTOTYPE: DISABLE
 PREINIT:
  ptable *t;
- int    *level;
-CODE:
+PPCODE:
  {
   my_cxt_t ud;
   dMY_CXT;
@@ -818,13 +904,8 @@ CODE:
   MY_CXT.tbl     = t;
   MY_CXT.owner   = aTHX;
  }
- {
-  level = PerlMemShared_malloc(sizeof *level);
-  *level = 1;
-  LEAVE;
-  SAVEDESTRUCTOR_X(indirect_thread_cleanup, level);
-  ENTER;
- }
+ reap(3, indirect_thread_cleanup, NULL);
+ XSRETURN(0);
 
 #endif