typedef struct {
SV *comp;
SV *exec;
+ SV *free;
} xsh_hints_user_t;
-STATIC SV *rep_validate_callback(SV *code) {
+static SV *rep_validate_callback(SV *code) {
if (!SvROK(code))
return NULL;
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;
}
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;
}
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;
}
/* --- Custom regexp engine ------------------------------------------------ */
-#define GET_SELF_FROM_PPRIVATE(pprivate) \
- re__engine__Plugin self; \
- SELF_FROM_PPRIVATE(self,pprivate);
-
/* 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"); \
- }
+#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
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_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 *);
#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
+ 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
+ , Plugin_dupe
#endif
#if XSH_HAS_PERL(5, 17, 0)
- , 0
+ , 0
#endif
};
typedef struct replug {
- /* Pointer back to the containing regexp struct so that accessors
- * can modify nparens, gofs etc. */
- struct regexp * rx;
+ /* Pointer back to the containing regexp struct so that accessors
+ * can modify nparens, gofs, etc... */
+ struct regexp *rx;
- /* A copy of the pattern given to comp, for ->pattern */
- SV * pattern;
+ /* A copy of the pattern given to comp, for ->pattern */
+ SV *pattern;
- /* A copy of the string being matched against, for ->str */
- SV * str;
+ /* A copy of the string being matched against, for ->str */
+ SV *str;
- /* The ->stash */
- SV * stash;
+ /* The ->stash */
+ SV *stash;
- /* Callbacks */
- SV * cb_exec;
- SV * cb_free;
+ /* 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;
+ /* ->num_captures */
+ SV *cb_num_capture_buff_FETCH;
+ SV *cb_num_capture_buff_STORE;
+ SV *cb_num_capture_buff_LENGTH;
} *re__engine__Plugin;
#if XSH_HAS_PERL(5, 11, 0)
# define rxREGEXP(RX) (SvANY(RX))
-# define newREGEXP(RX) ((RX) = ((REGEXP*) newSV_type(SVt_REGEXP)))
+# define newREGEXP(RX) ((RX) = ((REGEXP *) newSV_type(SVt_REGEXP)))
#else
# define rxREGEXP(RX) (RX)
# define newREGEXP(RX) (Newxz((RX), 1, struct regexp))
Plugin_comp(pTHX_ const SV * const pattern, const U32 flags)
#endif
{
- dSP;
- struct regexp * rx;
- REGEXP *RX;
-
- re__engine__Plugin re;
- const xsh_hints_user_t *h;
-
- STRLEN plen;
- char *pbuf;
-
- SV *obj;
+ 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 */
- h = rep_hint();
- if (!h) /* This looks like a pragma leak. Apply the default behaviour */
- return re_compile(pattern, flags);
+#if !XSH_HAS_PERL(5, 11, 0)
+ rx->refcnt = 1; /* Refcount so we won't be destroyed */
- /* exp/xend version of the pattern & length */
- pbuf = SvPV((SV*)pattern, plen);
+ /* Precompiled pattern for pp_regcomp to use */
+ rx->prelen = plen;
+ rx->precomp = savepvn(pbuf, rx->prelen);
- /* Our blessed object */
- obj = newSV(0);
- SvREFCNT_inc_simple_void_NN(obj);
- Newxz(re, 1, struct replug);
- sv_setref_pv(obj, "re::engine::Plugin", (void*)re);
+ /* 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
- newREGEXP(RX);
- rx = rxREGEXP(RX);
+ /* Store our private object */
+ rx->pprivate = obj;
- 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 */
+ /* Store the pattern for ->pattern */
+ re->pattern = (SV *) pattern;
+ SvREFCNT_inc_simple_void(re->pattern);
-#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
+ re->str = NULL;
+ re->stash = NULL;
- /* Store our private object */
- rx->pprivate = obj;
+ /* Store the default exec callback (which may be NULL) into the regexp
+ * object. */
+ re->cb_exec = h->exec;
+ SvREFCNT_inc_simple_void(h->exec);
- /* Store the pattern for ->pattern */
- re->pattern = (SV*)pattern;
- SvREFCNT_inc_simple_void(re->pattern);
+ /* Same goes for the free callback. */
+ re->cb_free = h->free;
+ SvREFCNT_inc_simple_void(h->free);
- /* If there's an exec callback, store it into the private object so
- * that it will be the one to be called, even if the engine changes
- * in between */
- if (h->exec) {
- re->cb_exec = h->exec;
- SvREFCNT_inc_simple_void_NN(h->exec);
- }
+ re->cb_num_capture_buff_FETCH = NULL;
+ re->cb_num_capture_buff_STORE = NULL;
+ re->cb_num_capture_buff_LENGTH = NULL;
- re->cb_num_capture_buff_FETCH = NULL;
- re->cb_num_capture_buff_STORE = NULL;
- re->cb_num_capture_buff_LENGTH = NULL;
+ /* 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 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) {
- ENTER;
- SAVETMPS;
+ ENTER;
+ SAVETMPS;
- PUSHMARK(SP);
- XPUSHs(obj);
- PUTBACK;
+ PUSHMARK(SP);
+ XPUSHs(obj);
+ PUTBACK;
- call_sv(h->comp, G_DISCARD);
+ call_sv(h->comp, G_DISCARD);
- FREETMPS;
- LEAVE;
- }
+ FREETMPS;
+ LEAVE;
+ }
- /* If any of the comp-time accessors were called we'll have to
- * update the regexp struct with the new info.
- */
+ /* 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);
- Newxz(rx->offs, rx->nparens + 1, regexp_paren_pair);
-
- return RX;
+ return RX;
}
I32
char *strbeg, REP_ENG_EXEC_MINEND_TYPE minend,
SV *sv, void *data, U32 flags)
{
- dSP;
- I32 matched;
- struct regexp *rx = rxREGEXP(RX);
- GET_SELF_FROM_PPRIVATE(rx->pprivate);
+ struct regexp *rx;
+ re__engine__Plugin self;
+ I32 matched;
+
+ rx = rxREGEXP(RX);
+ SELF_FROM_PPRIVATE(self, rx->pprivate);
- if (self->cb_exec) {
- SV *ret;
+ 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);
+ /* Store the current str for ->str */
+ SvREFCNT_dec(self->str);
+ self->str = sv;
+ SvREFCNT_inc_simple_void(self->str);
- ENTER;
- SAVETMPS;
+ ENTER;
+ SAVETMPS;
- PUSHMARK(SP);
- XPUSHs(rx->pprivate);
- XPUSHs(sv);
- PUTBACK;
+ PUSHMARK(SP);
+ XPUSHs(rx->pprivate);
+ XPUSHs(sv);
+ PUTBACK;
- call_sv(self->cb_exec, G_SCALAR);
+ call_sv(self->cb_exec, G_SCALAR);
- SPAGAIN;
+ SPAGAIN;
- ret = POPs;
- if (SvTRUE(ret))
- matched = 1;
- else
- matched = 0;
+ ret = POPs;
+ if (SvTRUE(ret))
+ matched = 1;
+ else
+ matched = 0;
- PUTBACK;
- FREETMPS;
- LEAVE;
- } else {
- matched = 0;
- }
+ PUTBACK;
+ FREETMPS;
+ LEAVE;
+ } else {
+ matched = 0;
+ }
- return matched;
+ return matched;
}
char *
char *strend, U32 flags, re_scream_pos_data *data)
#endif
{
- PERL_UNUSED_ARG(RX);
- PERL_UNUSED_ARG(sv);
+ PERL_UNUSED_ARG(RX);
+ PERL_UNUSED_ARG(sv);
#if XSH_HAS_PERL(5, 19, 1)
- PERL_UNUSED_ARG(strbeg);
+ PERL_UNUSED_ARG(strbeg);
#endif
- PERL_UNUSED_ARG(strpos);
- PERL_UNUSED_ARG(strend);
- PERL_UNUSED_ARG(flags);
- PERL_UNUSED_ARG(data);
- return NULL;
+ PERL_UNUSED_ARG(strpos);
+ PERL_UNUSED_ARG(strend);
+ PERL_UNUSED_ARG(flags);
+ PERL_UNUSED_ARG(data);
+
+ return NULL;
}
SV *
Plugin_checkstr(pTHX_ REGEXP * const RX)
{
- PERL_UNUSED_ARG(RX);
- return NULL;
+ PERL_UNUSED_ARG(RX);
+
+ return NULL;
}
void
Plugin_free(pTHX_ REGEXP * const RX)
{
- struct regexp *rx;
- re__engine__Plugin self;
+ struct regexp *rx;
+ re__engine__Plugin self;
+ SV *callback;
+
+ if (PL_dirty)
+ return;
+
+ rx = rxREGEXP(RX);
+ SELF_FROM_PPRIVATE(self, rx->pprivate);
+
+ callback = self->cb_free;
- if (PL_dirty)
- return;
+ if (callback) {
+ dSP;
- rx = rxREGEXP(RX);
- SELF_FROM_PPRIVATE(self, rx->pprivate);
+ ENTER;
+ SAVETMPS;
- SvREFCNT_dec(self->pattern);
- SvREFCNT_dec(self->str);
+ PUSHMARK(SP);
+ XPUSHs(rx->pprivate);
+ PUTBACK;
- SvREFCNT_dec(self->cb_exec);
+ call_sv(callback, G_DISCARD);
- SvREFCNT_dec(self->cb_num_capture_buff_FETCH);
- SvREFCNT_dec(self->cb_num_capture_buff_STORE);
- SvREFCNT_dec(self->cb_num_capture_buff_LENGTH);
+ PUTBACK;
+ FREETMPS;
+ LEAVE;
+ }
- self->rx = NULL;
- Safefree(self);
+ SvREFCNT_dec(self->pattern);
+ SvREFCNT_dec(self->str);
+ SvREFCNT_dec(self->stash);
-/*
- dSP;
- SV * callback;
+ SvREFCNT_dec(self->cb_exec);
- callback = self->cb_free;
+ SvREFCNT_dec(self->cb_num_capture_buff_FETCH);
+ SvREFCNT_dec(self->cb_num_capture_buff_STORE);
+ SvREFCNT_dec(self->cb_num_capture_buff_LENGTH);
- if (callback) {
- ENTER;
- SAVETMPS;
+ self->rx = NULL;
- PUSHMARK(SP);
- XPUSHs(rx->pprivate);
- PUTBACK;
+ XSH_LOCAL_FREE(self, 1, struct replug);
- call_sv(callback, G_DISCARD);
+ SvREFCNT_dec(rx->pprivate);
- PUTBACK;
- FREETMPS;
- LEAVE;
- }
- return;
-*/
+ return;
}
void *
Plugin_dupe(pTHX_ REGEXP * const RX, CLONE_PARAMS *param)
{
- struct regexp *rx = rxREGEXP(RX);
- Perl_croak(aTHX_ "dupe not supported yet");
- return rx->pprivate;
+ struct regexp *rx = rxREGEXP(RX);
+
+ Perl_croak(aTHX_ "dupe not supported yet");
+
+ return rx->pprivate;
}
Plugin_numbered_buff_FETCH(pTHX_ REGEXP * const RX, const I32 paren,
SV * const sv)
{
- dSP;
- I32 items;
- SV * callback;
- struct regexp *rx = rxREGEXP(RX);
- GET_SELF_FROM_PPRIVATE(rx->pprivate);
-
- callback = self->cb_num_capture_buff_FETCH;
-
- if (callback) {
- ENTER;
- SAVETMPS;
-
- PUSHMARK(SP);
- XPUSHs(rx->pprivate);
- XPUSHs(sv_2mortal(newSViv(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);
- }
+ 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_numbered_buff_STORE(pTHX_ REGEXP * const RX, const I32 paren,
SV const * const value)
{
- dSP;
- SV * callback;
- struct regexp *rx = rxREGEXP(RX);
- GET_SELF_FROM_PPRIVATE(rx->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;
+ callback = self->cb_num_capture_buff_STORE;
- if (callback) {
- ENTER;
- SAVETMPS;
+ if (callback) {
+ dSP;
- PUSHMARK(SP);
- XPUSHs(rx->pprivate);
- XPUSHs(sv_2mortal(newSViv(paren)));
- XPUSHs((SV *) value);
- PUTBACK;
+ ENTER;
+ SAVETMPS;
- call_sv(callback, G_DISCARD);
+ PUSHMARK(SP);
+ XPUSHs(rx->pprivate);
+ mXPUSHi(paren);
+ XPUSHs((SV *) value);
+ PUTBACK;
- PUTBACK;
- FREETMPS;
- LEAVE;
- }
+ call_sv(callback, G_DISCARD);
+
+ PUTBACK;
+ FREETMPS;
+ LEAVE;
+ }
}
I32
Plugin_numbered_buff_LENGTH(pTHX_ REGEXP * const RX, const SV * const sv,
- const I32 paren)
+ const I32 paren)
{
- dSP;
- SV * callback;
- struct regexp *rx = rxREGEXP(RX);
- GET_SELF_FROM_PPRIVATE(rx->pprivate);
+ struct regexp *rx;
+ re__engine__Plugin self;
+ SV *callback;
- callback = self->cb_num_capture_buff_LENGTH;
+ rx = rxREGEXP(RX);
+ SELF_FROM_PPRIVATE(self, rx->pprivate);
- if (callback) {
- IV ret;
+ callback = self->cb_num_capture_buff_LENGTH;
- ENTER;
- SAVETMPS;
+ if (callback) {
+ IV ret;
+ dSP;
- PUSHMARK(SP);
- XPUSHs(rx->pprivate);
- XPUSHs(sv_2mortal(newSViv(paren)));
- PUTBACK;
+ ENTER;
+ SAVETMPS;
- call_sv(callback, G_SCALAR);
+ PUSHMARK(SP);
+ XPUSHs(rx->pprivate);
+ mXPUSHi(paren);
+ PUTBACK;
- SPAGAIN;
+ call_sv(callback, G_SCALAR);
- ret = POPi;
+ SPAGAIN;
- PUTBACK;
- FREETMPS;
- LEAVE;
+ ret = POPi;
- return (I32)ret;
- } else {
- /* TODO: call FETCH and get the length on that value */
- return 0;
- }
-}
+ PUTBACK;
+ FREETMPS;
+ LEAVE;
+ return (I32) ret;
+ } else {
+ /* TODO: call FETCH and get the length on that value */
+ return 0;
+ }
+}
-SV*
-Plugin_named_buff (pTHX_ REGEXP * const RX, SV * const key, SV * const value,
- const U32 flags)
+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_iter (pTHX_ REGEXP * const RX, const SV * const lastkey,
- const U32 flags)
+SV *
+Plugin_named_buff_iter(pTHX_ REGEXP * const RX, const SV * const lastkey,
+ const U32 flags)
{
- return NULL;
+ return NULL;
}
-SV*
+SV *
Plugin_package(pTHX_ REGEXP * const RX)
{
- PERL_UNUSED_ARG(RX);
- return newSVpvs("re::engine::Plugin");
+ PERL_UNUSED_ARG(RX);
+
+ return newSVpvs(XSH_PACKAGE);
}
static void xsh_user_global_setup(pTHX) {
- HV *stash;
+ 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));
+ stash = gv_stashpvn(XSH_PACKAGE, XSH_PACKAGE_LEN, 1);
+ newCONSTSUB(stash, "REP_THREADSAFE", newSVuv(XSH_THREADSAFE));
+ newCONSTSUB(stash, "REP_FORKSAFE", newSVuv(XSH_FORKSAFE));
- return;
+ return;
}
/* --- XS ------------------------------------------------------------------ */
BOOT:
{
- xsh_setup();
+ xsh_setup();
}
#if XSH_THREADSAFE
void
CLONE(...)
PPCODE:
- xsh_clone();
- XSRETURN(0);
+ xsh_clone();
+ XSRETURN(0);
#endif /* XSH_THREADSAFE */
void
pattern(re::engine::Plugin self, ...)
PPCODE:
- XPUSHs(self->pattern);
+ XPUSHs(self->pattern);
+ XSRETURN(1);
void
str(re::engine::Plugin self, ...)
PPCODE:
- XPUSHs(self->str);
+ XPUSHs(self->str);
+ XSRETURN(1);
void
mod(re::engine::Plugin self)
PREINIT:
- U32 flags;
- char mods[5 + 1];
- int n = 0, i;
+ 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);
+ 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);
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);
- }
+ 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);
+ }
void
minlen(re::engine::Plugin self, ...)
PPCODE:
- if (items > 1) {
- self->rx->minlen = (I32)SvIV(ST(1));
- XSRETURN_EMPTY;
- } else {
- if (self->rx->minlen) {
- XPUSHs(sv_2mortal(newSViv(self->rx->minlen)));
- } else {
- XPUSHs(sv_2mortal(&PL_sv_undef));
- }
- }
+ 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;
+ }
void
gofs(re::engine::Plugin self, ...)
PPCODE:
- if (items > 1) {
- self->rx->gofs = (U32)SvIV(ST(1));
- XSRETURN_EMPTY;
- } else {
- if (self->rx->gofs) {
- XPUSHs(sv_2mortal(newSVuv(self->rx->gofs)));
- } else {
- XPUSHs(sv_2mortal(&PL_sv_undef));
- }
- }
+ 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;
+ }
void
nparens(re::engine::Plugin self, ...)
PPCODE:
- if (items > 1) {
- self->rx->nparens = (U32)SvIV(ST(1));
- XSRETURN_EMPTY;
- } else {
- if (self->rx->nparens) {
- XPUSHs(sv_2mortal(newSVuv(self->rx->nparens)));
- } else {
- XPUSHs(sv_2mortal(&PL_sv_undef));
- }
- }
+ 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);
- }
+ 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
_num_capture_buff_FETCH(re::engine::Plugin self, ...)
PPCODE:
- 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);
- }
+ 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);
- }
+ 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);
- }
+ 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)
+_tag(SV *comp, SV *exec, SV *free)
PREINIT:
- xsh_hints_user_t arg;
+ xsh_hints_user_t arg;
CODE:
- arg.comp = comp;
- arg.exec = exec;
- RETVAL = xsh_hints_tag(&arg);
+ arg.comp = comp;
+ arg.exec = exec;
+ arg.free = free;
+ RETVAL = xsh_hints_tag(&arg);
OUTPUT:
- RETVAL
+ RETVAL
void
ENGINE()
PPCODE:
- XPUSHs(sv_2mortal(newSViv(PTR2IV(&engine_plugin))));
+ mXPUSHi(PTR2IV(&engine_plugin));
+ XSRETURN(1);
projects / perl / modules / re-engine-Plugin.git / blobdiff