# 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)
# ifndef PL_oldbufptr
# define PL_oldbufptr PL_parser->oldbufptr
# endif
+# ifndef PL_lex_inwhat
+# define PL_lex_inwhat PL_parser->lex_inwhat
+# endif
#else
# ifndef PL_linestr
# define PL_linestr PL_Ilinestr
# ifndef PL_oldbufptr
# define PL_oldbufptr PL_Ioldbufptr
# endif
+# ifndef PL_lex_inwhat
+# define PL_lex_inwhat PL_Ilex_inwhat
+# endif
#endif
#ifndef I_WORKAROUND_REQUIRE_PROPAGATION
#endif
#ifndef I_MULTIPLICITY
-# if defined(MULTIPLICITY) || defined(PERL_IMPLICIT_CONTEXT)
+# 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
# undef MY_CXT
# define MY_CXT indirect_globaldata
# undef START_MY_CXT
-# define START_MY_CXT STATIC my_cxt_t 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
#else
-STATIC void indirect_ck_replace(pTHX_ OPCODE type, indirect_ck_t new_ck, indirect_ck_t *old_ck_p) {
+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_MUTEX_LOCK;
if (!*old_ck_p) {
#endif
-STATIC void indirect_ck_restore(pTHX_ OPCODE type, indirect_ck_t *old_ck_p) {
+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_MUTEX_LOCK;
if (*old_ck_p) {
/* --- Helpers ------------------------------------------------------------- */
+/* ... Check if the module is loaded ....................................... */
+
+#if I_THREADSAFE
+
+#define PTABLE_NAME ptable_loaded
+#define PTABLE_VAL_FREE(V) NOOP
+
+#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))
+
+#define indirect_loaded()
+
+static ptable *indirect_loaded_cxts = NULL;
+static U32 indirect_loaded_cxts_refcount = 0;
+
+/* 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
+
+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 void indirect_set_loaded(pTHX_ void *cxt) {
+#define indirect_set_loaded(C) indirect_set_loaded(aTHX_ (C))
+ I_LOADED_LOCK;
+ if (!indirect_loaded_cxts) {
+ indirect_loaded_cxts = ptable_new();
+ indirect_loaded_cxts_refcount = 0;
+ }
+ ++indirect_loaded_cxts_refcount;
+ ptable_loaded_store(indirect_loaded_cxts, cxt, cxt);
+ I_LOADED_UNLOCK;
+}
+
+static void indirect_clear_loaded(pTHX_ void *cxt) {
+#define indirect_clear_loaded(C) indirect_clear_loaded(aTHX_ (C))
+ I_LOADED_LOCK;
+ if (indirect_loaded_cxts_refcount <= 1) {
+ ptable_loaded_free(indirect_loaded_cxts);
+ indirect_loaded_cxts = NULL;
+ indirect_loaded_cxts_refcount = 0;
+ } else {
+ --indirect_loaded_cxts_refcount;
+ ptable_loaded_delete(indirect_loaded_cxts, cxt);
+ }
+ I_LOADED_UNLOCK;
+}
+
+#else
+
+#define indirect_is_loaded(C) (1)
+#define indirect_set_loaded(C) NOOP
+#define indirect_clear_loaded(C) NOOP
+
+#endif
+
/* ... Thread-safe hints ................................................... */
#if I_WORKAROUND_REQUIRE_PROPAGATION
#if I_THREADSAFE
-STATIC SV *indirect_clone(pTHX_ SV *sv, tTHX owner) {
-#define indirect_clone(S, O) indirect_clone(aTHX_ (S), (O))
- CLONE_PARAMS param;
- AV *stashes = NULL;
- SV *dupsv;
-
- if (!sv)
- return NULL;
-
- if (SvTYPE(sv) == SVt_PVHV && HvNAME_get(sv))
- stashes = newAV();
-
- param.stashes = stashes;
- param.flags = 0;
- param.proto_perl = owner;
-
- dupsv = sv_dup(sv, ¶m);
-
- if (stashes) {
- av_undef(stashes);
- SvREFCNT_dec(stashes);
- }
-
- return SvREFCNT_inc(dupsv);
-}
-
-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;
+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
- if (ud->owner == aTHX)
- return;
+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_clone(h1->code, ud->owner);
+ h2 = PerlMemShared_malloc(sizeof *h2);
+ h2->code = indirect_dup_inc(h1->code, ud);
#if I_WORKAROUND_REQUIRE_PROPAGATION
- h2->require_tag = PTR2IV(indirect_clone(INT2PTR(SV *, h1->require_tag),
- ud->owner));
+ h2->require_tag = PTR2IV(indirect_dup_inc(INT2PTR(SV *, h1->require_tag), ud));
#endif
#else /* I_HINT_STRUCT */
- h2 = indirect_clone(h1, ud->owner);
+ h2 = indirect_dup_inc(h1, ud);
#endif /* !I_HINT_STRUCT */
ptable_hints_store(ud->tbl, ent->key, h2);
}
-#include "reap.h"
-
-STATIC void indirect_thread_cleanup(pTHX_ void *ud) {
+static void indirect_thread_cleanup(pTHX_ void *ud) {
dMY_CXT;
+ indirect_clear_loaded(&MY_CXT);
+
SvREFCNT_dec(MY_CXT.global_code);
+ MY_CXT.global_code = NULL;
+
ptable_free(MY_CXT.map);
+ MY_CXT.map = NULL;
+
ptable_hints_free(MY_CXT.tbl);
+ MY_CXT.tbl = NULL;
}
+static int indirect_endav_free(pTHX_ SV *sv, MAGIC *mg) {
+ SAVEDESTRUCTOR_X(indirect_thread_cleanup, NULL);
+
+ return 0;
+}
+
+static MGVTBL indirect_endav_vtbl = {
+ 0,
+ 0,
+ 0,
+ 0,
+ indirect_endav_free
+#if MGf_COPY
+ , 0
+#endif
+#if MGf_DUP
+ , 0
+#endif
+#if MGf_LOCAL
+ , 0
+#endif
+};
+
#endif /* I_THREADSAFE */
#if I_WORKAROUND_REQUIRE_PROPAGATION
-STATIC IV indirect_require_tag(pTHX) {
+static IV indirect_require_tag(pTHX) {
#define indirect_require_tag() indirect_require_tag(aTHX)
const CV *cv, *outside;
}
#endif /* I_WORKAROUND_REQUIRE_PROPAGATION */
-STATIC SV *indirect_tag(pTHX_ SV *value) {
+static SV *indirect_tag(pTHX_ SV *value) {
#define indirect_tag(V) indirect_tag(aTHX_ (V))
indirect_hint_t *h;
- SV *code = NULL;
+ SV *code = NULL;
+#if I_THREADSAFE
+ dMY_CXT;
+
+ if (!MY_CXT.tbl)
+ return newSViv(0);
+#endif /* I_THREADSAFE */
if (SvROK(value)) {
value = SvRV(value);
#endif /* !I_HINT_STRUCT */
#if I_THREADSAFE
- {
- dMY_CXT;
- /* 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);
- }
+ /* 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) {
+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);
return I_HINT_CODE(h);
}
-STATIC U32 indirect_hash = 0;
+static VOL U32 indirect_hash = 0;
-STATIC SV *indirect_hint(pTHX) {
+static SV *indirect_hint(pTHX) {
#define indirect_hint() indirect_hint(aTHX)
SV *hint = NULL;
}
#endif
- if (hint && SvIOK(hint))
+ if (hint && SvIOK(hint)) {
return indirect_detag(hint);
- else {
+ } else {
dMY_CXT;
- return MY_CXT.global_code;
+ 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) {
+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->line = line;
}
-STATIC const indirect_op_info_t *indirect_map_fetch(pTHX_ const OP *o) {
+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) {
+static void indirect_map_delete(pTHX_ const OP *o) {
#define indirect_map_delete(O) indirect_map_delete(aTHX_ (O))
dMY_CXT;
- ptable_delete(MY_CXT.map, o);
+ if (indirect_is_loaded(&MY_CXT) && MY_CXT.map)
+ ptable_delete(MY_CXT.map, o);
}
/* --- Check functions ----------------------------------------------------- */
-STATIC STRLEN indirect_nextline(const char *s, STRLEN len) {
- STRLEN i;
-
- for (i = 0; i < len; ++i) {
- if (s[i] == '\n') {
- ++i;
- while (i < len && s[i] == '\r')
- ++i;
- break;
- }
- }
-
- return i;
-}
-
-STATIC int indirect_find(pTHX_ SV *name_sv, const char *line_bufptr, STRLEN *name_pos) {
+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;
const char *name, *name_end;
const char *line, *line_end;
- const char *p, *t, *u;
+ const char *p;
line = SvPV_const(PL_linestr, line_len);
line_end = line + line_len;
++p;
}
- t = line;
- u = t;
- while (t <= p) {
- STRLEN i = indirect_nextline(t, line_len);
- if (i >= line_len)
- break;
- u = t;
- t += i;
- line_len -= i;
- }
- *name_pos = p - u;
+ *name_pos = p - line;
return 1;
}
/* ... ck_const ............................................................ */
-STATIC OP *(*indirect_old_ck_const)(pTHX_ OP *) = 0;
+static OP *(*indirect_old_ck_const)(pTHX_ OP *) = 0;
-STATIC OP *indirect_ck_const(pTHX_ OP *o) {
+static OP *indirect_ck_const(pTHX_ OP *o) {
o = indirect_old_ck_const(aTHX_ o);
if (indirect_hint()) {
STRLEN pos;
if (indirect_find(sv, PL_oldbufptr, &pos)) {
+ STRLEN len;
+
+ /* If the constant is equal to the current package name, try to look for
+ * a "__PACKAGE__" coming before what we got. We only need to check this
+ * when we already had a match because __PACKAGE__ can only appear in
+ * direct method calls ("new __PACKAGE__" is a syntax error). */
+ len = SvCUR(sv);
+ if (PL_curstash
+ && len == (STRLEN) HvNAMELEN_get(PL_curstash)
+ && memcmp(SvPVX(sv), HvNAME_get(PL_curstash), len) == 0) {
+ STRLEN pos_pkg;
+ SV *pkg = sv_newmortal();
+ sv_setpvn(pkg, "__PACKAGE__", sizeof("__PACKAGE__")-1);
+
+ if (indirect_find(pkg, PL_oldbufptr, &pos_pkg) && pos_pkg < pos) {
+ sv = pkg;
+ pos = pos_pkg;
+ }
+ }
+
indirect_map_store(o, pos, sv, CopLINE(&PL_compiling));
return o;
}
/* ... ck_rv2sv ............................................................ */
-STATIC OP *(*indirect_old_ck_rv2sv)(pTHX_ OP *) = 0;
+static OP *(*indirect_old_ck_rv2sv)(pTHX_ OP *) = 0;
-STATIC OP *indirect_ck_rv2sv(pTHX_ OP *o) {
+static OP *indirect_ck_rv2sv(pTHX_ OP *o) {
if (indirect_hint()) {
OP *op = cUNOPo->op_first;
SV *sv;
/* ... ck_padany ........................................................... */
-STATIC OP *(*indirect_old_ck_padany)(pTHX_ OP *) = 0;
+static OP *(*indirect_old_ck_padany)(pTHX_ OP *) = 0;
-STATIC OP *indirect_ck_padany(pTHX_ OP *o) {
+static OP *indirect_ck_padany(pTHX_ OP *o) {
o = indirect_old_ck_padany(aTHX_ o);
if (indirect_hint()) {
/* ... ck_scope ............................................................ */
-STATIC OP *(*indirect_old_ck_scope) (pTHX_ OP *) = 0;
-STATIC OP *(*indirect_old_ck_lineseq)(pTHX_ OP *) = 0;
+static OP *(*indirect_old_ck_scope) (pTHX_ OP *) = 0;
+static OP *(*indirect_old_ck_lineseq)(pTHX_ OP *) = 0;
-STATIC OP *indirect_ck_scope(pTHX_ OP *o) {
+static OP *indirect_ck_scope(pTHX_ OP *o) {
OP *(*old_ck)(pTHX_ OP *) = 0;
switch (o->op_type) {
/* ... ck_method ........................................................... */
-STATIC OP *(*indirect_old_ck_method)(pTHX_ OP *) = 0;
+static OP *(*indirect_old_ck_method)(pTHX_ OP *) = 0;
-STATIC OP *indirect_ck_method(pTHX_ OP *o) {
+static OP *indirect_ck_method(pTHX_ OP *o) {
if (indirect_hint()) {
OP *op = cUNOPo->op_first;
/* "use foo/no foo" compiles its call to import/unimport directly to a
* method_named op. */
-STATIC OP *(*indirect_old_ck_method_named)(pTHX_ OP *) = 0;
+static OP *(*indirect_old_ck_method_named)(pTHX_ OP *) = 0;
-STATIC OP *indirect_ck_method_named(pTHX_ OP *o) {
+static OP *indirect_ck_method_named(pTHX_ OP *o) {
if (indirect_hint()) {
STRLEN pos;
line_t line;
/* ... ck_entersub ......................................................... */
-STATIC OP *(*indirect_old_ck_entersub)(pTHX_ OP *) = 0;
+static OP *(*indirect_old_ck_entersub)(pTHX_ OP *) = 0;
-STATIC OP *indirect_ck_entersub(pTHX_ OP *o) {
+static OP *indirect_ck_entersub(pTHX_ OP *o) {
SV *code = indirect_hint();
o = indirect_old_ck_entersub(aTHX_ o);
goto done;
oop = lop->op_first;
} while (oop->op_type != OP_PUSHMARK);
- oop = oop->op_sibling;
+ oop = OpSIBLING(oop);
mop = lop->op_last;
if (!oop)
return o;
}
-STATIC U32 indirect_initialized = 0;
+/* --- Global setup/teardown ------------------------------------------------ */
+
+static VOL U32 indirect_initialized = 0;
-STATIC void indirect_teardown(pTHX_ void *root) {
+static void indirect_global_teardown(pTHX_ void *root) {
if (!indirect_initialized)
return;
return;
#endif
- {
- dMY_CXT;
- ptable_free(MY_CXT.map);
-#if I_THREADSAFE
- ptable_hints_free(MY_CXT.tbl);
-#endif
- }
-
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_ENTERSUB, &indirect_old_ck_entersub);
indirect_initialized = 0;
+
+ return;
}
-STATIC void indirect_setup(pTHX) {
-#define indirect_setup() indirect_setup(aTHX)
+static void indirect_global_setup(pTHX) {
+#define indirect_global_setup() indirect_global_setup(aTHX)
+ HV *stash;
+
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.global_code = NULL;
- }
+ PERL_HASH(indirect_hash, __PACKAGE__, __PACKAGE_LEN__);
+
+ stash = gv_stashpvn(__PACKAGE__, __PACKAGE_LEN__, 1);
+ newCONSTSUB(stash, "I_THREADSAFE", newSVuv(I_THREADSAFE));
+ newCONSTSUB(stash, "I_FORKSAFE", newSVuv(I_FORKSAFE));
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_old_ck_entersub);
#if I_MULTIPLICITY
- call_atexit(indirect_teardown, aTHX);
+ call_atexit(indirect_global_teardown, aTHX);
#else
- call_atexit(indirect_teardown, NULL);
+ call_atexit(indirect_global_teardown, NULL);
#endif
indirect_initialized = 1;
+
+ return;
}
-STATIC U32 indirect_booted = 0;
+/* --- Interpreter setup/teardown ------------------------------------------ */
+
+static void indirect_local_teardown(pTHX_ void *param) {
+ dMY_CXT;
+
+ indirect_clear_loaded(&MY_CXT);
+
+ ptable_free(MY_CXT.map);
+ MY_CXT.map = NULL;
+
+#if I_THREADSAFE
+ ptable_hints_free(MY_CXT.tbl);
+ MY_CXT.tbl = NULL;
+#endif
+
+ return;
+}
+
+static void indirect_local_setup(pTHX) {
+#define indirect_local_setup() indirect_local_setup(aTHX)
+ MY_CXT_INIT;
+
+#if I_THREADSAFE
+ MY_CXT.tbl = ptable_new();
+ MY_CXT.owner = aTHX;
+#endif
+
+ MY_CXT.map = ptable_new();
+ MY_CXT.global_code = NULL;
+
+ indirect_set_loaded(&MY_CXT);
+
+ call_atexit(indirect_local_teardown, NULL);
+
+ return;
+}
/* --- XS ------------------------------------------------------------------ */
BOOT:
{
- if (!indirect_booted++) {
- HV *stash;
-
- PERL_HASH(indirect_hash, __PACKAGE__, __PACKAGE_LEN__);
-
- stash = gv_stashpvn(__PACKAGE__, __PACKAGE_LEN__, 1);
- newCONSTSUB(stash, "I_THREADSAFE", newSVuv(I_THREADSAFE));
- newCONSTSUB(stash, "I_FORKSAFE", newSVuv(I_FORKSAFE));
- }
-
- indirect_setup();
+ indirect_global_setup();
+ indirect_local_setup();
}
#if I_THREADSAFE
PREINIT:
ptable *t;
SV *global_code_dup;
+ GV *gv;
PPCODE:
{
- my_cxt_t ud;
+ indirect_ptable_clone_ud ud;
dMY_CXT;
- ud.tbl = t = ptable_new();
- ud.owner = MY_CXT.owner;
+ 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_clone(MY_CXT.global_code, MY_CXT.owner);
+ global_code_dup = indirect_dup_inc(MY_CXT.global_code, &ud);
+ indirect_ptable_clone_ud_deinit(ud);
}
{
MY_CXT_CLONE;
MY_CXT.tbl = t;
MY_CXT.owner = aTHX;
MY_CXT.global_code = global_code_dup;
+ indirect_set_loaded(&MY_CXT);
}
- reap(3, indirect_thread_cleanup, NULL);
+ gv = gv_fetchpv(__PACKAGE__ "::_THREAD_CLEANUP", 0, SVt_PVCV);
+ if (gv) {
+ CV *cv = GvCV(gv);
+ if (!PL_endav)
+ PL_endav = newAV();
+ SvREFCNT_inc(cv);
+ if (!av_store(PL_endav, av_len(PL_endav) + 1, (SV *) cv))
+ SvREFCNT_dec(cv);
+ sv_magicext((SV *) PL_endav, NULL, PERL_MAGIC_ext, &indirect_endav_vtbl, NULL, 0);
+ }
+ XSRETURN(0);
+
+void
+_THREAD_CLEANUP(...)
+PROTOTYPE: DISABLE
+PPCODE:
+ indirect_thread_cleanup(aTHX_ NULL);
XSRETURN(0);
#endif
projects / perl / modules / indirect.git / blobdiff