The Big Boilerplate Factorization
authorVincent Pit <perl@profvince.com>
Wed, 4 Nov 2015 13:35:33 +0000 (11:35 -0200)
committerVincent Pit <perl@profvince.com>
Thu, 5 Nov 2015 12:48:21 +0000 (10:48 -0200)
MANIFEST
Makefile.PL
indirect.xs
ptable.h [deleted file]
xsh/caps.h [new file with mode: 0644]
xsh/debug.h [new file with mode: 0644]
xsh/hints.h [new file with mode: 0644]
xsh/ops.h [new file with mode: 0644]
xsh/ptable.h [new file with mode: 0644]
xsh/threads.h [new file with mode: 0644]
xsh/util.h [new file with mode: 0644]

index 2b6fc4a..0390be2 100644 (file)
--- a/MANIFEST
+++ b/MANIFEST
@@ -6,7 +6,6 @@ Makefile.PL
 README
 indirect.xs
 lib/indirect.pm
-ptable.h
 samples/indirect.pl
 t/00-load.t
 t/09-load-threads.t
@@ -53,3 +52,10 @@ t/lib/indirect/TestRequired5/c0.pm
 t/lib/indirect/TestRequired5/d0.pm
 t/lib/indirect/TestRequired6.pm
 t/lib/indirect/TestRequiredGlobal.pm
+xsh/caps.h
+xsh/debug.h
+xsh/hints.h
+xsh/ops.h
+xsh/ptable.h
+xsh/threads.h
+xsh/util.h
index 8dd474d..430cc53 100644 (file)
@@ -39,12 +39,12 @@ print $is_gcc_34 ? "yes\n" : "no\n";
 
 # Threads, Windows and 5.8.x don't seem to be best friends
 if ($^O eq 'MSWin32' and "$]" < 5.009) {
- push @DEFINES, '-DI_MULTIPLICITY=0';
+ push @DEFINES, '-DXSH_MULTIPLICITY=0';
 }
 
 # Fork emulation got "fixed" in 5.10.1
 if ($^O eq 'MSWin32' and "$]" < 5.010_001) {
- push @DEFINES, '-DI_FORKSAFE=0';
+ push @DEFINES, '-DXSH_FORKSAFE=0';
 }
 
 @DEFINES = (DEFINE => join ' ', @DEFINES) if @DEFINES;
index ec53317..0545e01 100644 (file)
@@ -6,19 +6,92 @@
 #include "perl.h"
 #include "XSUB.h"
 
-#define __PACKAGE__     "indirect"
-#define __PACKAGE_LEN__ (sizeof(__PACKAGE__)-1)
+/* --- XS helpers ---------------------------------------------------------- */
 
-/* --- Compatibility wrappers ---------------------------------------------- */
+#define XSH_PACKAGE "indirect"
 
-#ifndef NOOP
-# define NOOP
-#endif
+#include "xsh/caps.h"
+#include "xsh/util.h"
+#include "xsh/ops.h"
+
+/* ... op => source position map ........................................... */
+
+typedef struct {
+ char   *buf;
+ STRLEN  pos;
+ STRLEN  size;
+ STRLEN  len;
+ line_t  line;
+} indirect_op_info_t;
+
+#define PTABLE_NAME        ptable
+#define PTABLE_VAL_FREE(V) if (V) { Safefree(((indirect_op_info_t *) (V))->buf); Safefree(V); }
+#define PTABLE_NEED_DELETE 1
+#define PTABLE_NEED_WALK   0
+
+#include "xsh/ptable.h"
+
+/* Safefree() always need aTHX */
+#define ptable_store(T, K, V) ptable_store(aTHX_ (T), (K), (V))
+#define ptable_delete(T, K)   ptable_delete(aTHX_ (T), (K))
+#define ptable_clear(T)       ptable_clear(aTHX_ (T))
+#define ptable_free(T)        ptable_free(aTHX_ (T))
+
+/* ... Lexical hints ....................................................... */
 
-#ifndef dNOOP
-# define dNOOP
+#define XSH_HINTS_TYPE_SV 1
+
+#include "xsh/hints.h"
+
+/* ... Thread-local storage ................................................ */
+
+typedef struct {
+ ptable *map;
+ SV     *global_code;
+} xsh_user_cxt_t;
+
+#define XSH_THREADS_USER_CONTEXT            1
+#define XSH_THREADS_USER_CLONE_NEEDS_DUP    1
+#define XSH_THREADS_COMPILE_TIME_PROTECTION 1
+
+#if XSH_THREADSAFE
+
+static void xsh_user_clone(pTHX_ const xsh_user_cxt_t *old_cxt, xsh_user_cxt_t *new_cxt, CLONE_PARAMS *params) {
+ new_cxt->map         = ptable_new(32);
+ new_cxt->global_code = xsh_dup_inc(old_cxt->global_code, params);
+
+ return;
+}
+
+#endif /* XSH_THREADSAFE */
+
+#include "xsh/threads.h"
+
+/* ... Lexical hints, continued ............................................ */
+
+static SV *indirect_hint(pTHX) {
+#define indirect_hint() indirect_hint(aTHX)
+ SV *hint;
+
+#if XSH_HAS_PERL(5, 10, 0) || defined(PL_parser)
+ if (!PL_parser)
+  return NULL;
 #endif
 
+ hint = xsh_hints_fetch();
+ if (hint && SvOK(hint)) {
+  return xsh_hints_detag(hint);
+ } else {
+  dXSH_CXT;
+  if (xsh_is_loaded(&XSH_CXT))
+   return XSH_CXT.global_code;
+  else
+   return NULL;
+ }
+}
+
+/* --- Compatibility wrappers ---------------------------------------------- */
+
 #ifndef Newx
 # define Newx(v, n, c) New(0, v, n, c)
 #endif
 # define HvNAMELEN_get(H) strlen(HvNAME_get(H))
 #endif
 
-#ifndef OpSIBLING
-# ifdef OP_SIBLING
-#  define OpSIBLING(O) OP_SIBLING(O)
-# else
-#  define OpSIBLING(O) ((O)->op_sibling)
-# endif
-#endif
-
-#define I_HAS_PERL(R, V, S) (PERL_REVISION > (R) || (PERL_REVISION == (R) && (PERL_VERSION > (V) || (PERL_VERSION == (V) && (PERL_SUBVERSION >= (S))))))
-
-#if I_HAS_PERL(5, 10, 0) || defined(PL_parser)
+#if XSH_HAS_PERL(5, 10, 0) || defined(PL_parser)
 # ifndef PL_linestr
 #  define PL_linestr PL_parser->linestr
 # endif
 # endif
 #endif
 
