+/* This file is part of the re::engine::Plugin Perl module.
+ * See http://search.cpan.org/dist/re-engine-Plugin/ */
+
+#define PERL_NO_GET_CONTEXT
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
-#define SAVEPVN(p,n) ((p) ? savepvn(p,n) : NULL)
+/* --- Helpers ------------------------------------------------------------- */
-START_EXTERN_C
+#define XSH_PACKAGE "re::engine::Plugin"
+
+#include "xsh/caps.h"
+#include "xsh/util.h"
+
+/* ... Lexical hints ....................................................... */
+
+typedef struct {
+ SV *comp;
+ SV *exec;
+ SV *free;
+} xsh_hints_user_t;
+
+static SV *rep_validate_callback(SV *code) {
+ if (!SvROK(code))
+ return NULL;
+
+ code = SvRV(code);
+ if (SvTYPE(code) < SVt_PVCV)
+ return NULL;
+
+ return SvREFCNT_inc_simple_NN(code);
+}
+
+static void xsh_hints_user_init(pTHX_ xsh_hints_user_t *hv, xsh_hints_user_t *v) {
+ hv->comp = rep_validate_callback(v->comp);
+ hv->exec = rep_validate_callback(v->exec);
+ hv->free = rep_validate_callback(v->free);
+
+ return;
+}
+
+#if XSH_THREADSAFE
+
+static void xsh_hints_user_clone(pTHX_ xsh_hints_user_t *nv, xsh_hints_user_t *ov, CLONE_PARAMS *params) {
+ nv->comp = xsh_dup_inc(ov->comp, params);
+ nv->exec = xsh_dup_inc(ov->exec, params);
+ nv->free = xsh_dup_inc(ov->free, params);
+
+ return;
+}
+
+#endif /* XSH_THREADSAFE */
+
+static void xsh_hints_user_deinit(pTHX_ xsh_hints_user_t *hv) {
+ SvREFCNT_dec(hv->comp);
+ SvREFCNT_dec(hv->exec);
+ SvREFCNT_dec(hv->free);
+
+ return;
+}
+
+#define rep_hint() xsh_hints_detag(xsh_hints_fetch())
+
+#define XSH_HINTS_TYPE_USER 1
+#define XSH_HINTS_ONLY_COMPILE_TIME 0
+
+#include "xsh/hints.h"
+/* ... Thread-local storage ................................................ */
+
+#define XSH_THREADS_USER_CONTEXT 0
+#define XSH_THREADS_USER_LOCAL_SETUP 0
+#define XSH_THREADS_USER_LOCAL_TEARDOWN 0
+#define XSH_THREADS_USER_GLOBAL_TEARDOWN 0
+#define XSH_THREADS_COMPILE_TIME_PROTECTION 0
+
+#include "xsh/threads.h"
+
+/* --- Custom regexp engine ------------------------------------------------ */
+
+/* re__engine__Plugin self; SELF_FROM_PPRIVATE(self,rx->pprivate) */
+#define SELF_FROM_PPRIVATE(self, pprivate) \
+ if (sv_isobject(pprivate)) { \
+ SV *ref = SvRV((SV *) pprivate); \
+ IV tmp = SvIV((SV *) ref); \
+ self = INT2PTR(re__engine__Plugin, tmp); \
+ } else { \
+ Perl_croak(aTHX_ "Not an object"); \
+ }
+
+#if XSH_HAS_PERL(5, 19, 4)
+# define REP_ENG_EXEC_MINEND_TYPE SSize_t
+#else
+# define REP_ENG_EXEC_MINEND_TYPE I32
+#endif
+
+START_EXTERN_C
EXTERN_C const regexp_engine engine_plugin;
+#if XSH_HAS_PERL(5, 11, 0)
+EXTERN_C REGEXP * Plugin_comp(pTHX_ SV * const, U32);
+#else
+EXTERN_C REGEXP * Plugin_comp(pTHX_ const SV * const, const U32);
+#endif
+EXTERN_C I32 Plugin_exec(pTHX_ REGEXP * const, char *, char *,
+ char *, REP_ENG_EXEC_MINEND_TYPE, SV *, void *, U32);
+#if XSH_HAS_PERL(5, 19, 1)
+EXTERN_C char * Plugin_intuit(pTHX_ REGEXP * const, SV *, const char * const,
+ char *, char *, U32, re_scream_pos_data *);
+#else
+EXTERN_C char * Plugin_intuit(pTHX_ REGEXP * const, SV *, char *,
+ char *, U32, re_scream_pos_data *);
+#endif
+EXTERN_C SV * Plugin_checkstr(pTHX_ REGEXP * const);
+EXTERN_C void Plugin_free(pTHX_ REGEXP * const);
+EXTERN_C void * Plugin_dupe(pTHX_ REGEXP * const, CLONE_PARAMS *);
+EXTERN_C void Plugin_numbered_buff_FETCH(pTHX_ REGEXP * const,
+ const I32, SV * const);
+EXTERN_C void Plugin_numbered_buff_STORE(pTHX_ REGEXP * const,
+ const I32, SV const * const);
+EXTERN_C I32 Plugin_numbered_buff_LENGTH(pTHX_ REGEXP * const,
+ const SV * const, const I32);
+EXTERN_C SV * Plugin_named_buff(pTHX_ REGEXP * const, SV * const,
+ SV * const, const U32);
+EXTERN_C SV * Plugin_named_buff_iter(pTHX_ REGEXP * const, const SV * const,
+ const U32);
+EXTERN_C SV * Plugin_package(pTHX_ REGEXP * const);
+#ifdef USE_ITHREADS
+EXTERN_C void * Plugin_dupe(pTHX_ REGEXP * const, CLONE_PARAMS *);
+#endif
+EXTERN_C const regexp_engine engine_plugin;
END_EXTERN_C
-/*
- * Our struct which gets initiated and used as our object
- * ($re). Since we can't count on the regexp structure provided by
- * perl to be alive between comp/exec etc. we pull stuff from it and
- * save it in our own structure.
- *
- * Besides, creating Perl accessors which directly muck with perl's
- * own regexp structures in different phases of regex execution would
- * be a little too evil.
- */
+#define RE_ENGINE_PLUGIN (&engine_plugin)
+const regexp_engine engine_plugin = {
+ Plugin_comp,
+ Plugin_exec,
+ Plugin_intuit,
+ Plugin_checkstr,
+ Plugin_free,
+ Plugin_numbered_buff_FETCH,
+ Plugin_numbered_buff_STORE,
+ Plugin_numbered_buff_LENGTH,
+ Plugin_named_buff,
+ Plugin_named_buff_iter,
+ Plugin_package
+#if defined(USE_ITHREADS)
+ , Plugin_dupe
+#endif
+#if XSH_HAS_PERL(5, 17, 0)
+ , 0
+#endif
+};
+
typedef struct replug {
- SV * pattern;
- char flags[sizeof("ecgimsxp")];
+ /* Pointer back to the containing regexp struct so that accessors
+ * can modify nparens, gofs, etc... */
+ struct regexp *rx;
- I32 minlen;
- U32 gofs;
+ /* A copy of the pattern given to comp, for ->pattern */
+ SV *pattern;
- SV * stash;
+ /* A copy of the string being matched against, for ->str */
+ SV *str;
- U32 nparens;
- AV * captures; /* Array of SV* that'll become $1, $2, ... */
+ /* The ->stash */
+ SV *stash;
+
+ /* Callbacks */
+ SV *cb_exec;
+ SV *cb_free;
+
+ /* ->num_captures */
+ SV *cb_num_capture_buff_FETCH;
+ SV *cb_num_capture_buff_STORE;
+ SV *cb_num_capture_buff_LENGTH;
} *re__engine__Plugin;
-SV*
-get_H_callback(const char* key)
+#if XSH_HAS_PERL(5, 11, 0)
+# define rxREGEXP(RX) (SvANY(RX))
+# define newREGEXP(RX) ((RX) = ((REGEXP *) newSV_type(SVt_REGEXP)))
+#else
+# define rxREGEXP(RX) (RX)
+# define newREGEXP(RX) (Newxz((RX), 1, struct regexp))
+#endif
+
+REGEXP *
+#if XSH_HAS_PERL(5, 11, 0)
+Plugin_comp(pTHX_ SV * const pattern, U32 flags)
+#else
+Plugin_comp(pTHX_ const SV * const pattern, const U32 flags)
+#endif
{
- dVAR;
- dSP;
+ const xsh_hints_user_t *h;
+ REGEXP *RX;
+ struct regexp *rx;
+ re__engine__Plugin re;
+ char *pbuf;
+ STRLEN plen;
+ SV *obj;
+
+ h = rep_hint();
+ if (!h) /* This looks like a pragma leak. Apply the default behaviour */
+ return re_compile(pattern, flags);
+
+ /* exp/xend version of the pattern & length */
+ pbuf = SvPV((SV *) pattern, plen);
+
+ /* Our blessed object */
+ obj = newSV(0);
+ XSH_LOCAL_ALLOC(re, 1, struct replug);
+ sv_setref_pv(obj, XSH_PACKAGE, (void *) re);
+
+ newREGEXP(RX);
+ rx = rxREGEXP(RX);
+
+ re->rx = rx; /* Make the rx accessible from self->rx */
+ rx->intflags = flags; /* Flags for internal use */
+ rx->extflags = flags; /* Flags for perl to use */
+ rx->engine = RE_ENGINE_PLUGIN; /* Compile to use this engine */
+
+#if !XSH_HAS_PERL(5, 11, 0)
+ rx->refcnt = 1; /* Refcount so we won't be destroyed */
+
+ /* Precompiled pattern for pp_regcomp to use */
+ rx->prelen = plen;
+ rx->precomp = savepvn(pbuf, rx->prelen);
+
+ /* Set up qr// stringification to be equivalent to the supplied
+ * pattern, this should be done via overload eventually */
+ rx->wraplen = rx->prelen;
+ Newx(rx->wrapped, rx->wraplen, char);
+ Copy(rx->precomp, rx->wrapped, rx->wraplen, char);
+#endif
+
+ /* Store our private object */
+ rx->pprivate = obj;
+
+ /* Store the pattern for ->pattern */
+ re->pattern = (SV *) pattern;
+ SvREFCNT_inc_simple_void(re->pattern);
+
+ re->str = NULL;
+ re->stash = NULL;
+
+ /* Store the default exec callback (which may be NULL) into the regexp
+ * object. */
+ re->cb_exec = h->exec;
+ SvREFCNT_inc_simple_void(h->exec);
+
+ /* Same goes for the free callback. */
+ re->cb_free = h->free;
+ SvREFCNT_inc_simple_void(h->free);
- SV * callback;
+ re->cb_num_capture_buff_FETCH = NULL;
+ re->cb_num_capture_buff_STORE = NULL;
+ re->cb_num_capture_buff_LENGTH = NULL;
- ENTER;
- SAVETMPS;
-
- PUSHMARK(SP);
- XPUSHs(sv_2mortal(newSVpv(key, 0)));
- PUTBACK;
+ /* Call our callback function if one was defined, if not we've already set up
+ * all the stuff we're going to to need for subsequent exec and other calls */
+ if (h->comp) {
+ dSP;
- call_pv("re::engine::Plugin::get_callback", G_SCALAR);
+ ENTER;
+ SAVETMPS;
- SPAGAIN;
+ PUSHMARK(SP);
+ XPUSHs(obj);
+ PUTBACK;
- callback = POPs;
- SvREFCNT_inc(callback);
+ call_sv(h->comp, G_DISCARD);
- if (!SvROK(callback)) { callback = NULL; }// croak("ret value not a ref"); }
+ FREETMPS;
+ LEAVE;
+ }
- PUTBACK;
- FREETMPS;
- LEAVE;
+ /* If any of the comp-time accessors were called we'll have to
+ * update the regexp struct with the new info */
+ Newxz(rx->offs, rx->nparens + 1, regexp_paren_pair);
- return callback;
+ return RX;
}
-/* just learn to use gdb you lazy bum! */
-#if 0
-void
-dump_r_info(const char* id, regexp *r)
+I32
+Plugin_exec(pTHX_ REGEXP * const RX, char *stringarg, char *strend,
+ char *strbeg, REP_ENG_EXEC_MINEND_TYPE minend,
+ SV *sv, void *data, U32 flags)
{
- warn("%s:", id);
- warn("\textflags = %d", r->extflags);
- warn("\tminlen = %d", r->minlen);
- warn("\tminlenren = %d", r->minlenret);
- warn("\tgofs = %d", r->gofs);
- warn("\tnparens = %d", r->nparens);
- warn("\tpprivate = %p", r->pprivate);
- warn("\tsubbeg = %s", r->subbeg);
- warn("\tsublen = %d", r->sublen);
- warn("\tprecomp = %s", r->precomp);
- warn("\tprelen = %d", r->prelen);
- warn("\twrapped = %s", r->wrapped);
- warn("\twraplen = %d", r->wraplen);
- warn("\tseen_evals = %d", r->seen_evals);
- warn("\trefcnt = %d", r->refcnt);
-
+ struct regexp *rx;
+ re__engine__Plugin self;
+ I32 matched;
+
+ rx = rxREGEXP(RX);
+ SELF_FROM_PPRIVATE(self, rx->pprivate);
+
+ if (self->cb_exec) {
+ SV *ret;
+ dSP;
+
+ /* Store the current str for ->str */
+ SvREFCNT_dec(self->str);
+ self->str = sv;
+ SvREFCNT_inc_simple_void(self->str);
+
+ ENTER;
+ SAVETMPS;
+
+ PUSHMARK(SP);
+ XPUSHs(rx->pprivate);
+ XPUSHs(sv);
+ PUTBACK;
+
+ call_sv(self->cb_exec, G_SCALAR);
+
+ SPAGAIN;
+
+ ret = POPs;
+ if (SvTRUE(ret))
+ matched = 1;
+ else
+ matched = 0;
+
+ PUTBACK;
+ FREETMPS;
+ LEAVE;
+ } else {
+ matched = 0;
+ }
+
+ return matched;
}
+
+char *
+#if XSH_HAS_PERL(5, 19, 1)
+Plugin_intuit(pTHX_ REGEXP * const RX, SV *sv, const char * const strbeg,
+ char *strpos, char *strend, U32 flags, re_scream_pos_data *data)
+#else
+Plugin_intuit(pTHX_ REGEXP * const RX, SV *sv, char *strpos,
+ char *strend, U32 flags, re_scream_pos_data *data)
+#endif
+{
+ PERL_UNUSED_ARG(RX);
+ PERL_UNUSED_ARG(sv);
+#if XSH_HAS_PERL(5, 19, 1)
+ PERL_UNUSED_ARG(strbeg);
#endif
+ PERL_UNUSED_ARG(strpos);
+ PERL_UNUSED_ARG(strend);
+ PERL_UNUSED_ARG(flags);
+ PERL_UNUSED_ARG(data);
-regexp *
-Plugin_comp(pTHX_ char *exp, char *xend, PMOP *pm)
+ return NULL;
+}
+
+SV *
+Plugin_checkstr(pTHX_ REGEXP * const RX)
{
- dSP;
- register regexp *r;
- int count;
-
- /*
- * Allocate a new regexp struct, we must only write to the intflags,
- * engine and private members and the others must be populated,
- * internals expect the regex to have certain values least our code
- * blow up
- */
-
- Newxz(r,1,regexp);
-
- /* Set up the regex to be handled by this plugin */
- r->engine = &engine_plugin;
-
- /* Store the initial flags */
- r->intflags = pm->op_pmflags;
- r->pprivate = NULL; /* this is set to our object below */
-
- /*
- * Populate the regexp members for the engine
- */
-
- /* Ref count of the pattern */
- r->refcnt = 1;
-
- /* Preserve a copy of the original pattern */
- r->prelen = xend - exp;
- r->precomp = SAVEPVN(exp, r->prelen);
-
- /* these may be changed by accessors */
- r->minlen = 0;
- r->minlenret = 0;
- r->gofs = 0;
- r->nparens = 0;
-
- /* Store the flags as perl expects them */
- r->extflags = pm->op_pmflags & RXf_PMf_COMPILETIME;
-
- /*
- * Construct a new B<re::engine::Plugin> object that'll carry around
- * our data inside C<< r->pprivate >>. The object is a blessed void*
- * that points to our replug struct which holds any state we want to
- * keep.
- */
- re__engine__Plugin re;
- Newz(0, re, 1, struct replug);
-
- SV *obj = newSV(0);
- SvREFCNT_inc(obj);
-
- /* Bless into this package; TODO: make it subclassable */
- const char * pkg = "re::engine::Plugin";
- /* bless it */
- sv_setref_pv(obj, pkg, (void*)re);
-
- /* Store our private object */
- r->pprivate = obj;
-
- re->pattern = newSVpvn(SAVEPVN(exp, xend - exp), xend - exp);
- SvREFCNT_inc(re->pattern);
-
- /* Concat [ec]gimosxp (egimosxp & cgimosxp into) the flags string as
- * appropriate
- */
- if (r->intflags & PMf_EVAL) { strcat(re->flags, "e"); }
- if (r->intflags & PMf_CONTINUE) { strcat(re->flags, "c"); }
- if (r->intflags & PMf_GLOBAL) { strcat(re->flags, "g"); }
- if (r->intflags & PMf_FOLD) { strcat(re->flags, "i"); }
- if (r->intflags & PMf_MULTILINE) { strcat(re->flags, "m"); }
- if (r->intflags & PMf_ONCE) { strcat(re->flags, "o"); }
- if (r->intflags & PMf_SINGLELINE) { strcat(re->flags, "s"); }
- if (r->intflags & PMf_EXTENDED) { strcat(re->flags, "x"); }
- if (((r->extflags & RXf_PMf_KEEPCOPY) == RXf_PMf_KEEPCOPY)) {
- strcat(re->flags, "p");
- }
-
- /*
- * Call our callback function if one was defined, if not we've
- * already set up all the stuff we're going to to need for
- * subsequent exec and other calls
- */
- SV * callback = get_H_callback("comp");
-
- if (callback) {
- ENTER;
- SAVETMPS;
-
- PUSHMARK(SP);
- XPUSHs(obj);
- XPUSHs(sv_2mortal(newSVpv(exp, xend - exp)));
-
- PUTBACK;
-
- call_sv(get_H_callback("comp"), G_DISCARD);
-
- FREETMPS;
- LEAVE;
- }
-
- /* If any of the comp-time accessors were called we'll have to
- * update the regexp struct with the new info.
- */
- if (re->minlen) r->minlen = re->minlen;
- if (re->gofs) r->gofs = re->gofs;
- if (re->gofs) r->gofs = re->gofs;
- if (re->nparens) r->nparens = re->nparens;
-
- int buffers = r->nparens;
-
- //r->nparens = (buffers - 1);
- Newxz(r->startp, buffers, I32);
- Newxz(r->endp, buffers, I32);
-
- /* return the regexp */
- return r;
+ PERL_UNUSED_ARG(RX);
+
+ return NULL;
}
-I32
-Plugin_exec(pTHX_ register regexp *r, char *stringarg, register char *strend,
- char *strbeg, I32 minend, SV *sv, void *data, U32 flags)
+void
+Plugin_free(pTHX_ REGEXP * const RX)
{
- dSP;
- I32 rc;
- int *ovector;
- I32 i;
- int count;
- int ret;
+ struct regexp *rx;
+ re__engine__Plugin self;
+ SV *callback;
- /*Newx(ovector,r->nparens,int);*/
+ if (PL_dirty)
+ return;
- SV* callback = get_H_callback("exec");
+ rx = rxREGEXP(RX);
+ SELF_FROM_PPRIVATE(self, rx->pprivate);
- ENTER;
- SAVETMPS;
-
- PUSHMARK(SP);
+ callback = self->cb_free;
- XPUSHs(r->pprivate);
- XPUSHs(sv);
+ if (callback) {
+ dSP;
- PUTBACK;
+ ENTER;
+ SAVETMPS;
- count = call_sv(callback, G_ARRAY);
-
- SPAGAIN;
+ PUSHMARK(SP);
+ XPUSHs(rx->pprivate);
+ PUTBACK;
- SV * SvRet = POPs;
+ call_sv(callback, G_DISCARD);
- if (SvTRUE(SvRet)) {
- /* Match vars */
+ PUTBACK;
+ FREETMPS;
+ LEAVE;
+ }
- /*
- r->sublen = strend-strbeg;
- r->subbeg = savepvn(strbeg,r->sublen);
- r->startp[1] = 0;
- r->endp[1] = 5;
- */
+ SvREFCNT_dec(self->pattern);
+ SvREFCNT_dec(self->str);
+ SvREFCNT_dec(self->stash);
- ret = 1;
- } else {
- ret = 0;
- }
+ SvREFCNT_dec(self->cb_exec);
- PUTBACK;
- FREETMPS;
- LEAVE;
+ SvREFCNT_dec(self->cb_num_capture_buff_FETCH);
+ SvREFCNT_dec(self->cb_num_capture_buff_STORE);
+ SvREFCNT_dec(self->cb_num_capture_buff_LENGTH);
- return ret;
+ self->rx = NULL;
+
+ XSH_LOCAL_FREE(self, 1, struct replug);
+
+ SvREFCNT_dec(rx->pprivate);
+
+ return;
}
-char *
-Plugin_intuit(pTHX_ regexp *prog, SV *sv, char *strpos,
- char *strend, U32 flags, re_scream_pos_data *data)
+void *
+Plugin_dupe(pTHX_ REGEXP * const RX, CLONE_PARAMS *param)
{
- return NULL;
+ struct regexp *rx = rxREGEXP(RX);
+
+ Perl_croak(aTHX_ "dupe not supported yet");
+
+ return rx->pprivate;
}
-SV *
-Plugin_checkstr(pTHX_ regexp *prog)
+
+void
+Plugin_numbered_buff_FETCH(pTHX_ REGEXP * const RX, const I32 paren,
+ SV * const sv)
{
- return NULL;
+ struct regexp *rx;
+ re__engine__Plugin self;
+ SV *callback;
+
+ rx = rxREGEXP(RX);
+ SELF_FROM_PPRIVATE(self, rx->pprivate);
+
+ callback = self->cb_num_capture_buff_FETCH;
+
+ if (callback) {
+ I32 items;
+ dSP;
+
+ ENTER;
+ SAVETMPS;
+
+ PUSHMARK(SP);
+ XPUSHs(rx->pprivate);
+ mXPUSHi(paren);
+ PUTBACK;
+
+ items = call_sv(callback, G_SCALAR);
+
+ if (items == 1) {
+ SV *ret;
+ SPAGAIN;
+ ret = POPs;
+ sv_setsv(sv, ret);
+ } else {
+ sv_setsv(sv, &PL_sv_undef);
+ }
+
+ PUTBACK;
+ FREETMPS;
+ LEAVE;
+ } else {
+ sv_setsv(sv, &PL_sv_undef);
+ }
}
void
-Plugin_free(pTHX_ struct regexp *r)
+Plugin_numbered_buff_STORE(pTHX_ REGEXP * const RX, const I32 paren,
+ SV const * const value)
{
- /*sv_2mortal(r->pprivate);*/
- /*PerlMemShared_free(r->pprivate);*/
+ struct regexp *rx;
+ re__engine__Plugin self;
+ SV *callback;
+
+ rx = rxREGEXP(RX);
+ SELF_FROM_PPRIVATE(self, rx->pprivate);
+
+ callback = self->cb_num_capture_buff_STORE;
+
+ if (callback) {
+ dSP;
+
+ ENTER;
+ SAVETMPS;
+
+ PUSHMARK(SP);
+ XPUSHs(rx->pprivate);
+ mXPUSHi(paren);
+ XPUSHs((SV *) value);
+ PUTBACK;
+
+ call_sv(callback, G_DISCARD);
+
+ PUTBACK;
+ FREETMPS;
+ LEAVE;
+ }
}
-void *
-Plugin_dupe(pTHX_ const regexp *r, CLONE_PARAMS *param)
+I32
+Plugin_numbered_buff_LENGTH(pTHX_ REGEXP * const RX, const SV * const sv,
+ const I32 paren)
{
- return r->pprivate;
+ struct regexp *rx;
+ re__engine__Plugin self;
+ SV *callback;
+
+ rx = rxREGEXP(RX);
+ SELF_FROM_PPRIVATE(self, rx->pprivate);
+
+ callback = self->cb_num_capture_buff_LENGTH;
+
+ if (callback) {
+ IV ret;
+ dSP;
+
+ ENTER;
+ SAVETMPS;
+
+ PUSHMARK(SP);
+ XPUSHs(rx->pprivate);
+ mXPUSHi(paren);
+ PUTBACK;
+
+ call_sv(callback, G_SCALAR);
+
+ SPAGAIN;
+
+ ret = POPi;
+
+ PUTBACK;
+ FREETMPS;
+ LEAVE;
+
+ return (I32) ret;
+ } else {
+ /* TODO: call FETCH and get the length on that value */
+ return 0;
+ }
}
-SV*
-Plugin_numbered_buff_get(pTHX_ const REGEXP * const rx, I32 paren, SV* usesv)
+SV *
+Plugin_named_buff(pTHX_ REGEXP * const RX, SV * const key, SV * const value,
+ const U32 flags)
{
- return NULL;
+ return NULL;
}
-SV*
-Plugin_named_buff_get(pTHX_ const REGEXP * const rx, SV* namesv, U32 flags)
+SV *
+Plugin_named_buff_iter(pTHX_ REGEXP * const RX, const SV * const lastkey,
+ const U32 flags)
{
- return NULL;
+ return NULL;
}
-/*
- * The function pointers we're telling the regex engine to use
- */
-const regexp_engine engine_plugin = {
- Plugin_comp,
- Plugin_exec,
- Plugin_intuit,
- Plugin_checkstr,
- Plugin_free,
- Plugin_numbered_buff_get,
- Plugin_named_buff_get,
-#if defined(USE_ITHREADS)
- Plugin_dupe,
-#endif
-};
+SV *
+Plugin_package(pTHX_ REGEXP * const RX)
+{
+ PERL_UNUSED_ARG(RX);
-MODULE = re::engine::Plugin PACKAGE = re::engine::Plugin
+ return newSVpvs(XSH_PACKAGE);
+}
-SV *
+static void xsh_user_global_setup(pTHX) {
+ HV *stash;
+
+ stash = gv_stashpvn(XSH_PACKAGE, XSH_PACKAGE_LEN, 1);
+ newCONSTSUB(stash, "REP_THREADSAFE", newSVuv(XSH_THREADSAFE));
+ newCONSTSUB(stash, "REP_FORKSAFE", newSVuv(XSH_FORKSAFE));
+
+ return;
+}
+
+/* --- XS ------------------------------------------------------------------ */
+
+MODULE = re::engine::Plugin PACKAGE = re::engine::Plugin
+
+PROTOTYPES: DISABLE
+
+BOOT:
+{
+ xsh_setup();
+}
+
+#if XSH_THREADSAFE
+
+void
+CLONE(...)
+PPCODE:
+ xsh_clone();
+ XSRETURN(0);
+
+#endif /* XSH_THREADSAFE */
+
+void
pattern(re::engine::Plugin self, ...)
-CODE:
- SvREFCNT_inc(self->pattern);
- RETVAL = self->pattern;
-OUTPUT:
- RETVAL
+PPCODE:
+ XPUSHs(self->pattern);
+ XSRETURN(1);
-char*
-flags(re::engine::Plugin self, ...)
-CODE:
- RETVAL = self->flags;
-OUTPUT:
- RETVAL
+void
+str(re::engine::Plugin self, ...)
+PPCODE:
+ XPUSHs(self->str);
+ XSRETURN(1);
-SV *
-stash(re::engine::Plugin self, ...)
+void
+mod(re::engine::Plugin self)
PREINIT:
- SV * stash;
-CODE:
- if (items > 1) {
- self->stash = sv_mortalcopy(ST(1));
- SvREFCNT_inc(self->stash);
- }
- SvREFCNT_inc(self->stash);
- RETVAL = self->stash;
-OUTPUT:
- RETVAL
+ U32 flags;
+ char mods[5 + 1];
+ int n = 0, i;
+PPCODE:
+ flags = self->rx->intflags;
+ if (flags & PMf_FOLD) /* /i */
+ mods[n++] = 'i';
+ if (flags & PMf_MULTILINE) /* /m */
+ mods[n++] = 'm';
+ if (flags & PMf_SINGLELINE) /* /s */
+ mods[n++] = 's';
+ if (flags & PMf_EXTENDED) /* /x */
+ mods[n++] = 'x';
+ if (flags & RXf_PMf_KEEPCOPY) /* /p */
+ mods[n++] = 'p';
+ mods[n] = '\0';
+ EXTEND(SP, 2 * n);
+ for (i = 0; i < n; ++i) {
+ mPUSHp(mods + i, 1);
+ PUSHs(&PL_sv_yes);
+ }
+ XSRETURN(2 * n);
-SV *
-minlen(re::engine::Plugin self, ...)
-CODE:
- if (items > 1) {
- self->minlen = (I32)SvIV(ST(1));
- }
+void
+stash(re::engine::Plugin self, ...)
+PPCODE:
+ if (items > 1) {
+ SvREFCNT_dec(self->stash);
+ self->stash = ST(1);
+ SvREFCNT_inc_simple_void(self->stash);
+ XSRETURN_EMPTY;
+ } else {
+ XPUSHs(self->stash);
+ XSRETURN(1);
+ }
- RETVAL = self->minlen ? newSViv(self->minlen) : &PL_sv_undef;
-OUTPUT:
- RETVAL
+void
+minlen(re::engine::Plugin self, ...)
+PPCODE:
+ if (items > 1) {
+ self->rx->minlen = (I32)SvIV(ST(1));
+ XSRETURN_EMPTY;
+ } else if (self->rx->minlen) {
+ mXPUSHi(self->rx->minlen);
+ XSRETURN(1);
+ } else {
+ XSRETURN_UNDEF;
+ }
-SV *
+void
gofs(re::engine::Plugin self, ...)
-CODE:
- if (items > 1) {
- self->gofs = (U32)SvIV(ST(1));
- }
- RETVAL = self->gofs ? newSVuv(self->gofs) : &PL_sv_undef;
-OUTPUT:
- RETVAL
+PPCODE:
+ if (items > 1) {
+ self->rx->gofs = (U32)SvIV(ST(1));
+ XSRETURN_EMPTY;
+ } else if (self->rx->gofs) {
+ mXPUSHu(self->rx->gofs);
+ XSRETURN(1);
+ } else {
+ XSRETURN_UNDEF;
+ }
-SV *
+void
nparens(re::engine::Plugin self, ...)
-CODE:
- if (items > 1) {
- self->nparens = (U32)SvIV(ST(1));
- }
- RETVAL = self->gofs ? newSVuv(self->gofs) : &PL_sv_undef;
-OUTPUT:
- RETVAL
+PPCODE:
+ if (items > 1) {
+ self->rx->nparens = (U32)SvIV(ST(1));
+ XSRETURN_EMPTY;
+ } else if (self->rx->nparens) {
+ mXPUSHu(self->rx->nparens);
+ XSRETURN(1);
+ } else {
+ XSRETURN_UNDEF;
+ }
+
+void
+_exec(re::engine::Plugin self, ...)
+PPCODE:
+ if (items > 1) {
+ SvREFCNT_dec(self->cb_exec);
+ self->cb_exec = ST(1);
+ SvREFCNT_inc_simple_void(self->cb_exec);
+ }
+ XSRETURN(0);
+
+void
+_free(re::engine::Plugin self, ...)
+PPCODE:
+ if (items > 1) {
+ SvREFCNT_dec(self->cb_free);
+ self->cb_free = ST(1);
+ SvREFCNT_inc_simple_void(self->cb_free);
+ }
+ XSRETURN(0);
void
-captures(re::engine::Plugin self, ...)
+_num_capture_buff_FETCH(re::engine::Plugin self, ...)
PPCODE:
- if (items > 1) {
- self->minlen = (I32)SvIV(ST(1));
- }
- XPUSHs(sv_2mortal(newSViv(5)));
- XPUSHs(sv_2mortal(newSViv(10)));
+ if (items > 1) {
+ SvREFCNT_dec(self->cb_num_capture_buff_FETCH);
+ self->cb_num_capture_buff_FETCH = ST(1);
+ SvREFCNT_inc_simple_void(self->cb_num_capture_buff_FETCH);
+ }
+ XSRETURN(0);
+
+void
+_num_capture_buff_STORE(re::engine::Plugin self, ...)
+PPCODE:
+ if (items > 1) {
+ SvREFCNT_dec(self->cb_num_capture_buff_STORE);
+ self->cb_num_capture_buff_STORE = ST(1);
+ SvREFCNT_inc_simple_void(self->cb_num_capture_buff_STORE);
+ }
+ XSRETURN(0);
+
+void
+_num_capture_buff_LENGTH(re::engine::Plugin self, ...)
+PPCODE:
+ if (items > 1) {
+ SvREFCNT_dec(self->cb_num_capture_buff_LENGTH);
+ self->cb_num_capture_buff_LENGTH = ST(1);
+ SvREFCNT_inc_simple_void(self->cb_num_capture_buff_LENGTH);
+ }
+ XSRETURN(0);
+
+SV *
+_tag(SV *comp, SV *exec, SV *free)
+PREINIT:
+ xsh_hints_user_t arg;
+CODE:
+ arg.comp = comp;
+ arg.exec = exec;
+ arg.free = free;
+ RETVAL = xsh_hints_tag(&arg);
+OUTPUT:
+ RETVAL
void
-get_engine_plugin()
+ENGINE()
PPCODE:
- XPUSHs(sv_2mortal(newSViv(PTR2IV(&engine_plugin))));
+ mXPUSHi(PTR2IV(&engine_plugin));
+ XSRETURN(1);
projects / perl / modules / re-engine-Plugin.git / blobdiff