Fix the thread destructor trick for 5.13.1

This fixes RT #57699.

diff --git a/MANIFEST b/MANIFEST
index 672c7c309fed6862a0a932694e53a5da5170b57b..69f13ed4f152b3e781678823b26dc002fea599a2 100644 (file)
--- a/MANIFEST
+++ b/MANIFEST
@@ -6,6 +6,7 @@ README
 indirect.xs
 lib/indirect.pm
 ptable.h
 indirect.xs
 lib/indirect.pm
 ptable.h

+reap.h

 samples/indirect.pl
 t/00-load.t
 t/10-args.t
 samples/indirect.pl
 t/00-load.t
 t/10-args.t

diff --git a/indirect.xs b/indirect.xs
index ee45f235dd4e7d3dfd3916bbd53254b047d85105..578c15447e5a3dfe1f815eeaed161731a67312f7 100644 (file)
--- a/indirect.xs
+++ b/indirect.xs
@@ -61,20 +61,6 @@
 
 #define I_HAS_PERL(R, V, S) (PERL_REVISION > (R) || (PERL_REVISION == (R) && (PERL_VERSION > (V) || (PERL_VERSION == (V) && (PERL_SUBVERSION >= (S))))))
 
 
 #define I_HAS_PERL(R, V, S) (PERL_REVISION > (R) || (PERL_REVISION == (R) && (PERL_VERSION > (V) || (PERL_VERSION == (V) && (PERL_SUBVERSION >= (S))))))
 

-#undef ENTERn
-#if defined(ENTER_with_name) && !I_HAS_PERL(5, 11, 4)
-# define ENTERn(N) ENTER_with_name(N)
-#else
-# define ENTERn(N) ENTER
-#endif
-
-#undef LEAVEn
-#if defined(LEAVE_with_name) && !I_HAS_PERL(5, 11, 4)
-# define LEAVEn(N) LEAVE_with_name(N)
-#else
-# define LEAVEn(N) LEAVE
-#endif
-

 #if I_HAS_PERL(5, 10, 0) || defined(PL_parser)
 # ifndef PL_lex_inwhat
 #  define PL_lex_inwhat PL_parser->lex_inwhat
 #if I_HAS_PERL(5, 10, 0) || defined(PL_parser)
 # ifndef PL_lex_inwhat
 #  define PL_lex_inwhat PL_parser->lex_inwhat


@@ -288,22 +274,13 @@ STATIC void indirect_ptable_clone(pTHX_ ptable_ent *ent, void *ud_) {
  ptable_hints_store(ud->tbl, ent->key, h2);
 }
 
  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) {
 
 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 */
 }
 
 #endif /* I_THREADSAFE */


@@ -905,7 +882,6 @@ CLONE(...)
 PROTOTYPE: DISABLE
 PREINIT:
  ptable *t;
 PROTOTYPE: DISABLE
 PREINIT:
  ptable *t;

- int    *level;

 PPCODE:
  {
   my_cxt_t ud;
 PPCODE:
  {
   my_cxt_t ud;


@@ -921,13 +897,7 @@ PPCODE:
   MY_CXT.tbl     = t;
   MY_CXT.owner   = aTHX;
  }
   MY_CXT.tbl     = t;
   MY_CXT.owner   = aTHX;
  }

- {
-  level = PerlMemShared_malloc(sizeof *level);
-  *level = 1;
-  LEAVEn("sub");
-  SAVEDESTRUCTOR_X(indirect_thread_cleanup, level);
-  ENTERn("sub");
- }
+ reap(3, indirect_thread_cleanup, NULL);

  XSRETURN(0);
 
 #endif
  XSRETURN(0);
 
 #endif

diff --git a/reap.h b/reap.h
new file mode 100644 (file)
index 0000000..8db64ed
--- /dev/null
+++ b/reap.h
@@ -0,0 +1,81 @@
+/* This file is part of the indirect Perl module.
+ * See http://search.cpan.org/dist/indirect/ */
+
+/* This header provides a specialized version of Scope::Upper::reap that can be
+ * called directly from XS.
+ * See http://search.cpan.org/dist/Scope-Upper/ for details. */
+
+#ifndef REAP_H
+#define REAP_H 1
+
+#define REAP_DESTRUCTOR_SIZE 3
+
+typedef struct {
+ I32    depth;
+ I32   *origin;
+ void (*cb)(pTHX_ void *);
+ void  *ud;
+ char  *dummy;
+} reap_ud;
+
+STATIC void reap_pop(pTHX_ void *);
+
+STATIC void reap_pop(pTHX_ void *ud_) {
+ reap_ud *ud = ud_;
+ I32 depth, *origin, mark, base;
+
+ depth  = ud->depth;
+ origin = ud->origin;
+ mark   = origin[depth];
+ base   = origin[depth - 1];
+
+ if (base < mark) {
+  PL_savestack_ix = mark;
+  leave_scope(base);
+ }
+ PL_savestack_ix = base;
+
+ if ((ud->depth = --depth) > 0) {
+  SAVEDESTRUCTOR_X(reap_pop, ud);
+ } else {
+  void (*cb)(pTHX_ void *) = ud->cb;
+  void  *cb_ud             = ud->ud;
+
+  PerlMemShared_free(ud->origin);
+  PerlMemShared_free(ud);
+
+  SAVEDESTRUCTOR_X(cb, cb_ud);
+ }
+}
+
+STATIC void reap(pTHX_ I32 depth, void (*cb)(pTHX_ void *), void *cb_ud) {
+#define reap(D, CB, UD) reap(aTHX_ (D), (CB), (UD))
+ reap_ud *ud;
+ I32 i;
+
+ if (depth > PL_scopestack_ix)
+  depth = PL_scopestack_ix;
+
+ ud         = PerlMemShared_malloc(sizeof *ud);
+ ud->depth  = depth;
+ ud->origin = PerlMemShared_malloc((depth + 1) * sizeof *ud->origin);
+ ud->cb     = cb;
+ ud->ud     = cb_ud;
+ ud->dummy  = NULL;
+
+ for (i = depth; i >= 1; --i) {
+  I32 j = PL_scopestack_ix - i;
+  ud->origin[depth - i] = PL_scopestack[j];
+  PL_scopestack[j] += REAP_DESTRUCTOR_SIZE;
+ }
+ ud->origin[depth] = PL_savestack_ix;
+
+ while (PL_savestack_ix + REAP_DESTRUCTOR_SIZE
+                                       <= PL_scopestack[PL_scopestack_ix - 1]) {
+  save_pptr(&ud->dummy);
+ }
+
+ SAVEDESTRUCTOR_X(reap_pop, ud);
+}
+
+#endif /* REAP_H */