-#ifdef DEBUGGING
-# define I_ASSERT(C) assert(C)
-#else
-# define I_ASSERT(C)
-#endif
-
-#ifndef I_WORKAROUND_REQUIRE_PROPAGATION
-# define I_WORKAROUND_REQUIRE_PROPAGATION !I_HAS_PERL(5, 10, 1)
-#endif
-
-/* ... 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)
-#  define I_MULTIPLICITY 1
-# else
-#  define I_MULTIPLICITY 0
-# endif
-#endif
-#if I_MULTIPLICITY
-# ifndef PERL_IMPLICIT_CONTEXT
-#  error MULTIPLICITY builds must set PERL_IMPLICIT_CONTEXT
-# endif
-#endif
-#if I_MULTIPLICITY && !defined(tTHX)
-# define tTHX PerlInterpreter*
-#endif
-
-#if I_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 I_THREADSAFE 1
-# ifndef MY_CXT_CLONE
-#  define MY_CXT_CLONE \
-    dMY_CXT_SV;                                                      \
-    my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1)); \
-    Copy(INT2PTR(my_cxt_t*, SvUV(my_cxt_sv)), my_cxtp, 1, my_cxt_t); \
-    sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))
-# endif
-#else
-# define I_THREADSAFE 0
-# undef  dMY_CXT
-# define dMY_CXT      dNOOP
-# undef  MY_CXT
-# define MY_CXT       indirect_globaldata
-# undef  START_MY_CXT
-# define START_MY_CXT static my_cxt_t MY_CXT;
-# undef  MY_CXT_INIT
-# define MY_CXT_INIT  NOOP
-# undef  MY_CXT_CLONE
-# define MY_CXT_CLONE NOOP
-#endif
-
-#if I_THREADSAFE
-/* We must use preexistent global mutexes or we will never be able to destroy
- * them. */
-# if I_HAS_PERL(5, 9, 3)
-#  define I_LOADED_LOCK   MUTEX_LOCK(&PL_my_ctx_mutex)
-#  define I_LOADED_UNLOCK MUTEX_UNLOCK(&PL_my_ctx_mutex)
-# else
-#  define I_LOADED_LOCK   OP_REFCNT_LOCK
-#  define I_LOADED_UNLOCK OP_REFCNT_UNLOCK
-# endif
-#else
-# define I_LOADED_LOCK   NOOP
-# define I_LOADED_UNLOCK NOOP
-#endif
-
-#if defined(OP_CHECK_MUTEX_LOCK) && defined(OP_CHECK_MUTEX_UNLOCK)
-# define I_CHECK_LOCK   OP_CHECK_MUTEX_LOCK
-# define I_CHECK_UNLOCK OP_CHECK_MUTEX_UNLOCK
-#elif I_HAS_PERL(5, 9, 3)
-# define I_CHECK_LOCK   OP_REFCNT_LOCK
-# define I_CHECK_UNLOCK OP_REFCNT_UNLOCK
-#else
-/* Before perl 5.9.3, indirect_ck_*() calls are already protected by the
- * I_LOADED mutex, which falls back to the OP_REFCNT mutex. Make sure we don't
- * lock it twice. */
-# define I_CHECK_LOCK   NOOP
-# define I_CHECK_UNLOCK NOOP
-#endif
-
-typedef OP *(*indirect_ck_t)(pTHX_ OP *);
-
-#ifdef wrap_op_checker
-
-# define indirect_ck_replace(T, NC, OCP) wrap_op_checker((T), (NC), (OCP))
-
-#else
-
-static void indirect_ck_replace(pTHX_ OPCODE type, indirect_ck_t new_ck, indirect_ck_t *old_ck_p) {
-#define indirect_ck_replace(T, NC, OCP) indirect_ck_replace(aTHX_ (T), (NC), (OCP))
- I_CHECK_LOCK;
- if (!*old_ck_p) {
-  *old_ck_p      = PL_check[type];
-  PL_check[type] = new_ck;
- }
- I_CHECK_UNLOCK;
-}
-
-#endif
-
-static void indirect_ck_restore(pTHX_ OPCODE type, indirect_ck_t *old_ck_p) {
-#define indirect_ck_restore(T, OCP) indirect_ck_restore(aTHX_ (T), (OCP))
- I_CHECK_LOCK;
- if (*old_ck_p) {
-  PL_check[type] = *old_ck_p;
-  *old_ck_p      = 0;
- }
- I_CHECK_UNLOCK;
-}
-
-/* --- Helpers ------------------------------------------------------------- */
-
-/* ... Check if the module is loaded ....................................... */
-
-static I32 indirect_loaded = 0;
-
-#if I_THREADSAFE
-
-#define PTABLE_NAME        ptable_loaded
-#define PTABLE_NEED_DELETE 1
-#define PTABLE_NEED_WALK   0
-
-#include "ptable.h"
-
-#define ptable_loaded_store(T, K, V) ptable_loaded_store(aPTBLMS_ (T), (K), (V))
-#define ptable_loaded_delete(T, K)   ptable_loaded_delete(aPTBLMS_ (T), (K))
-#define ptable_loaded_free(T)        ptable_loaded_free(aPTBLMS_ (T))
-
-static ptable *indirect_loaded_cxts = NULL;
-
-static int indirect_is_loaded(pTHX_ void *cxt) {
-#define indirect_is_loaded(C) indirect_is_loaded(aTHX_ (C))
- int res = 0;
-
- I_LOADED_LOCK;
- if (indirect_loaded_cxts && ptable_fetch(indirect_loaded_cxts, cxt))
-  res = 1;
- I_LOADED_UNLOCK;
-
- return res;
-}
-
-static int indirect_set_loaded_locked(pTHX_ void *cxt) {
-#define indirect_set_loaded_locked(C) indirect_set_loaded_locked(aTHX_ (C))
- int global_setup = 0;
-
- if (indirect_loaded <= 0) {
-  I_ASSERT(indirect_loaded == 0);
-  I_ASSERT(!indirect_loaded_cxts);
-  indirect_loaded_cxts = ptable_new();
-  global_setup         = 1;
- }
- ++indirect_loaded;
- I_ASSERT(indirect_loaded_cxts);
- ptable_loaded_store(indirect_loaded_cxts, cxt, cxt);
-
- return global_setup;
-}
-
-static int indirect_clear_loaded_locked(pTHX_ void *cxt) {
-#define indirect_clear_loaded_locked(C) indirect_clear_loaded_locked(aTHX_ (C))
- int global_teardown = 0;
-
- if (indirect_loaded > 1) {
-  I_ASSERT(indirect_loaded_cxts);
-  ptable_loaded_delete(indirect_loaded_cxts, cxt);
-  --indirect_loaded;
- } else if (indirect_loaded_cxts) {
-  I_ASSERT(indirect_loaded == 1);
-  ptable_loaded_free(indirect_loaded_cxts);
-  indirect_loaded_cxts = NULL;
-  indirect_loaded      = 0;
-  global_teardown      = 1;
- }
-
- return global_teardown;
-}
-
-#else
-
-#define indirect_is_loaded(C)           (indirect_loaded > 0)
-#define indirect_set_loaded_locked(C)   ((indirect_loaded++ <= 0) ? 1 : 0)
-#define indirect_clear_loaded_locked(C) ((--indirect_loaded <= 0) ? 1 : 0)
-
-#endif
-
-/* ... Thread-safe hints ................................................... */
-
-#if I_WORKAROUND_REQUIRE_PROPAGATION
-
-typedef struct {
- SV *code;
- IV  require_tag;
-} indirect_hint_t;
-
-#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 */
-
-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 PTABLE_NEED_DELETE 0
-#define PTABLE_NEED_WALK   1
-
-#define pPTBL  pTHX
-#define pPTBL_ pTHX_
-#define aPTBL  aTHX
-#define aPTBL_ aTHX_
-
-#include "ptable.h"
-
-#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 */
-
-/* Define the op->str ptable here because we need to be able to clean it during
- * thread cleanup. */
-
-typedef struct {
- char   *buf;
- STRLEN  pos;
- STRLEN  size;
- STRLEN  len;
- line_t  line;
-} indirect_op_info_t;
-
-#define PTABLE_NAME        ptable
-#define PTABLE_VAL_FREE(V) if (V) { Safefree(((indirect_op_info_t *) (V))->buf); Safefree(V); }
-#define PTABLE_NEED_DELETE 1
-#define PTABLE_NEED_WALK   0
-
-#define pPTBL  pTHX
-#define pPTBL_ pTHX_
-#define aPTBL  aTHX
-#define aPTBL_ aTHX_
-
-#include "ptable.h"
-
-#define ptable_store(T, K, V) ptable_store(aTHX_ (T), (K), (V))
-#define ptable_delete(T, K)   ptable_delete(aTHX_ (T), (K))
-#define ptable_clear(T)       ptable_clear(aTHX_ (T))
-#define ptable_free(T)        ptable_free(aTHX_ (T))
-
-#define MY_CXT_KEY __PACKAGE__ "::_guts" XS_VERSION
-
-typedef struct {
-#if I_THREADSAFE
- ptable *tbl; /* It really is a ptable_hints */
- tTHX    owner;
-#endif
- ptable *map;
- SV     *global_code;
-} my_cxt_t;
-
-START_MY_CXT
-
-#if I_THREADSAFE
-
-typedef struct {
- ptable *tbl;
-#if I_HAS_PERL(5, 13, 2)
- CLONE_PARAMS *params;
-#else
- CLONE_PARAMS params;
-#endif
-} indirect_ptable_clone_ud;
-
-#if I_HAS_PERL(5, 13, 2)
-# define indirect_ptable_clone_ud_init(U, T, O) \
-   (U).tbl    = (T); \
-   (U).params = Perl_clone_params_new((O), aTHX)
-# define indirect_ptable_clone_ud_deinit(U) Perl_clone_params_del((U).params)
-# define indirect_dup_inc(S, U)             SvREFCNT_inc(sv_dup((S), (U)->params))
-#else
-# define indirect_ptable_clone_ud_init(U, T, O) \
-   (U).tbl               = (T);     \
-   (U).params.stashes    = newAV(); \
-   (U).params.flags      = 0;       \
-   (U).params.proto_perl = (O)
-# define indirect_ptable_clone_ud_deinit(U) SvREFCNT_dec((U).params.stashes)
-# define indirect_dup_inc(S, U)             SvREFCNT_inc(sv_dup((S), &((U)->params)))
-#endif
-
-static void indirect_ptable_clone(pTHX_ ptable_ent *ent, void *ud_) {
- indirect_ptable_clone_ud *ud = ud_;
- indirect_hint_t          *h1 = ent->val;
- indirect_hint_t          *h2;
-
-#if I_HINT_STRUCT
-
- h2              = PerlMemShared_malloc(sizeof *h2);
- h2->code        = indirect_dup_inc(h1->code, ud);
-#if I_WORKAROUND_REQUIRE_PROPAGATION
- h2->require_tag = PTR2IV(indirect_dup_inc(INT2PTR(SV *, h1->require_tag), ud));
-#endif
-
-#else  /*  I_HINT_STRUCT */
-
- h2 = indirect_dup_inc(h1, ud);
-
-#endif /* !I_HINT_STRUCT */
-
- ptable_hints_store(ud->tbl, ent->key, h2);
-}
-
-#endif /* I_THREADSAFE */
-
-#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))
- indirect_hint_t *h;
- SV              *code = NULL;
-#if I_THREADSAFE
- dMY_CXT;
-
- if (!MY_CXT.tbl)
-  return newSViv(0);
-#endif /* I_THREADSAFE */
-
- if (SvROK(value)) {
-  value = SvRV(value);
-  if (SvTYPE(value) >= SVt_PVCV) {
-   code = value;
-   SvREFCNT_inc_simple_void_NN(code);
-  }
- }
-
-#if I_HINT_STRUCT
- h = PerlMemShared_malloc(sizeof *h);
- 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));
-}
-
-static SV *indirect_detag(pTHX_ const SV *hint) {
-#define indirect_detag(H) indirect_detag(aTHX_ (H))
- indirect_hint_t *h;
-#if I_THREADSAFE || I_WORKAROUND_REQUIRE_PROPAGATION
- dMY_CXT;
-#endif
-
-#if I_THREADSAFE
- if (!MY_CXT.tbl)
-  return NULL;
-#endif /* I_THREADSAFE */
-
- 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
- if (indirect_require_tag() != h->require_tag)
-  return MY_CXT.global_code;
-#endif /* I_WORKAROUND_REQUIRE_PROPAGATION */
-
- return I_HINT_CODE(h);
-}
-
-static VOL U32 indirect_hash = 0;
-
-static SV *indirect_hint(pTHX) {
-#define indirect_hint() indirect_hint(aTHX)
- SV *hint = NULL;
-
- if (IN_PERL_RUNTIME)
-  return NULL;
-
-#if I_HAS_PERL(5, 10, 0) || defined(PL_parser)
- if (!PL_parser)
-  return NULL;
-#endif
-
-#ifdef cop_hints_fetch_pvn
- hint = cop_hints_fetch_pvn(PL_curcop, __PACKAGE__, __PACKAGE_LEN__,
-                                                              indirect_hash, 0);
-#elif I_HAS_PERL(5, 9, 5)
- hint = Perl_refcounted_he_fetch(aTHX_ PL_curcop->cop_hints_hash,
-                                       NULL,
-                                       __PACKAGE__, __PACKAGE_LEN__,
-                                       0,
-                                       indirect_hash);
-#else
- {
-  SV **val = hv_fetch(GvHV(PL_hintgv), __PACKAGE__, __PACKAGE_LEN__, 0);
-  if (val)
-   hint = *val;
- }
-#endif
-
- if (hint && SvIOK(hint)) {
-  return indirect_detag(hint);
- } else {
-  dMY_CXT;
-  if (indirect_is_loaded(&MY_CXT))
-   return MY_CXT.global_code;
-  else
-   return NULL;
- }
-}
-
-/* ... op -> source position ............................................... */
-
-static void indirect_map_store(pTHX_ const OP *o, STRLEN pos, SV *sv, line_t line) {
-#define indirect_map_store(O, P, N, L) indirect_map_store(aTHX_ (O), (P), (N), (L))
- indirect_op_info_t *oi;
- const char *s;
- STRLEN len;
- dMY_CXT;
-
- /* No need to check for MY_CXT.map != NULL because this code path is always
-  * guarded by indirect_hint(). */
-
- if (!(oi = ptable_fetch(MY_CXT.map, o))) {
-  Newx(oi, 1, indirect_op_info_t);
-  ptable_store(MY_CXT.map, o, oi);
-  oi->buf  = NULL;
-  oi->size = 0;
- }
-
- if (sv) {
-  s = SvPV_const(sv, len);
- } else {
-  s   = "{";
-  len = 1;
- }
-
- if (len > oi->size) {
-  Safefree(oi->buf);
-  Newx(oi->buf, len, char);
-  oi->size = len;
- }
- Copy(s, oi->buf, len, char);
-
- oi->len  = len;
- oi->pos  = pos;
- oi->line = line;
-}
-
-static const indirect_op_info_t *indirect_map_fetch(pTHX_ const OP *o) {
-#define indirect_map_fetch(O) indirect_map_fetch(aTHX_ (O))
- dMY_CXT;
-
- /* No need to check for MY_CXT.map != NULL because this code path is always
-  * guarded by indirect_hint(). */
-
- return ptable_fetch(MY_CXT.map, o);
-}
-
-static void indirect_map_delete(pTHX_ const OP *o) {
-#define indirect_map_delete(O) indirect_map_delete(aTHX_ (O))
- dMY_CXT;
-
- if (indirect_is_loaded(&MY_CXT) && MY_CXT.map)
-  ptable_delete(MY_CXT.map, o);
-}
-
-/* --- Safe version of call_sv() ------------------------------------------- */
+/* ... Safe version of call_sv() ........................................... */
 
 static I32 indirect_call_sv(pTHX_ SV *sv, I32 flags) {
 #define indirect_call_sv(S, F) indirect_call_sv(aTHX_ (S), (F))
@@ -679,7 +199,7 @@ static I32 indirect_call_sv(pTHX_ SV *sv, I32 flags) {
   SvCUR_set(ERRSV, 0);
   /* Immediately flush all errors. */
   if (IN_PERL_COMPILETIME) {
-#if I_HAS_PERL(5, 10, 0) || defined(PL_parser)
+#if XSH_HAS_PERL(5, 10, 0) || defined(PL_parser)
    if (PL_parser)
     ++PL_parser->error_count;
 #elif defined(PL_error_count)
@@ -708,6 +228,64 @@ static I32 indirect_call_sv(pTHX_ SV *sv, I32 flags) {
 
 /* --- Check functions ----------------------------------------------------- */
 
+/* ... op => source position map, continued ................................ */
+
+static void indirect_map_store(pTHX_ const OP *o, STRLEN pos, SV *sv, line_t line) {
+#define indirect_map_store(O, P, N, L) indirect_map_store(aTHX_ (O), (P), (N), (L))
+ indirect_op_info_t *oi;
+ const char *s;
+ STRLEN len;
+ dXSH_CXT;
+
+ /* No need to check for XSH_CXT.map != NULL because this code path is always
+  * guarded by indirect_hint(). */
+
+ if (!(oi = ptable_fetch(XSH_CXT.map, o))) {
+  Newx(oi, 1, indirect_op_info_t);
+  ptable_store(XSH_CXT.map, o, oi);
+  oi->buf  = NULL;
+  oi->size = 0;
+ }
+
+ if (sv) {
+  s = SvPV_const(sv, len);
+ } else {
+  s   = "{";
+  len = 1;
+ }
+
+ if (len > oi->size) {
+  Safefree(oi->buf);
+  Newx(oi->buf, len, char);
+  oi->size = len;
+ }
+ Copy(s, oi->buf, len, char);
+
+ oi->len  = len;
+ oi->pos  = pos;
+ oi->line = line;
+}
+
+static const indirect_op_info_t *indirect_map_fetch(pTHX_ const OP *o) {
+#define indirect_map_fetch(O) indirect_map_fetch(aTHX_ (O))
+ dXSH_CXT;
+
+ /* No need to check for XSH_CXT.map != NULL because this code path is always
+  * guarded by indirect_hint(). */
+
+ return ptable_fetch(XSH_CXT.map, o);
+}
+
+static void indirect_map_delete(pTHX_ const OP *o) {
+#define indirect_map_delete(O) indirect_map_delete(aTHX_ (O))
+ dXSH_CXT;
+
+ if (xsh_is_loaded(&XSH_CXT) && XSH_CXT.map)
+  ptable_delete(XSH_CXT.map, o);
+}
+
+/* ... Heuristics for finding a string in the source buffer ................ */
+
 static int indirect_find(pTHX_ SV *name_sv, const char *line_bufptr, STRLEN *name_pos) {
 #define indirect_find(NSV, LBP, NP) indirect_find(aTHX_ (NSV), (LBP), (NP))
  STRLEN      name_len, line_len;
@@ -1078,81 +656,56 @@ done:
 
 /* --- Module setup/teardown ----------------------------------------------- */
 
-static void indirect_teardown(pTHX_ void *interp) {
- dMY_CXT;
-
- I_LOADED_LOCK;
-
- if (indirect_clear_loaded_locked(&MY_CXT)) {
-  indirect_ck_restore(OP_CONST,   &indirect_old_ck_const);
-  indirect_ck_restore(OP_RV2SV,   &indirect_old_ck_rv2sv);
-  indirect_ck_restore(OP_PADANY,  &indirect_old_ck_padany);
-  indirect_ck_restore(OP_SCOPE,   &indirect_old_ck_scope);
-  indirect_ck_restore(OP_LINESEQ, &indirect_old_ck_lineseq);
-
-  indirect_ck_restore(OP_METHOD,       &indirect_old_ck_method);
-  indirect_ck_restore(OP_METHOD_NAMED, &indirect_old_ck_method_named);
-  indirect_ck_restore(OP_ENTERSUB,     &indirect_old_ck_entersub);
- }
-
- I_LOADED_UNLOCK;
+static void xsh_user_global_setup(pTHX) {
+ xsh_ck_replace(OP_CONST,   indirect_ck_const,  &indirect_old_ck_const);
+ xsh_ck_replace(OP_RV2SV,   indirect_ck_rv2sv,  &indirect_old_ck_rv2sv);
+ xsh_ck_replace(OP_PADANY,  indirect_ck_padany, &indirect_old_ck_padany);
+ xsh_ck_replace(OP_SCOPE,   indirect_ck_scope,  &indirect_old_ck_scope);
+ xsh_ck_replace(OP_LINESEQ, indirect_ck_scope,  &indirect_old_ck_lineseq);
 
- SvREFCNT_dec(MY_CXT.global_code);
- MY_CXT.global_code = NULL;
-
- ptable_free(MY_CXT.map);
- MY_CXT.map = NULL;
-
-#if I_THREADSAFE
- ptable_hints_free(MY_CXT.tbl);
- MY_CXT.tbl = NULL;
-#endif
+ xsh_ck_replace(OP_METHOD,       indirect_ck_method,
+                                 &indirect_old_ck_method);
+ xsh_ck_replace(OP_METHOD_NAMED, indirect_ck_method_named,
+                                 &indirect_old_ck_method_named);
+ xsh_ck_replace(OP_ENTERSUB,     indirect_ck_entersub,
+                                 &indirect_old_ck_entersub);
 
  return;
 }
 
-static void indirect_setup(pTHX) {
-#define indirect_setup() indirect_setup(aTHX)
- MY_CXT_INIT; /* Takes/release PL_my_ctx_mutex */
+static void xsh_user_local_setup(pTHX_ xsh_user_cxt_t *cxt) {
+ HV *stash;
 
- I_LOADED_LOCK;
+ stash = gv_stashpvn(XSH_PACKAGE, XSH_PACKAGE_LEN, 1);
+ newCONSTSUB(stash, "I_THREADSAFE", newSVuv(XSH_THREADSAFE));
+ newCONSTSUB(stash, "I_FORKSAFE",   newSVuv(XSH_FORKSAFE));
 
- if (indirect_set_loaded_locked(&MY_CXT)) {
-  PERL_HASH(indirect_hash, __PACKAGE__, __PACKAGE_LEN__);
-
-  indirect_ck_replace(OP_CONST,   indirect_ck_const,  &indirect_old_ck_const);
-  indirect_ck_replace(OP_RV2SV,   indirect_ck_rv2sv,  &indirect_old_ck_rv2sv);
-  indirect_ck_replace(OP_PADANY,  indirect_ck_padany, &indirect_old_ck_padany);
-  indirect_ck_replace(OP_SCOPE,   indirect_ck_scope,  &indirect_old_ck_scope);
-  indirect_ck_replace(OP_LINESEQ, indirect_ck_scope,  &indirect_old_ck_lineseq);
-
-  indirect_ck_replace(OP_METHOD,       indirect_ck_method,
-                                       &indirect_old_ck_method);
-  indirect_ck_replace(OP_METHOD_NAMED, indirect_ck_method_named,
-                                       &indirect_old_ck_method_named);
-  indirect_ck_replace(OP_ENTERSUB,     indirect_ck_entersub,
-                                       &indirect_old_ck_entersub);
- }
+ cxt->map         = ptable_new(32);
+ cxt->global_code = NULL;
 
- I_LOADED_UNLOCK;
+ return;
+}
 
- {
-  HV *stash;
+static void xsh_user_local_teardown(pTHX_ xsh_user_cxt_t *cxt) {
+ SvREFCNT_dec(cxt->global_code);
+ cxt->global_code = NULL;
 
-  stash = gv_stashpvn(__PACKAGE__, __PACKAGE_LEN__, 1);
-  newCONSTSUB(stash, "I_THREADSAFE", newSVuv(I_THREADSAFE));
-  newCONSTSUB(stash, "I_FORKSAFE",   newSVuv(I_FORKSAFE));
+ ptable_free(cxt->map);
+ cxt->map         = NULL;
 
-#if I_THREADSAFE
-  MY_CXT.tbl         = ptable_new();
-  MY_CXT.owner       = aTHX;
-#endif
+ return;
+}
 
-  MY_CXT.map         = ptable_new();
-  MY_CXT.global_code = NULL;
- }
+static void xsh_user_global_teardown(pTHX) {
+ xsh_ck_restore(OP_CONST,   &indirect_old_ck_const);
+ xsh_ck_restore(OP_RV2SV,   &indirect_old_ck_rv2sv);
+ xsh_ck_restore(OP_PADANY,  &indirect_old_ck_padany);
+ xsh_ck_restore(OP_SCOPE,   &indirect_old_ck_scope);
+ xsh_ck_restore(OP_LINESEQ, &indirect_old_ck_lineseq);
 
- call_atexit(indirect_teardown, NULL);
+ xsh_ck_restore(OP_METHOD,       &indirect_old_ck_method);
+ xsh_ck_restore(OP_METHOD_NAMED, &indirect_old_ck_method_named);
+ xsh_ck_restore(OP_ENTERSUB,     &indirect_old_ck_entersub);
 
  return;
 }
@@ -1165,50 +718,29 @@ PROTOTYPES: ENABLE
 
 BOOT:
 {
indirect_setup();
xsh_setup();
 }
 
-#if I_THREADSAFE
+#if XSH_THREADSAFE
 
 void
 CLONE(...)
 PROTOTYPE: DISABLE
-PREINIT:
- ptable *t;
- SV     *global_code_dup;
 PPCODE:
- {
-  indirect_ptable_clone_ud ud;
-  dMY_CXT;
-  t = ptable_new();
-  indirect_ptable_clone_ud_init(ud, t, MY_CXT.owner);
-  ptable_walk(MY_CXT.tbl, indirect_ptable_clone, &ud);
-  global_code_dup = indirect_dup_inc(MY_CXT.global_code, &ud);
-  indirect_ptable_clone_ud_deinit(ud);
- }
- {
-  MY_CXT_CLONE;
-  MY_CXT.map         = ptable_new();
-  MY_CXT.tbl         = t;
-  MY_CXT.owner       = aTHX;
-  MY_CXT.global_code = global_code_dup;
-  {
-   int global_setup;
-   I_LOADED_LOCK;
-   global_setup = indirect_set_loaded_locked(&MY_CXT);
-   I_ASSERT(!global_setup);
-   I_LOADED_UNLOCK;
-  }
- }
+ xsh_clone();
  XSRETURN(0);
 
-#endif /* I_THREADSAFE */
+#endif /* XSH_THREADSAFE */
 
 SV *
-_tag(SV *value)
+_tag(SV *code)
 PROTOTYPE: $
 CODE:
- RETVAL = indirect_tag(value);
+ if (!SvOK(code))
+  code = NULL;
+ else if (SvROK(code))
+  code = SvRV(code);
+ RETVAL = xsh_hints_tag(code);
 OUTPUT:
  RETVAL
 
@@ -1221,8 +753,8 @@ PPCODE:
  else if (SvROK(code))
   code = SvRV(code);
  {
-  dMY_CXT;
-  SvREFCNT_dec(MY_CXT.global_code);
-  MY_CXT.global_code = SvREFCNT_inc(code);
+  dXSH_CXT;
+  SvREFCNT_dec(XSH_CXT.global_code);
+  XSH_CXT.global_code = SvREFCNT_inc(code);
  }
  XSRETURN(0);
diff --git a/ptable.h b/ptable.h
deleted file mode 100644 (file)
index 4b48aa6..0000000
--- a/ptable.h
+++ /dev/null
@@ -1,269 +0,0 @@
-/* This file is part of the indirect Perl module.
- * See http://search.cpan.org/dist/indirect/ */
-
-/* This is a pointer table implementation essentially copied from the ptr_table
- * implementation in perl's sv.c, except that it has been modified to use memory
- * shared across threads.
- * Copyright goes to the original authors, bug reports to me. */
-
-/* This header is designed to be included several times with different
- * definitions for PTABLE_NAME and PTABLE_VAL_FREE(). */
-
-#undef VOID2
-#ifdef __cplusplus
-# define VOID2(T, P) static_cast<T>(P)
-#else
-# define VOID2(T, P) (P)
-#endif
-
-#undef pPTBLMS
-#undef pPTBLMS_
-#undef aPTBLMS
-#undef aPTBLMS_
-
-/* Context for PerlMemShared_* functions */
-
-#ifdef PERL_IMPLICIT_SYS
-# define pPTBLMS  pTHX
-# define pPTBLMS_ pTHX_
-# define aPTBLMS  aTHX
-# define aPTBLMS_ aTHX_
-#else
-# define pPTBLMS  void
-# define pPTBLMS_
-# define aPTBLMS
-# define aPTBLMS_
-#endif
-
-#ifndef pPTBL
-# define pPTBL  pPTBLMS
-#endif
-#ifndef pPTBL_
-# define pPTBL_ pPTBLMS_
-#endif
-#ifndef aPTBL
-# define aPTBL  aPTBLMS
-#endif
-#ifndef aPTBL_
-# define aPTBL_ aPTBLMS_
-#endif
-
-#ifndef PTABLE_NAME
-# define PTABLE_NAME ptable
-#endif
-
-#ifndef PTABLE_JOIN
-# define PTABLE_PASTE(A, B) A ## B
-# define PTABLE_JOIN(A, B)  PTABLE_PASTE(A, B)
-#endif
-
-#ifndef PTABLE_PREFIX
-# define PTABLE_PREFIX(X) PTABLE_JOIN(PTABLE_NAME, X)
-#endif
-
-#ifndef PTABLE_NEED_DELETE
-# define PTABLE_NEED_DELETE 1
-#endif
-
-#ifndef PTABLE_NEED_WALK
-# define PTABLE_NEED_WALK 1
-#endif
-
-#ifndef ptable_ent
-typedef struct ptable_ent {
- struct ptable_ent *next;
- const void *       key;
- void *             val;
-} ptable_ent;
-#define ptable_ent ptable_ent
-#endif /* !ptable_ent */
-
-#ifndef ptable
-typedef struct ptable {
- ptable_ent **ary;
- size_t       max;
- size_t       items;
-} ptable;
-#define ptable ptable
-#endif /* !ptable */
-
-#ifndef ptable_new
-static ptable *ptable_new(pPTBLMS) {
-#define ptable_new() ptable_new(aPTBLMS)
- ptable *t = VOID2(ptable *, PerlMemShared_malloc(sizeof *t));
- t->max    = 15;
- t->items  = 0;
- t->ary    = VOID2(ptable_ent **,
-                              PerlMemShared_calloc(t->max + 1, sizeof *t->ary));
- return t;
-}
-#endif /* !ptable_new */
-
-#ifndef PTABLE_HASH
-# define PTABLE_HASH(ptr) \
-     ((PTR2UV(ptr) >> 3) ^ (PTR2UV(ptr) >> (3 + 7)) ^ (PTR2UV(ptr) >> (3 + 17)))
-#endif
-
-#ifndef ptable_find
-static ptable_ent *ptable_find(const ptable * const t, const void * const key) {
-#define ptable_find ptable_find
- ptable_ent *ent;
- const UV hash = PTABLE_HASH(key);
-
- ent = t->ary[hash & t->max];
- for (; ent; ent = ent->next) {
-  if (ent->key == key)
-   return ent;
- }
-
- return NULL;
-}
-#endif /* !ptable_find */
-
-#ifndef ptable_fetch
-static void *ptable_fetch(const ptable * const t, const void * const key) {
-#define ptable_fetch ptable_fetch
- const ptable_ent *const ent = ptable_find(t, key);
-
- return ent ? ent->val : NULL;
-}
-#endif /* !ptable_fetch */
-
-#ifndef ptable_split
-static void ptable_split(pPTBLMS_ ptable * const t) {
-#define ptable_split(T) ptable_split(aPTBLMS_ (T))
- ptable_ent **ary = t->ary;
- const size_t oldsize = t->max + 1;
- size_t newsize = oldsize * 2;
- size_t i;
-
- ary = VOID2(ptable_ent **, PerlMemShared_realloc(ary, newsize * sizeof(*ary)));
- Zero(&ary[oldsize], newsize - oldsize, sizeof(*ary));
- t->max = --newsize;
- t->ary = ary;
-
- for (i = 0; i < oldsize; i++, ary++) {
-  ptable_ent **curentp, **entp, *ent;
-  if (!*ary)
-   continue;
-  curentp = ary + oldsize;
-  for (entp = ary, ent = *ary; ent; ent = *entp) {
-   if ((newsize & PTABLE_HASH(ent->key)) != i) {
-    *entp     = ent->next;
-    ent->next = *curentp;
-    *curentp  = ent;
-    continue;
-   } else
-    entp = &ent->next;
-  }
- }
-}
-#endif /* !ptable_split */
-
-static void PTABLE_PREFIX(_store)(pPTBL_ ptable * const t, const void * const key, void * const val) {
- ptable_ent *ent = ptable_find(t, key);
-
- if (ent) {
-#ifdef PTABLE_VAL_FREE
-  void *oldval = ent->val;
-  PTABLE_VAL_FREE(oldval);
-#endif
-  ent->val = val;
- } else if (val) {
-  const size_t i = PTABLE_HASH(key) & t->max;
-  ent = VOID2(ptable_ent *, PerlMemShared_malloc(sizeof *ent));
-  ent->key  = key;
-  ent->val  = val;
-  ent->next = t->ary[i];
-  t->ary[i] = ent;
-  t->items++;
-  if (ent->next && t->items > t->max)
-   ptable_split(t);
- }
-}
-
-#if PTABLE_NEED_DELETE
-
-static void PTABLE_PREFIX(_delete)(pPTBL_ ptable * const t, const void * const key) {
- ptable_ent *prev, *ent;
- const size_t i = PTABLE_HASH(key) & t->max;
-
- prev = NULL;
- ent  = t->ary[i];
- for (; ent; prev = ent, ent = ent->next) {
-  if (ent->key == key)
-   break;
- }
-
- if (ent) {
-  if (prev)
-   prev->next = ent->next;
-  else
-   t->ary[i]  = ent->next;
-#ifdef PTABLE_VAL_FREE
-  PTABLE_VAL_FREE(ent->val);
-#endif
-  PerlMemShared_free(ent);
- }
-}
-
-#endif /* PTABLE_NEED_DELETE */
-
-#if PTABLE_NEED_WALK && !defined(ptable_walk)
-
-static void ptable_walk(pTHX_ ptable * const t, void (*cb)(pTHX_ ptable_ent *ent, void *userdata), void *userdata) {
-#define ptable_walk(T, CB, UD) ptable_walk(aTHX_ (T), (CB), (UD))
- if (t && t->items) {
-  register ptable_ent ** const array = t->ary;
-  size_t i = t->max;
-  do {
-   ptable_ent *entry;
-   for (entry = array[i]; entry; entry = entry->next)
-    if (entry->val)
-     cb(aTHX_ entry, userdata);
-  } while (i--);
- }
-}
-
-#endif /* PTABLE_NEED_WALK && !defined(ptable_walk) */
-
-static void PTABLE_PREFIX(_clear)(pPTBL_ ptable * const t) {
- if (t && t->items) {
-  register ptable_ent ** const array = t->ary;
-  size_t i = t->max;
-
-  do {
-   ptable_ent *entry = array[i];
-   while (entry) {
-    ptable_ent * const nentry = entry->next;
-#ifdef PTABLE_VAL_FREE
-    PTABLE_VAL_FREE(entry->val);
-#endif
-    PerlMemShared_free(entry);
-    entry = nentry;
-   }
-   array[i] = NULL;
-  } while (i--);
-
-  t->items = 0;
- }
-}
-
-static void PTABLE_PREFIX(_free)(pPTBL_ ptable * const t) {
- if (!t)
-  return;
- PTABLE_PREFIX(_clear)(aPTBL_ t);
- PerlMemShared_free(t->ary);
- PerlMemShared_free(t);
-}
-
-#undef pPTBL
-#undef pPTBL_
-#undef aPTBL
-#undef aPTBL_
-
-#undef PTABLE_NAME
-#undef PTABLE_VAL_FREE
-
-#undef PTABLE_NEED_DELETE
-#undef PTABLE_NEED_WALK
diff --git a/xsh/caps.h b/xsh/caps.h
new file mode 100644 (file)
index 0000000..4559524
--- /dev/null
@@ -0,0 +1,47 @@
+#ifndef XSH_CAPS_H
+#define XSH_CAPS_H 1
+
+#define XSH_HAS_PERL(R, V, S) (PERL_REVISION > (R) || (PERL_REVISION == (R) && (PERL_VERSION > (V) || (PERL_VERSION == (V) && (PERL_SUBVERSION >= (S))))))
+
+#define XSH_HAS_PERL_BRANCH(R, V, S) (PERL_REVISION == (R) && PERL_VERSION == (V) && PERL_SUBVERSION >= (S))
+
+#define XSH_HAS_PERL_EXACT(R, V, S) ((PERL_REVISION == (R)) && (PERL_VERSION == (V)) && (PERL_SUBVERSION == (S)))
+
+#ifndef XSH_PERL_PATCHLEVEL
+# ifdef PERL_PATCHNUM
+#  define XSH_PERL_PATCHLEVEL PERL_PATCHNUM
+# else
+#  define XSH_PERL_PATCHLEVEL 0
+# endif
+#endif
+
+#define XSH_HAS_PERL_MAINT(R, V, S, P) (PERL_REVISION == (R) && PERL_VERSION == (V) && (XSH_PERL_PATCHLEVEL >= (P) || (!XSH_PERL_PATCHLEVEL && PERL_SUBVERSION >= (S))))
+
+#ifndef XSH_MULTIPLICITY
+# if defined(MULTIPLICITY)
+#  define XSH_MULTIPLICITY 1
+# else
+#  define XSH_MULTIPLICITY 0
+# endif
+#endif
+#if XSH_MULTIPLICITY
+# ifndef PERL_IMPLICIT_CONTEXT
+#  error MULTIPLICITY builds must set PERL_IMPLICIT_CONTEXT
+# endif
+# ifndef tTHX
+#  define tTHX PerlInterpreter*
+# endif
+#endif
+
+#if XSH_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 XSH_THREADSAFE 1
+#else
+# define XSH_THREADSAFE 0
+#endif
+
+/* Safe unless stated otherwise in Makefile.PL */
+#ifndef XSH_FORKSAFE
+# define XSH_FORKSAFE 1
+#endif
+
+#endif /* XSH_CAPS_H */
diff --git a/xsh/debug.h b/xsh/debug.h
new file mode 100644 (file)
index 0000000..707c760
--- /dev/null
@@ -0,0 +1,27 @@
+#ifndef XSH_DEBUG_H
+#define XSH_DEBUG_H 1
+
+#include "util.h" /* XSH_PACKAGE, STMT_* */
+
+#ifndef XSH_DEBUG
+# define XSH_DEBUG 0
+#endif
+
+#if XSH_DEBUG
+# define XSH_D(X) STMT_START X STMT_END
+static void xsh_debug_log(const char *fmt, ...) {
+ va_list va;
+ SV *sv;
+ dTHX;
+ va_start(va, fmt);
+ sv = get_sv(XSH_PACKAGE "::DEBUG", 0);
+ if (sv && SvTRUE(sv))
+  PerlIO_vprintf(Perl_debug_log, fmt, va);
+ va_end(va);
+ return;
+}
+#else
+# define XSH_D(X)
+#endif
+
+#endif /* XSH_DEBUG_H */
diff --git a/xsh/hints.h b/xsh/hints.h
new file mode 100644 (file)
index 0000000..458b117
--- /dev/null
@@ -0,0 +1,372 @@
+#ifndef XSH_HINTS_H
+#define XSH_HINTS_H 1
+
+#include "caps.h" /* XSH_HAS_PERL(), XSH_THREADSAFE, tTHX */
+
+#ifdef XSH_THREADS_H
+# error threads.h must be loaded at the very end
+#endif
+
+#define XSH_HINTS_KEY     XSH_PACKAGE
+#define XSH_HINTS_KEY_LEN (sizeof(XSH_HINTS_KEY)-1)
+
+#ifndef XSH_WORKAROUND_REQUIRE_PROPAGATION
+# define XSH_WORKAROUND_REQUIRE_PROPAGATION !XSH_HAS_PERL(5, 10, 1)
+#endif
+
+#ifndef XSH_HINTS_ONLY_COMPILE_TIME
+# define XSH_HINTS_ONLY_COMPILE_TIME 1
+#endif
+
+#ifdef XSH_HINTS_TYPE_UV
+# ifdef XSH_HINTS_TYPE_VAL
+#  error hint type can only be set once
+# endif
+# undef  XSH_HINTS_TYPE_UV
+# define XSH_HINTS_TYPE_UV         1
+# define XSH_HINTS_TYPE_STRUCT     UV
+# define XSH_HINTS_TYPE_COMPACT    UV
+# define XSH_HINTS_NEED_STRUCT     0
+# define XSH_HINTS_VAL_STRUCT_REF  0
+# define XSH_HINTS_VAL_NONE        0
+# define XSH_HINTS_VAL_PACK(T, V)  INT2PTR(T, (V))
+# define XSH_HINTS_VAL_UNPACK(V)   ((XSH_HINTS_TYPE_VAL) PTR2UV(V))
+# define XSH_HINTS_VAL_INIT(HV, V) ((HV) = (V))
+# undef  XSH_HINTS_VAL_CLONE
+# undef  XSH_HINTS_VAL_DEINIT
+#endif
+
+#ifdef XSH_HINTS_TYPE_SV
+# ifdef XSH_HINTS_TYPE_VAL
+#  error hint type can only be set once
+# endif
+# undef  XSH_HINTS_TYPE_SV
+# define XSH_HINTS_TYPE_SV         1
+# define XSH_HINTS_TYPE_STRUCT     SV *
+# define XSH_HINTS_TYPE_COMPACT    SV
+# define XSH_HINTS_NEED_STRUCT     0
+# define XSH_HINTS_VAL_STRUCT_REF  0
+# define XSH_HINTS_VAL_NONE        NULL
+# define XSH_HINTS_VAL_PACK(T, V)  (V)
+# define XSH_HINTS_VAL_UNPACK(V)   (V)
+# define XSH_HINTS_VAL_INIT(HV, V) ((HV) = (((V) != XSH_HINTS_VAL_NONE) ? SvREFCNT_inc(V) : XSH_HINTS_VAL_NONE))
+# define XSH_HINTS_VAL_CLONE(N, O) ((N) = xsh_dup_inc((O), ud->params))
+# define XSH_HINTS_VAL_DEINIT(V)   SvREFCNT_dec(V)
+#endif
+
+#ifdef XSH_HINTS_TYPE_USER
+# ifdef XSH_HINTS_TYPE_VAL
+#  error hint type can only be set once
+# endif
+# undef  XSH_HINTS_TYPE_USER
+# define XSH_HINTS_TYPE_USER         1
+# define XSH_HINTS_TYPE_STRUCT       xsh_hints_user_t
+# undef  XSH_HINTS_TYPE_COMPACT      /* not used */
+# define XSH_HINTS_NEED_STRUCT       1
+# define XSH_HINTS_VAL_STRUCT_REF    1
+# define XSH_HINTS_VAL_NONE          NULL
+# define XSH_HINTS_VAL_PACK(T, V)    (V)
+# define XSH_HINTS_VAL_UNPACK(V)     (V)
+# define XSH_HINTS_VAL_INIT(HV, V)   xsh_hints_user_init(aTHX_ (HV), (V))
+# define XSH_HINTS_VAL_CLONE(NV, OV) xsh_hints_user_clone(aTHX_ (NV), (OV), ud->params)
+# define XSH_HINTS_VAL_DEINIT(V)     xsh_hints_user_deinit(aTHX_ (V))
+#endif
+
+#ifndef XSH_HINTS_TYPE_STRUCT
+# error hint type was not set
+#endif
+
+#if XSH_HINTS_VAL_STRUCT_REF
+# define XSH_HINTS_TYPE_VAL XSH_HINTS_TYPE_STRUCT *
+#else
+# define XSH_HINTS_TYPE_VAL XSH_HINTS_TYPE_STRUCT
+#endif
+
+#if XSH_WORKAROUND_REQUIRE_PROPAGATION
+# undef  XSH_HINTS_NEED_STRUCT
+# define XSH_HINTS_NEED_STRUCT 1
+#endif
+
+#if XSH_THREADSAFE && (defined(XSH_HINTS_VAL_CLONE) || XSH_WORKAROUND_REQUIRE_PROPAGATION)
+# define XSH_HINTS_NEED_CLONE 1
+#else
+# define XSH_HINTS_NEED_CLONE 0
+#endif
+
+#if XSH_WORKAROUND_REQUIRE_PROPAGATION
+
+static UV xsh_require_tag(pTHX) {
+#define xsh_require_tag() xsh_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 PTR2UV(cv);
+}
+
+#endif /* XSH_WORKAROUND_REQUIRE_PROPAGATION */
+
+#if XSH_HINTS_NEED_STRUCT
+
+typedef struct {
+ XSH_HINTS_TYPE_STRUCT val;
+#if XSH_WORKAROUND_REQUIRE_PROPAGATION
+ UV                    require_tag;
+#endif
+} xsh_hints_t;
+
+#if XSH_HINTS_VAL_STRUCT_REF
+# define XSH_HINTS_VAL_GET(H) (&(H)->val)
+#else
+# define XSH_HINTS_VAL_GET(H) ((H)->val)
+#endif
+
+#define XSH_HINTS_VAL_SET(H, V) XSH_HINTS_VAL_INIT(XSH_HINTS_VAL_GET(H), (V))
+
+#ifdef XSH_HINTS_VAL_DEINIT
+# define XSH_HINTS_FREE(H) \
+   if (H) XSH_HINTS_VAL_DEINIT(XSH_HINTS_VAL_GET(H)); \
+   PerlMemShared_free(H)
+#else
+# define XSH_HINTS_FREE(H) PerlMemShared_free(H)
+#endif
+
+#else  /*  XSH_HINTS_NEED_STRUCT */
+
+typedef XSH_HINTS_TYPE_COMPACT xsh_hints_t;
+
+#define XSH_HINTS_VAL_GET(H)    XSH_HINTS_VAL_UNPACK(H)
+#define XSH_HINTS_VAL_SET(H, V) STMT_START { XSH_HINTS_TYPE_VAL tmp; XSH_HINTS_VAL_INIT(tmp, (V)); (H) = XSH_HINTS_VAL_PACK(xsh_hints_t *, tmp); } STMT_END
+
+#undef XSH_HINTS_FREE
+
+#endif /* !XSH_HINTS_NEED_STRUCT */
+
+/* ... Thread safety ....................................................... */
+
+#if XSH_HINTS_NEED_CLONE
+
+#ifdef XSH_HINTS_FREE
+# define PTABLE_NAME        ptable_hints
+# define PTABLE_VAL_FREE(V) XSH_HINTS_FREE((xsh_hints_t *) (V))
+#else
+# define PTABLE_USE_DEFAULT 1
+#endif
+
+#define PTABLE_NEED_WALK    1
+#define PTABLE_NEED_DELETE  0
+
+#include "ptable.h"
+
+#if PTABLE_WAS_DEFAULT
+# define ptable_hints_store(T, K, V) ptable_default_store(aPTBL_ (T), (K), (V))
+# define ptable_hints_free(T)        ptable_default_free(aPTBL_ (T))
+#else
+# define ptable_hints_store(T, K, V) ptable_hints_store(aPTBL_ (T), (K), (V))
+# define ptable_hints_free(T)        ptable_hints_free(aPTBL_ (T))
+#endif
+
+#define XSH_THREADS_HINTS_CONTEXT 1
+
+typedef struct {
+ ptable *tbl; /* It really is a ptable_hints */
+ tTHX    owner;
+} xsh_hints_cxt_t;
+
+static xsh_hints_cxt_t *xsh_hints_get_cxt(pTHX);
+
+static void xsh_hints_local_setup(pTHX_ xsh_hints_cxt_t *cxt) {
+ cxt->tbl   = ptable_new(4);
+ cxt->owner = aTHX;
+}
+
+static void xsh_hints_local_teardown(pTHX_ xsh_hints_cxt_t *cxt) {
+ ptable_hints_free(cxt->tbl);
+ cxt->owner = NULL;
+}
+
+typedef struct {
+ ptable       *tbl; /* It really is a ptable_hints */
+ CLONE_PARAMS *params;
+} xsh_ptable_clone_ud;
+
+static void xsh_ptable_clone(pTHX_ ptable_ent *ent, void *ud_) {
+ xsh_ptable_clone_ud *ud = ud_;
+ xsh_hints_t         *h1 = ent->val;
+ xsh_hints_t         *h2;
+
+#if XSH_HINTS_NEED_STRUCT
+ h2              = PerlMemShared_malloc(sizeof *h2);
+# if XSH_WORKAROUND_REQUIRE_PROPAGATION
+ h2->require_tag = PTR2UV(xsh_dup_inc(INT2PTR(SV *, h1->require_tag), ud->params));
+# endif
+#endif  /*  XSH_HINTS_NEED_STRUCT */
+
+#ifdef XSH_HINTS_VAL_CLONE
+ XSH_HINTS_VAL_CLONE(XSH_HINTS_VAL_GET(h2), XSH_HINTS_VAL_GET(h1));
+#endif /* defined(XSH_HINTS_VAL_CLONE) */
+
+ ptable_hints_store(ud->tbl, ent->key, h2);
+}
+
+static void xsh_hints_clone(pTHX_ const xsh_hints_cxt_t *old_cxt, xsh_hints_cxt_t *new_cxt, CLONE_PARAMS *params) {
+ xsh_ptable_clone_ud ud;
+
+ new_cxt->tbl   = ptable_new(4);
+ new_cxt->owner = aTHX;
+
+ ud.tbl    = new_cxt->tbl;
+ ud.params = params;
+
+ ptable_walk(old_cxt->tbl, xsh_ptable_clone, &ud);
+}
+
+#endif /* XSH_HINTS_NEED_CLONE */
+
+/* ... tag hints ........................................................... */
+
+static SV *xsh_hints_tag(pTHX_ XSH_HINTS_TYPE_VAL val) {
+#define xsh_hints_tag(V) xsh_hints_tag(aTHX_ (V))
+ xsh_hints_t *h;
+
+ if (val == XSH_HINTS_VAL_NONE)
+  return newSVuv(0);
+
+#if XSH_HINTS_NEED_STRUCT
+ h              = PerlMemShared_malloc(sizeof *h);
+# if XSH_WORKAROUND_REQUIRE_PROPAGATION
+ h->require_tag = xsh_require_tag();
+# endif
+#endif /* XSH_HINTS_NEED_STRUCT */
+
+ XSH_HINTS_VAL_SET(h, val);
+
+#if XSH_HINTS_NEED_CLONE
+ /* 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. */
+ {
+  xsh_hints_cxt_t *cxt = xsh_hints_get_cxt(aTHX);
+  XSH_ASSERT(cxt->tbl);
+  ptable_hints_store(cxt->tbl, h, h);
+ }
+#endif /* !XSH_HINTS_NEED_CLONE */
+
+ return newSVuv(PTR2UV(h));
+}
+
+/* ... detag hints ......................................................... */
+
+#define xsh_hints_2uv(H) \
+    ((H) \
+     ? (SvIOK(H) \
+        ? SvUVX(H) \
+        : (SvPOK(H) \
+           ? sv_2uv(SvLEN(H) ? (H) : sv_mortalcopy(H)) \
+           : 0 \
+          ) \
+       ) \
+     : 0)
+
+static XSH_HINTS_TYPE_VAL xsh_hints_detag(pTHX_ SV *hint) {
+#define xsh_hints_detag(H) xsh_hints_detag(aTHX_ (H))
+ xsh_hints_t *h;
+ UV           hint_uv;
+
+ hint_uv = xsh_hints_2uv(hint);
+ h       = INT2PTR(xsh_hints_t *, hint_uv);
+ if (!h)
+  return XSH_HINTS_VAL_NONE;
+
+#if XSH_HINTS_NEED_CLONE
+ {
+  xsh_hints_cxt_t *cxt = xsh_hints_get_cxt(aTHX);
+  XSH_ASSERT(cxt->tbl);
+  h = ptable_fetch(cxt->tbl, h);
+ }
+#endif /* XSH_HINTS_NEED_CLONE */
+
+#if XSH_WORKAROUND_REQUIRE_PROPAGATION
+ if (xsh_require_tag() != h->require_tag)
+  return XSH_HINTS_VAL_NONE;
+#endif
+
+ return XSH_HINTS_VAL_GET(h);
+}
+
+/* ... fetch hints ......................................................... */
+
+#if !defined(cop_hints_fetch_pvn) && XSH_HAS_PERL(5, 9, 5)
+# define cop_hints_fetch_pvn(COP, PKG, PKGLEN, PKGHASH, FLAGS) \
+   Perl_refcounted_he_fetch(aTHX_ (COP)->cop_hints_hash, NULL, \
+                                  (PKG), (PKGLEN), (FLAGS), (PKGHASH))
+#endif
+
+#ifdef cop_hints_fetch_pvn
+
+static U32 xsh_hints_key_hash = 0;
+# define xsh_hints_global_setup(my_perl) \
+         PERL_HASH(xsh_hints_key_hash, XSH_HINTS_KEY, XSH_HINTS_KEY_LEN)
+
+#else /* defined(cop_hints_fetch_pvn) */
+
+# define xsh_hints_global_setup(my_perl)
+
+#endif /* !defined(cop_hints_fetch_pvn) */
+
+#define xsh_hints_global_teardown(my_perl)
+
+static SV *xsh_hints_fetch(pTHX) {
+#define xsh_hints_fetch() xsh_hints_fetch(aTHX)
+#if XSH_HINTS_ONLY_COMPILE_TIME
+ if (IN_PERL_RUNTIME)
+  return NULL;
+#endif
+
+#ifdef cop_hints_fetch_pvn
+ return cop_hints_fetch_pvn(PL_curcop, XSH_HINTS_KEY, XSH_HINTS_KEY_LEN,
+                                       xsh_hints_key_hash, 0);
+#else
+ {
+  SV **val = hv_fetch(GvHV(PL_hintgv), XSH_HINTS_KEY, XSH_HINTS_KEY_LEN, 0);
+  return val ? *val : NULL;
+ }
+#endif
+}
+
+#endif /* XSH_HINTS_H */
diff --git a/xsh/ops.h b/xsh/ops.h
new file mode 100644 (file)
index 0000000..2e3c06c
--- /dev/null
+++ b/xsh/ops.h
@@ -0,0 +1,83 @@
+#ifndef XSH_OPS_H
+#define XSH_OPS_H 1
+
+#include "caps.h" /* XSH_HAS_PERL() */
+#include "util.h" /* NOOP */
+
+#ifdef XSH_THREADS_H
+# error threads.h must be loaded at the very end
+#endif
+
+#ifndef XSH_THREADS_GLOBAL_SETUP
+# define XSH_THREADS_GLOBAL_SETUP 1
+#endif
+
+#ifndef XSH_THREADS_GLOBAL_TEARDOWN
+# define XSH_THREADS_GLOBAL_TEARDOWN 1
+#endif
+
+#ifndef OpSIBLING
+# ifdef OP_SIBLING
+#  define OpSIBLING(O) OP_SIBLING(O)
+# else
+#  define OpSIBLING(O) ((O)->op_sibling)
+# endif
+#endif
+
+#ifndef OpMAYBESIB_set
+# define OpMAYBESIB_set(O, S, P) ((O)->op_sibling = (S))
+#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
+
+#if defined(OP_CHECK_MUTEX_LOCK) && defined(OP_CHECK_MUTEX_UNLOCK)
+# define XSH_CHECK_LOCK   OP_CHECK_MUTEX_LOCK
+# define XSH_CHECK_UNLOCK OP_CHECK_MUTEX_UNLOCK
+#elif XSH_HAS_PERL(5, 9, 3)
+# define XSH_CHECK_LOCK   OP_REFCNT_LOCK
+# define XSH_CHECK_UNLOCK OP_REFCNT_UNLOCK
+#else
+/* Before perl 5.9.3, da_ck_*() calls are already protected by the XSH_LOADED
+ * mutex, which falls back to the OP_REFCNT mutex. Make sure we don't lock it
+ * twice. */
+# define XSH_CHECK_LOCK   NOOP
+# define XSH_CHECK_UNLOCK NOOP
+#endif
+
+typedef OP *(*xsh_check_t)(pTHX_ OP *);
+
+#ifdef wrap_op_checker
+
+# define xsh_ck_replace(T, NC, OCP) wrap_op_checker((T), (NC), (OCP))
+
+#else
+
+static void xsh_ck_replace(pTHX_ OPCODE type, xsh_check_t new_ck, xsh_check_t *old_ck_p) {
+#define xsh_ck_replace(T, NC, OCP) xsh_ck_replace(aTHX_ (T), (NC), (OCP))
+ XSH_CHECK_LOCK;
+ if (!*old_ck_p) {
+  *old_ck_p      = PL_check[type];
+  PL_check[type] = new_ck;
+ }
+ XSH_CHECK_UNLOCK;
+}
+
+#endif
+
+static void xsh_ck_restore(pTHX_ OPCODE type, xsh_check_t *old_ck_p) {
+#define xsh_ck_restore(T, OCP) xsh_ck_restore(aTHX_ (T), (OCP))
+ XSH_CHECK_LOCK;
+ if (*old_ck_p) {
+  PL_check[type] = *old_ck_p;
+  *old_ck_p      = 0;
+ }
+ XSH_CHECK_UNLOCK;
+}
+
+#endif /* XSH_OPS_H */
diff --git a/xsh/ptable.h b/xsh/ptable.h
new file mode 100644 (file)
index 0000000..af2e168
--- /dev/null
@@ -0,0 +1,466 @@
+/* This is a pointer table implementation essentially copied from the ptr_table
+ * implementation in perl's sv.c, except that it has been modified to use memory
+ * shared across threads.
+ * Copyright goes to the original authors, bug reports to me. */
+
+/* This header is designed to be included several times with different
+ * definitions for PTABLE_NAME and PTABLE_VAL_ALLOC/FREE(). */
+
+#include "util.h" /* VOID2(), XSH_ASSERT(), xPMS */
+
+/* --- Configuration ------------------------------------------------------- */
+
+#ifndef PTABLE_USE_DEFAULT
+# define PTABLE_USE_DEFAULT 0
+#endif
+
+#if PTABLE_USE_DEFAULT
+# if defined(PTABLE_VAL_ALLOC) || defined(PTABLE_VAL_FREE)
+#  error the default ptable is only available when PTABLE_VAL_ALLOC/FREE are unset
+# endif
+# undef  PTABLE_NAME
+# define PTABLE_NAME ptable_default
+# undef  PTABLE_VAL_NEED_CONTEXT
+# define PTABLE_VAL_NEED_CONTEXT 0
+#else
+# ifndef PTABLE_NAME
+#  error PTABLE_NAME must be defined
+# endif
+# ifndef PTABLE_VAL_NEED_CONTEXT
+#  define PTABLE_VAL_NEED_CONTEXT 1
+# endif
+#endif
+
+#ifndef PTABLE_JOIN
+# define PTABLE_PASTE(A, B) A ## B
+# define PTABLE_JOIN(A, B)  PTABLE_PASTE(A, B)
+#endif
+
+#ifndef PTABLE_PREFIX
+# define PTABLE_PREFIX(X) PTABLE_JOIN(PTABLE_NAME, X)
+#endif
+
+#ifndef PTABLE_NEED_SPLICE
+# define PTABLE_NEED_SPLICE 0
+#endif
+
+#ifndef PTABLE_NEED_WALK
+# define PTABLE_NEED_WALK 0
+#endif
+
+#ifndef PTABLE_NEED_STORE
+# define PTABLE_NEED_STORE 1
+#endif
+
+#ifndef PTABLE_NEED_VIVIFY
+# define PTABLE_NEED_VIVIFY 0
+#elif PTABLE_NEED_VIVIFY
+# undef  PTABLE_NEED_VIVIFY
+# ifndef PTABLE_VAL_ALLOC
+#  error need to define PTABLE_VAL_ALLOC() to use ptable_vivify()
+# endif
+# define PTABLE_NEED_VIVIFY 1
+#endif
+
+#ifndef PTABLE_NEED_DELETE
+# define PTABLE_NEED_DELETE 1
+#endif
+
+#ifndef PTABLE_NEED_CLEAR
+# define PTABLE_NEED_CLEAR 1
+#endif
+
+#undef PTABLE_NEED_ENT_VIVIFY
+#if PTABLE_NEED_SPLICE || PTABLE_NEED_STORE || PTABLE_NEED_VIVIFY
+# define PTABLE_NEED_ENT_VIVIFY 1
+#else
+# define PTABLE_NEED_ENT_VIVIFY 0
+#endif
+
+#undef PTABLE_NEED_ENT_DETACH
+#if PTABLE_NEED_SPLICE || PTABLE_NEED_DELETE
+# define PTABLE_NEED_ENT_DETACH 1
+#else
+# define PTABLE_NEED_ENT_DETACH 0
+#endif
+
+/* ... Context for ptable_*() functions calling PTABLE_VAL_ALLOC/FREE() .... */
+
+#undef pPTBL
+#undef pPTBL_
+#undef aPTBL
+#undef aPTBL_
+
+#if PTABLE_VAL_NEED_CONTEXT
+# define pPTBL  pTHX
+# define pPTBL_ pTHX_
+# define aPTBL  aTHX
+# define aPTBL_ aTHX_
+#else
+# define pPTBL  pPMS
+# define pPTBL_ pPMS_
+# define aPTBL  aPMS
+# define aPTBL_ aPMS_
+#endif
+
+/* --- <ptable> struct ----------------------------------------------------- */
+
+#ifndef ptable_ent
+typedef struct ptable_ent {
+ struct ptable_ent *next;
+ const void *       key;
+ void *             val;
+} ptable_ent;
+#define ptable_ent ptable_ent
+#endif /* !ptable_ent */
+
+#ifndef ptable
+typedef struct ptable {
+ ptable_ent **ary;
+ size_t       max;
+ size_t       items;
+} ptable;
+#define ptable ptable
+#endif /* !ptable */
+
+/* --- Private interface --------------------------------------------------- */
+
+#ifndef PTABLE_HASH
+# define PTABLE_HASH(ptr) \
+     ((PTR2UV(ptr) >> 3) ^ (PTR2UV(ptr) >> (3 + 7)) ^ (PTR2UV(ptr) >> (3 + 17)))
+#endif
+
+#ifndef ptable_bucket
+# define ptable_bucket(T, K) (PTABLE_HASH(K) & (T)->max)
+#endif
+
+#ifndef ptable_ent_find
+static ptable_ent *ptable_ent_find(const ptable *t, const void *key) {
+#define ptable_ent_find ptable_ent_find
+ ptable_ent  *ent;
+ const size_t idx = ptable_bucket(t, key);
+
+ ent = t->ary[idx];
+ for (; ent; ent = ent->next) {
+  if (ent->key == key)
+   return ent;
+ }
+
+ return NULL;
+}
+#endif /* !ptable_ent_find */
+
+#if PTABLE_NEED_ENT_VIVIFY
+
+#ifndef ptable_split
+static void ptable_split(pPMS_ ptable *t) {
+#define ptable_split(T) ptable_split(aPMS_ (T))
+ ptable_ent      **ary = t->ary;
+ const size_t old_size = t->max + 1;
+ size_t       new_size = old_size * 2;
+ size_t       i;
+
+ ary = VOID2(ptable_ent **,
+             PerlMemShared_realloc(ary, new_size * sizeof *ary));
+ Zero(ary + old_size, new_size - old_size, sizeof *ary);
+ t->max = --new_size;
+ t->ary = ary;
+
+ for (i = 0; i < old_size; i++, ary++) {
+  ptable_ent **curentp, **entp, *ent;
+
+  ent = *ary;
+  if (!ent)
+   continue;
+  entp    = ary;
+  curentp = ary + old_size;
+
+  do {
+   if ((new_size & PTABLE_HASH(ent->key)) != i) {
+    *entp     = ent->next;
+    ent->next = *curentp;
+    *curentp  = ent;
+   } else {
+    entp = &ent->next;
+   }
+   ent = *entp;
+  } while (ent);
+ }
+}
+#endif /* !ptable_split */
+
+#ifndef ptable_ent_vivify
+static ptable_ent *ptable_ent_vivify(pPMS_ ptable *t, const void *key) {
+#define ptable_ent_vivify(T, K) ptable_ent_vivify(aPMS_ (T), (K))
+ ptable_ent  *ent;
+ const size_t idx = ptable_bucket(t, key);
+
+ ent = t->ary[idx];
+ for (; ent; ent = ent->next) {
+  if (ent->key == key)
+   return ent;
+ }
+
+ ent = VOID2(ptable_ent *, PerlMemShared_malloc(sizeof *ent));
+
+ ent->key    = key;
+ ent->val    = NULL;
+ ent->next   = t->ary[idx];
+ t->ary[idx] = ent;
+
+ t->items++;
+ if (ent->next && t->items > t->max)
+  ptable_split(t);
+
+ return ent;
+}
+#endif /* !ptable_ent_vivify */
+
+#endif /* PTABLE_NEED_ENT_VIVIFY */
+
+#if PTABLE_NEED_ENT_DETACH
+
+#ifndef ptable_ent_detach
+static ptable_ent *ptable_ent_detach(ptable *t, const void *key) {
+#define ptable_ent_detach ptable_ent_detach
+ ptable_ent  *prev, *ent;
+ const size_t idx = ptable_bucket(t, key);
+
+ prev = NULL;
+ ent  = t->ary[idx];
+ for (; ent; prev = ent, ent = ent->next) {
+  if (ent->key == key) {
+   if (prev)
+    prev->next  = ent->next;
+   else
+    t->ary[idx] = ent->next;
+   break;
+  }
+ }
+
+ return ent;
+}
+#endif /* !ptable_ent_detach */
+
+#endif /* PTABLE_NEED_ENT_DETACH */
+
+/* --- Public interface ---------------------------------------------------- */
+
+/* ... Common symbols ...................................................... */
+
+#ifndef ptable_new
+static ptable *ptable_new(pPMS_ size_t init_buckets) {
+#define ptable_new(B) ptable_new(aPMS_ (B))
+ ptable *t;
+
+ if (init_buckets < 4) {
+  init_buckets = 4;
+ } else {
+  init_buckets--;
+  init_buckets |= init_buckets >> 1;
+  init_buckets |= init_buckets >> 2;
+  init_buckets |= init_buckets >> 4;
+  init_buckets |= init_buckets >> 8;
+  init_buckets |= init_buckets >> 16;
+  if (sizeof(init_buckets) > 4)
+   init_buckets |= init_buckets >> 32;
+  init_buckets++;
+ }
+
+ XSH_ASSERT(init_buckets >= 4 && ((init_buckets & (init_buckets - 1)) == 0));
+
+ t        = VOID2(ptable *, PerlMemShared_malloc(sizeof *t));
+ t->max   = init_buckets - 1;
+ t->items = 0;
+ t->ary   = VOID2(ptable_ent **,
+                              PerlMemShared_calloc(t->max + 1, sizeof *t->ary));
+ return t;
+}
+#endif /* !ptable_new */
+
+#ifndef ptable_fetch
+static void *ptable_fetch(const ptable *t, const void *key) {
+#define ptable_fetch ptable_fetch
+ const ptable_ent *ent = ptable_ent_find(t, key);
+
+ return ent ? ent->val : NULL;
+}
+#endif /* !ptable_fetch */
+
+#if PTABLE_NEED_SPLICE
+
+#ifndef ptable_splice
+static void *ptable_splice(pPMS_ ptable *t, const void *key, void *new_val) {
+#define ptable_splice(T, K, V) ptable_splice(aPMS_ (T), (K), (V))
+ ptable_ent *ent;
+ void       *old_val = NULL;
+
+ if (new_val) {
+  ent      = ptable_ent_vivify(t, key);
+  old_val  = ent->val;
+  ent->val = new_val;
+ } else {
+  ent = ptable_ent_detach(t, key);
+  if (ent) {
+   old_val = ent->val;
+   PerlMemShared_free(ent);
+  }
+ }
+
+ return old_val;
+}
+#endif /* !ptable_splice */
+
+#endif /* PTABLE_NEED_SPLICE */
+
+#if PTABLE_NEED_WALK
+
+#ifndef ptable_walk
+static void ptable_walk(pTHX_ ptable *t, void (*cb)(pTHX_ ptable_ent *ent, void *userdata), void *userdata) {
+#define ptable_walk(T, CB, UD) ptable_walk(aTHX_ (T), (CB), (UD))
+ if (t && t->items) {
+  register ptable_ent **array = t->ary;
+  size_t i = t->max;
+  do {
+   ptable_ent *entry;
+   for (entry = array[i]; entry; entry = entry->next)
+    if (entry->val)
+     cb(aTHX_ entry, userdata);
+  } while (i--);
+ }
+}
+#endif /* !ptable_walk */
+
+#endif /* PTABLE_NEED_WALK */
+
+/* ... Specialized symbols ................................................. */
+
+#if PTABLE_NEED_STORE
+
+#if !PTABLE_USE_DEFAULT || !defined(ptable_default_store)
+static void PTABLE_PREFIX(_store)(pPTBL_ ptable *t, const void *key, void *val){
+ ptable_ent *ent = ptable_ent_vivify(t, key);
+
+#ifdef PTABLE_VAL_FREE
+ PTABLE_VAL_FREE(ent->val);
+#endif
+
+ ent->val = val;
+
+ return;
+}
+# if PTABLE_USE_DEFAULT
+#  define ptable_default_store ptable_default_store
+# endif
+#endif /* !PTABLE_USE_DEFAULT || !defined(ptable_default_store) */
+
+#endif /* PTABLE_NEED_STORE */
+
+#if PTABLE_NEED_VIVIFY
+
+#if !PTABLE_USE_DEFAULT || !defined(ptable_default_vivify)
+static void *PTABLE_PREFIX(_vivify)(pPTBL_ ptable *t, const void *key) {
+ ptable_ent *ent = ptable_ent_vivify(t, key);
+
+ if (!ent->val) {
+  PTABLE_VAL_ALLOC(ent->val);
+ }
+
+ return ent->val;
+}
+# if PTABLE_USE_DEFAULT
+#  define ptable_default_vivify ptable_default_vivify
+# endif
+#endif /* !PTABLE_USE_DEFAULT || !defined(ptable_default_vivify) */
+
+#endif /* PTABLE_NEED_VIVIFY */
+
+#if PTABLE_NEED_DELETE
+
+#if !PTABLE_USE_DEFAULT || !defined(ptable_default_delete)
+static void PTABLE_PREFIX(_delete)(pPTBL_ ptable *t, const void *key) {
+ ptable_ent *ent = ptable_ent_detach(t, key);
+
+#ifdef PTABLE_VAL_FREE
+ if (ent) {
+  PTABLE_VAL_FREE(ent->val);
+ }
+#endif
+
+ PerlMemShared_free(ent);
+}
+# if PTABLE_USE_DEFAULT
+#  define ptable_default_delete ptable_default_delete
+# endif
+#endif /* !PTABLE_USE_DEFAULT || !defined(ptable_default_delete) */
+
+#endif /* PTABLE_NEED_DELETE */
+
+#if PTABLE_NEED_CLEAR
+
+#if !PTABLE_USE_DEFAULT || !defined(ptable_default_clear)
+static void PTABLE_PREFIX(_clear)(pPTBL_ ptable *t) {
+ if (t && t->items) {
+  register ptable_ent **array = t->ary;
+  size_t idx = t->max;
+
+  do {
+   ptable_ent *entry = array[idx];
+   while (entry) {
+    ptable_ent *nentry = entry->next;
+#ifdef PTABLE_VAL_FREE
+    PTABLE_VAL_FREE(entry->val);
+#endif
+    PerlMemShared_free(entry);
+    entry = nentry;
+   }
+   array[idx] = NULL;
+  } while (idx--);
+
+  t->items = 0;
+ }
+}
+# if PTABLE_USE_DEFAULT
+#  define ptable_default_clear ptable_default_clear
+# endif
+#endif /* !PTABLE_USE_DEFAULT || !defined(ptable_default_clear) */
+
+#endif /* PTABLE_NEED_CLEAR */
+
+#if !PTABLE_USE_DEFAULT || !defined(ptable_default_free)
+static void PTABLE_PREFIX(_free)(pPTBL_ ptable *t) {
+ if (!t)
+  return;
+ PTABLE_PREFIX(_clear)(aPTBL_ t);
+ PerlMemShared_free(t->ary);
+ PerlMemShared_free(t);
+}
+# if PTABLE_USE_DEFAULT
+#  define ptable_default_free ptable_default_free
+# endif
+#endif /* !PTABLE_USE_DEFAULT || !defined(ptable_default_free) */
+
+/* --- Cleanup ------------------------------------------------------------- */
+
+#undef PTABLE_WAS_DEFAULT
+#if PTABLE_USE_DEFAULT
+# define PTABLE_WAS_DEFAULT 1
+#else
+# define PTABLE_WAS_DEFAULT 0
+#endif
+
+#undef PTABLE_NAME
+#undef PTABLE_VAL_ALLOC
+#undef PTABLE_VAL_FREE
+#undef PTABLE_VAL_NEED_CONTEXT
+#undef PTABLE_USE_DEFAULT
+
+#undef PTABLE_NEED_SPLICE
+#undef PTABLE_NEED_WALK
+#undef PTABLE_NEED_STORE
+#undef PTABLE_NEED_VIVIFY
+#undef PTABLE_NEED_DELETE
+#undef PTABLE_NEED_CLEAR
+
+#undef PTABLE_NEED_ENT_VIVIFY
+#undef PTABLE_NEED_ENT_DETACH
diff --git a/xsh/threads.h b/xsh/threads.h
new file mode 100644 (file)
index 0000000..b72c63b
--- /dev/null
@@ -0,0 +1,501 @@
+#ifndef XSH_THREADS_H
+#define XSH_THREADS_H 1
+
+#include "caps.h" /* XSH_HAS_PERL(), XSH_THREADSAFE */
+#include "util.h" /* XSH_PACKAGE, dNOOP, NOOP */
+
+#ifndef XSH_THREADS_COMPILE_TIME_PROTECTION
+# define XSH_THREADS_COMPILE_TIME_PROTECTION 0
+#endif
+
+#ifndef XSH_THREADS_USER_CONTEXT
+# define XSH_THREADS_USER_CONTEXT 1
+#endif
+
+#ifndef XSH_THREADS_USER_GLOBAL_SETUP
+# define XSH_THREADS_USER_GLOBAL_SETUP 1
+#endif
+
+#ifndef XSH_THREADS_USER_LOCAL_SETUP
+# define XSH_THREADS_USER_LOCAL_SETUP 1
+#endif
+
+#ifndef XSH_THREADS_USER_LOCAL_TEARDOWN
+# define XSH_THREADS_USER_LOCAL_TEARDOWN 1
+#endif
+
+#ifndef XSH_THREADS_USER_GLOBAL_TEARDOWN
+# define XSH_THREADS_USER_GLOBAL_TEARDOWN 1
+#endif
+
+#ifndef XSH_THREADS_PEEP_CONTEXT
+# define XSH_THREADS_PEEP_CONTEXT 0
+#endif
+
+#ifndef XSH_THREADS_HINTS_CONTEXT
+# define XSH_THREADS_HINTS_CONTEXT 0
+#endif
+
+#ifndef XSH_THREADS_USER_CLONE_NEEDS_DUP
+# define XSH_THREADS_USER_CLONE_NEEDS_DUP 0
+#endif
+
+#if XSH_THREADSAFE && (XSH_THREADS_HINTS_CONTEXT || XSH_THREADS_USER_CLONE_NEEDS_DUP)
+# define XSH_THREADS_CLONE_NEEDS_DUP 1
+#else
+# define XSH_THREADS_CLONE_NEEDS_DUP 0
+#endif
+
+#if defined(XSH_OPS_H) && (!XSH_THREADS_GLOBAL_SETUP || !XSH_THREADS_GLOBAL_TEARDOWN)
+# error settting up hook check functions require global setup/teardown
+#endif
+
+#ifndef XSH_THREADS_NEED_TEARDOWN_LATE
+# define XSH_THREADS_NEED_TEARDOWN_LATE 0
+#endif
+
+#if XSH_THREADS_NEED_TEARDOWN_LATE && (!XSH_THREADS_USER_LOCAL_TEARDOWN || !XSH_THREADS_USER_GLOBAL_TEARDOWN)
+# error you need to declare local or global teardown handlers to use the late teardown feature
+#endif
+
+#if XSH_THREADSAFE
+# ifndef MY_CXT_CLONE
+#  define MY_CXT_CLONE \
+    dMY_CXT_SV;                                                      \
+    my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1)); \
+    Copy(INT2PTR(my_cxt_t*, SvUV(my_cxt_sv)), my_cxtp, 1, my_cxt_t); \
+    sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))
+# endif
+#else
+# undef  dMY_CXT
+# define dMY_CXT      dNOOP
+# undef  MY_CXT
+# define MY_CXT       xsh_globaldata
+# undef  START_MY_CXT
+# define START_MY_CXT static my_cxt_t MY_CXT;
+# undef  MY_CXT_INIT
+# define MY_CXT_INIT  NOOP
+# undef  MY_CXT_CLONE
+# define MY_CXT_CLONE NOOP
+#endif
+
+#if XSH_THREADSAFE
+/* We must use preexistent global mutexes or we will never be able to destroy
+ * them. */
+# if XSH_HAS_PERL(5, 9, 3)
+#  define XSH_LOADED_LOCK   MUTEX_LOCK(&PL_my_ctx_mutex)
+#  define XSH_LOADED_UNLOCK MUTEX_UNLOCK(&PL_my_ctx_mutex)
+# else
+#  define XSH_LOADED_LOCK   OP_REFCNT_LOCK
+#  define XSH_LOADED_UNLOCK OP_REFCNT_UNLOCK
+# endif
+#else
+# define XSH_LOADED_LOCK   NOOP
+# define XSH_LOADED_UNLOCK NOOP
+#endif
+
+static I32 xsh_loaded = 0;
+
+#if XSH_THREADSAFE && XSH_THREADS_COMPILE_TIME_PROTECTION
+
+#define PTABLE_USE_DEFAULT 1
+
+#include "ptable.h"
+
+#define ptable_loaded_store(T, K, V) ptable_default_store(aPTBL_ (T), (K), (V))
+#define ptable_loaded_delete(T, K)   ptable_default_delete(aPTBL_ (T), (K))
+#define ptable_loaded_free(T)        ptable_default_free(aPTBL_ (T))
+
+static ptable *xsh_loaded_cxts = NULL;
+
+static int xsh_is_loaded(pTHX_ void *cxt) {
+#define xsh_is_loaded(C) xsh_is_loaded(aTHX_ (C))
+ int res = 0;
+
+ XSH_LOADED_LOCK;
+ if (xsh_loaded_cxts && ptable_fetch(xsh_loaded_cxts, cxt))
+  res = 1;
+ XSH_LOADED_UNLOCK;
+
+ return res;
+}
+
+static int xsh_set_loaded_locked(pTHX_ void *cxt) {
+#define xsh_set_loaded_locked(C) xsh_set_loaded_locked(aTHX_ (C))
+ int global_setup = 0;
+
+ if (xsh_loaded <= 0) {
+  XSH_ASSERT(xsh_loaded == 0);
+  XSH_ASSERT(!xsh_loaded_cxts);
+  xsh_loaded_cxts = ptable_new(4);
+  global_setup   = 1;
+ }
+ ++xsh_loaded;
+ XSH_ASSERT(xsh_loaded_cxts);
+ ptable_loaded_store(xsh_loaded_cxts, cxt, cxt);
+
+ return global_setup;
+}
+
+static int xsh_clear_loaded_locked(pTHX_ void *cxt) {
+#define xsh_clear_loaded_locked(C) xsh_clear_loaded_locked(aTHX_ (C))
+ int global_teardown = 0;
+
+ if (xsh_loaded > 1) {
+  XSH_ASSERT(xsh_loaded_cxts);
+  ptable_loaded_delete(xsh_loaded_cxts, cxt);
+  --xsh_loaded;
+ } else if (xsh_loaded_cxts) {
+  XSH_ASSERT(xsh_loaded == 1);
+  ptable_loaded_free(xsh_loaded_cxts);
+  xsh_loaded_cxts = NULL;
+  xsh_loaded      = 0;
+  global_teardown = 1;
+ }
+
+ return global_teardown;
+}
+
+#else  /*  XSH_THREADS_COMPILE_TIME_PROTECTION */
+
+#define xsh_is_loaded_locked(C)    (xsh_loaded > 0)
+#define xsh_set_loaded_locked(C)   ((xsh_loaded++ <= 0) ? 1 : 0)
+#define xsh_clear_loaded_locked(C) ((--xsh_loaded <= 0) ? 1 : 0)
+
+#if XSH_THREADSAFE
+
+static int xsh_is_loaded(pTHX_ void *cxt) {
+#define xsh_is_loaded(C) xsh_is_loaded(aTHX_ (C))
+ int res = 0;
+
+ XSH_LOADED_LOCK;
+ res = xsh_is_loaded_locked(cxt);
+ XSH_LOADED_UNLOCK;
+
+ return res;
+}
+
+#else
+
+#define xsh_is_loaded(C) xsh_is_loaded_locked(C)
+
+#endif
+
+#endif /* !XSH_THREADS_COMPILE_TIME_PROTECTION */
+
+#define MY_CXT_KEY XSH_PACKAGE "::_guts" XS_VERSION
+
+typedef struct {
+#if XSH_THREADS_USER_CONTEXT
+ xsh_user_cxt_t  cxt_user;
+#endif
+#if XSH_THREADS_PEEP_CONTEXT
+ xsh_peep_cxt_t  cxt_peep;
+#endif
+#if XSH_THREADS_HINTS_CONTEXT
+ xsh_hints_cxt_t cxt_hints;
+#endif
+#if XSH_THREADS_CLONE_NEEDS_DUP
+ tTHX            owner;
+#endif
+#if !(XSH_THREADS_USER_CONTEXT || XSH_THREADS_PEEP_CONTEXT || XSH_THREADS_HINTS_CONTEXT || XSH_THREADS_CLONE_NEEDS_DUP)
+ int             dummy;
+#endif
+} my_cxt_t;
+
+START_MY_CXT
+
+#if XSH_THREADS_USER_CONTEXT
+# define dXSH_CXT dMY_CXT
+# define XSH_CXT  (MY_CXT.cxt_user)
+#endif
+
+#if XSH_THREADS_USER_GLOBAL_SETUP
+static void xsh_user_global_setup(pTHX);
+#endif
+
+#if XSH_THREADS_USER_LOCAL_SETUP
+# if XSH_THREADS_USER_CONTEXT
+static void xsh_user_local_setup(pTHX_ xsh_user_cxt_t *cxt);
+# else
+static void xsh_user_local_setup(pTHX);
+# endif
+#endif
+
+#if XSH_THREADS_USER_LOCAL_TEARDOWN
+# if XSH_THREADS_USER_CONTEXT
+static void xsh_user_local_teardown(pTHX_ xsh_user_cxt_t *cxt);
+# else
+static void xsh_user_local_teardown(pTHX);
+# endif
+#endif
+
+#if XSH_THREADS_USER_GLOBAL_TEARDOWN
+static void xsh_user_global_teardown(pTHX);
+#endif
+
+#if XSH_THREADSAFE && XSH_THREADS_USER_CONTEXT
+# if XSH_THREADS_USER_CLONE_NEEDS_DUP
+static void xsh_user_clone(pTHX_ const xsh_user_cxt_t *old_cxt, xsh_user_cxt_t *new_cxt, CLONE_PARAMS *params);
+# else
+static void xsh_user_clone(pTHX_ const xsh_user_cxt_t *old_cxt, xsh_user_cxt_t *new_cxt);
+# endif
+#endif
+
+#if XSH_THREADS_PEEP_CONTEXT
+static xsh_peep_cxt_t *xsh_peep_get_cxt(pTHX) {
+ dMY_CXT;
+ XSH_ASSERT(xsh_is_loaded(&MY_CXT));
+ return &MY_CXT.cxt_peep;
+}
+#endif
+
+#if XSH_THREADS_HINTS_CONTEXT
+static xsh_hints_cxt_t *xsh_hints_get_cxt(pTHX) {
+ dMY_CXT;
+ XSH_ASSERT(xsh_is_loaded(&MY_CXT));
+ return &MY_CXT.cxt_hints;
+}
+#endif
+
+#if XSH_THREADS_NEED_TEARDOWN_LATE
+
+typedef void (*xsh_teardown_late_cb)(pTHX_ void *ud);
+
+static int xsh_teardown_late_simple_free(pTHX_ SV *sv, MAGIC *mg) {
+ xsh_teardown_late_cb cb;
+
+ cb = DPTR2FPTR(xsh_teardown_late_cb, mg->mg_ptr);
+
+ XSH_LOADED_LOCK;
+ if (xsh_loaded == 0)
+  cb(aTHX_ NULL);
+ XSH_LOADED_UNLOCK;
+
+ return 0;
+}
+
+static MGVTBL xsh_teardown_late_simple_vtbl = {
+ 0,
+ 0,
+ 0,
+ 0,
+ xsh_teardown_late_simple_free
+#if MGf_COPY
+ , 0
+#endif
+#if MGf_DUP
+ , 0
+#endif
+#if MGf_LOCAL
+ , 0
+#endif
+};
+
+typedef struct {
+ xsh_teardown_late_cb  cb;
+ void                 *ud;
+} xsh_teardown_late_token;
+
+static int xsh_teardown_late_arg_free(pTHX_ SV *sv, MAGIC *mg) {
+ xsh_teardown_late_token *tok;
+
+ tok = (xsh_teardown_late_token *) mg->mg_ptr;
+
+ XSH_LOADED_LOCK;
+ if (xsh_loaded == 0)
+  tok->cb(aTHX_ tok->ud);
+ XSH_LOADED_UNLOCK;
+
+ PerlMemShared_free(tok);
+
+ return 0;
+}
+
+static MGVTBL xsh_teardown_late_arg_vtbl = {
+ 0,
+ 0,
+ 0,
+ 0,
+ xsh_teardown_late_arg_free
+#if MGf_COPY
+ , 0
+#endif
+#if MGf_DUP
+ , 0
+#endif
+#if MGf_LOCAL
+ , 0
+#endif
+};
+
+static void xsh_teardown_late_register(pTHX_ xsh_teardown_late_cb cb, void *ud){
+#define xsh_teardown_late_register(CB, UD) xsh_teardown_late_register(aTHX_ (CB), (UD))
+ void *ptr;
+
+ if (!ud) {
+  ptr = FPTR2DPTR(void *, cb);
+ } else {
+  xsh_teardown_late_token *tok;
+
+  tok     = PerlMemShared_malloc(sizeof *tok);
+  tok->cb = cb;
+  tok->ud = ud;
+
+  ptr = tok;
+ }
+
+ if (!PL_strtab)
+  PL_strtab = newHV();
+
+ sv_magicext((SV *) PL_strtab, NULL, PERL_MAGIC_ext,
+             ud ? &xsh_teardown_late_arg_vtbl : &xsh_teardown_late_simple_vtbl,
+             ptr, 0);
+
+ return;
+}
+
+#endif /* XSH_THREADS_NEED_TEARDOWN_LATE */
+
+static void xsh_teardown(pTHX_ void *root) {
+ dMY_CXT;
+
+#if XSH_THREADS_USER_LOCAL_TEARDOWN
+# if XSH_THREADS_USER_CONTEXT
+ xsh_user_local_teardown(aTHX_ &XSH_CXT);
+# else
+ xsh_user_local_teardown(aTHX);
+# endif
+#endif
+
+#if XSH_THREADS_PEEP_CONTEXT
+ xsh_peep_local_teardown(aTHX_ &MY_CXT.cxt_peep);
+#endif
+
+#if XSH_THREADS_HINTS_CONTEXT
+ xsh_hints_local_teardown(aTHX_ &MY_CXT.cxt_hints);
+#endif
+
+ XSH_LOADED_LOCK;
+
+ if (xsh_clear_loaded_locked(&MY_CXT)) {
+#if XSH_THREADS_USER_GLOBAL_TEARDOWN
+  xsh_user_global_teardown(aTHX);
+#endif
+
+#if XSH_THREADS_HINTS_CONTEXT
+  xsh_hints_global_teardown(aTHX);
+#endif
+ }
+
+ XSH_LOADED_UNLOCK;
+
+ return;
+}
+
+static void xsh_setup(pTHX) {
+#define xsh_setup() xsh_setup(aTHX)
+ MY_CXT_INIT; /* Takes/release PL_my_ctx_mutex */
+
+ XSH_LOADED_LOCK;
+
+ if (xsh_set_loaded_locked(&MY_CXT)) {
+#if XSH_THREADS_HINTS_CONTEXT
+  xsh_hints_global_setup(aTHX);
+#endif
+
+#if XSH_THREADS_USER_GLOBAL_SETUP
+  xsh_user_global_setup(aTHX);
+#endif
+ }
+
+ XSH_LOADED_UNLOCK;
+
+#if XSH_THREADS_CLONE_NEEDS_DUP
+ MY_CXT.owner = aTHX;
+#endif
+
+#if XSH_THREADS_HINTS_CONTEXT
+ xsh_hints_local_setup(aTHX_ &MY_CXT.cxt_hints);
+#endif
+
+#if XSH_THREADS_PEEP_CONTEXT
+ xsh_peep_local_setup(aTHX_ &MY_CXT.cxt_peep);
+#endif
+
+#if XSH_THREADS_USER_LOCAL_SETUP
+# if XSH_THREADS_USER_CONTEXT
+ xsh_user_local_setup(aTHX_ &XSH_CXT);
+# else
+ xsh_user_local_setup(aTHX);
+# endif
+#endif
+
+ call_atexit(xsh_teardown, NULL);
+
+ return;
+}
+
+#if XSH_THREADSAFE
+
+static void xsh_clone(pTHX) {
+#define xsh_clone() xsh_clone(aTHX)
+ const my_cxt_t *old_cxt;
+ my_cxt_t       *new_cxt;
+
+ {
+  dMY_CXT;
+  old_cxt = &MY_CXT;
+ }
+
+ {
+  int global_setup;
+
+  MY_CXT_CLONE;
+  new_cxt = &MY_CXT;
+
+  XSH_LOADED_LOCK;
+  global_setup = xsh_set_loaded_locked(new_cxt);
+  XSH_ASSERT(!global_setup);
+  XSH_LOADED_UNLOCK;
+
+#if XSH_THREADS_CLONE_NEEDS_DUP
+  new_cxt->owner = aTHX;
+#endif
+ }
+
+ {
+#if XSH_THREADS_CLONE_NEEDS_DUP
+  XSH_DUP_PARAMS_TYPE params;
+  xsh_dup_params_init(params, old_cxt->owner);
+#endif
+
+#if XSH_THREADS_PEEP_CONTEXT
+  xsh_peep_clone(aTHX_ &old_cxt->cxt_peep, &new_cxt->cxt_peep);
+#endif
+
+#if XSH_THREADS_HINTS_CONTEXT
+  xsh_hints_clone(aTHX_ &old_cxt->cxt_hints, &new_cxt->cxt_hints,
+                        xsh_dup_params_ptr(params));
+#endif
+
+#if XSH_THREADS_USER_CONTEXT
+# if XSH_THREADS_USER_CLONE_NEEDS_DUP
+  xsh_user_clone(aTHX_ &old_cxt->cxt_user, &new_cxt->cxt_user,
+                       xsh_dup_params_ptr(params));
+# else
+  xsh_user_clone(aTHX_ &old_cxt->cxt_user, &new_cxt->cxt_user);
+# endif
+#endif
+
+#if XSH_THREADS_CLONE_NEEDS_DUP
+  xsh_dup_params_deinit(params);
+#endif
+ }
+
+ return;
+}
+
+#endif /* XSH_THREADSAFE */
+
+#endif /* XSH_THREADS_H */
diff --git a/xsh/util.h b/xsh/util.h
new file mode 100644 (file)
index 0000000..dcc142c
--- /dev/null
@@ -0,0 +1,97 @@
+#ifndef XSH_UTIL_H
+#define XSH_UTIL_H 1
+
+#include "caps.h" /* XSH_HAS_PERL() */
+
+#ifndef XSH_PACKAGE
+# error XSH_PACKAGE must be defined
+#endif
+
+#define XSH_PACKAGE_LEN (sizeof(XSH_PACKAGE)-1)
+
+#ifdef DEBUGGING
+# if XSH_HAS_PERL(5, 8, 9) || XSH_HAS_PERL(5, 9, 3)
+#  define XSH_ASSERT(C) assert(C)
+# else
+#  define XSH_ASSERT(C) PERL_DEB( \
+   ((C) ? ((void) 0)           \
+        : (Perl_croak_nocontext("Assertion %s failed: file \"" __FILE__  \
+                                 "\", line %d", STRINGIFY(C), __LINE__), \
+           (void) 0)))
+# endif
+#else
+# define XSH_ASSERT(C)
+#endif
+
+#undef VOID2
+#ifdef __cplusplus
+# define VOID2(T, P) static_cast<T>(P)
+#else
+# define VOID2(T, P) (P)
+#endif
+
+#ifndef STMT_START
+# define STMT_START do
+#endif
+
+#ifndef STMT_END
+# define STMT_END while (0)
+#endif
+
+#ifndef dNOOP
+# define dNOOP
+#endif
+
+#ifndef NOOP
+# define NOOP
+#endif
+
+#if XSH_HAS_PERL(5, 13, 2)
+# define XSH_DUP_PARAMS_TYPE       CLONE_PARAMS *
+# define xsh_dup_params_init(P, O) ((P) = Perl_clone_params_new((O), aTHX))
+# define xsh_dup_params_deinit(P)  Perl_clone_params_del(P)
+# define xsh_dup_params_ptr(P)     (P)
+#else
+# define XSH_DUP_PARAMS_TYPE       CLONE_PARAMS
+# define xsh_dup_params_init(P, O) \
+      ((P).stashes = newAV()); (P).flags = 0; ((P).proto_perl = (O))
+# define xsh_dup_params_deinit(P)  SvREFCNT_dec((P).stashes)
+# define xsh_dup_params_ptr(P)     &(P)
+#endif
+#define xsh_dup(S, P)     sv_dup((S), (P))
+#define xsh_dup_inc(S, P) SvREFCNT_inc(xsh_dup((S), (P)))
+
+/* Context for PerlMemShared_*() functions */
+#ifdef PERL_IMPLICIT_SYS
+# define pPMS  pTHX
+# define pPMS_ pTHX_
+# define aPMS  aTHX
+# define aPMS_ aTHX_
+#else
+# define pPMS  void
+# define pPMS_
+# define aPMS
+# define aPMS_
+#endif
+
+#ifdef USE_ITHREADS
+# define XSH_LOCK(M)   MUTEX_LOCK(M)
+# define XSH_UNLOCK(M) MUTEX_UNLOCK(M)
+#else
+# define XSH_LOCK(M)   NOOP
+# define XSH_UNLOCK(M) NOOP
+#endif
+
+#ifndef PTR2nat
+# define PTR2nat(p) (PTRV)(p)
+#endif
+
+#ifndef DPTR2FPTR
+# define DPTR2FPTR(t,p) ((t)PTR2nat(p))
+#endif
+
+#ifndef FPTR2DPTR
+# define FPTR2DPTR(t,p) ((t)PTR2nat(p))
+#endif
+
+#endif /* XSH_UTIL_H */