Fix building with blead

[perl/modules/re-engine-Plugin.git] / Plugin.xs

diff --git a/Plugin.xs b/Plugin.xs
index d0bc33e17af8e025562883321f675d99ca57a6a8..2aeb2b951268e4858836f8f75c1a3292602c0992 100644 (file)
--- a/Plugin.xs
+++ b/Plugin.xs
@@ -39,21 +39,21 @@ get_H_callback(const char* key)
 }
 
 REGEXP *
+#if PERL_VERSION <= 10
 Plugin_comp(pTHX_ const SV * const pattern, const U32 flags)
+#else
+Plugin_comp(pTHX_ SV * const pattern, U32 flags)
+#endif
 {
     dSP;
-    REGEXP * rx;
+    struct regexp * rx;
+    REGEXP *RX;
     re__engine__Plugin re;
-    I32 count;
     I32 buffers;
 
     /* exp/xend version of the pattern & length */
     STRLEN plen;
     char*  exp = SvPV((SV*)pattern, plen);
-    char* xend = exp + plen;
-
-    /* The REGEXP structure to return to perl */
-    Newxz(rx, 1, REGEXP);
 
     /* Our blessed object */
     SV *obj = newSV(0);
@@ -61,13 +61,18 @@ Plugin_comp(pTHX_ const SV * const pattern, const U32 flags)
     Newxz(re, 1, struct replug);
     sv_setref_pv(obj, "re::engine::Plugin", (void*)re);
 
+    newREGEXP(RX);
+    rx = rxREGEXP(RX);
+
     re->rx = rx;                   /* Make the rx accessible from self->rx */
-    rx->refcnt = 1;                /* Refcount so we won' be destroyed */
     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 a precompiled regexp for pp_regcomp to use */
+#if PERL_VERSION <= 10
+    rx->refcnt = 1;                /* Refcount so we won't be destroyed */
+
+    /* Precompiled pattern for pp_regcomp to use */
     rx->prelen = plen;
     rx->precomp = savepvn(exp, rx->prelen);
 
@@ -77,6 +82,7 @@ Plugin_comp(pTHX_ const SV * const pattern, const U32 flags)
     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;
@@ -112,18 +118,19 @@ Plugin_comp(pTHX_ const SV * const pattern, const U32 flags)
 
     buffers = rx->nparens;
 
-    Newxz(rx->offs, buffers, regexp_paren_pair);
+    Newxz(rx->offs, buffers + 1, regexp_paren_pair);
 
-    return rx;
+    return RX;
 }
 
 I32
-Plugin_exec(pTHX_ REGEXP * const rx, char *stringarg, char *strend,
+Plugin_exec(pTHX_ REGEXP * const RX, char *stringarg, char *strend,
             char *strbeg, I32 minend, SV *sv, void *data, U32 flags)
 {
     dSP;
     I32 matched;
     SV * callback = get_H_callback("exec");
+    struct regexp *rx = rxREGEXP(RX);
     GET_SELF_FROM_PPRIVATE(rx->pprivate);
 
     if (callback) {
@@ -161,10 +168,10 @@ Plugin_exec(pTHX_ REGEXP * const rx, char *stringarg, char *strend,
 }
 
 char *
-Plugin_intuit(pTHX_ REGEXP * const rx, SV *sv, char *strpos,
+Plugin_intuit(pTHX_ REGEXP * const RX, SV *sv, char *strpos,
                      char *strend, U32 flags, re_scream_pos_data *data)
 {
-    PERL_UNUSED_ARG(rx);
+    PERL_UNUSED_ARG(RX);
     PERL_UNUSED_ARG(sv);
     PERL_UNUSED_ARG(strpos);
     PERL_UNUSED_ARG(strend);
@@ -174,16 +181,16 @@ Plugin_intuit(pTHX_ REGEXP * const rx, SV *sv, char *strpos,
 }
 
 SV *
-Plugin_checkstr(pTHX_ REGEXP * const rx)
+Plugin_checkstr(pTHX_ REGEXP * const RX)
 {
-    PERL_UNUSED_ARG(rx);
+    PERL_UNUSED_ARG(RX);
     return NULL;
 }
 
 void
-Plugin_free(pTHX_ REGEXP * const rx)
+Plugin_free(pTHX_ REGEXP * const RX)
 {
-    PERL_UNUSED_ARG(rx);
+    PERL_UNUSED_ARG(RX);
 /*
     dSP;
     SV * callback;
@@ -210,20 +217,22 @@ Plugin_free(pTHX_ REGEXP * const rx)
 }
 
 void *
-Plugin_dupe(pTHX_ const REGEXP * rx, CLONE_PARAMS *param)
+Plugin_dupe(pTHX_ REGEXP * const RX, CLONE_PARAMS *param)
 {
-    Perl_croak("dupe not supported yet");
+    struct regexp *rx = rxREGEXP(RX);
+    Perl_croak(aTHX_ "dupe not supported yet");
     return rx->pprivate;
 }
 
 
 void
-Plugin_numbered_buff_FETCH(pTHX_ REGEXP * const rx, const I32 paren,
+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;
@@ -257,12 +266,12 @@ Plugin_numbered_buff_FETCH(pTHX_ REGEXP * const rx, const I32 paren,
 }
 
 void
-Plugin_numbered_buff_STORE(pTHX_ REGEXP * const rx, const I32 paren,
+Plugin_numbered_buff_STORE(pTHX_ REGEXP * const RX, const I32 paren,
                            SV const * const value)
 {
     dSP;
-    I32 items;
     SV * callback;
+    struct regexp *rx = rxREGEXP(RX);
     GET_SELF_FROM_PPRIVATE(rx->pprivate);
 
     callback = self->cb_num_capture_buff_STORE;
@@ -286,15 +295,13 @@ Plugin_numbered_buff_STORE(pTHX_ REGEXP * const rx, const I32 paren,
 }
 
 I32
-Plugin_numbered_buff_LENGTH(pTHX_ REGEXP * const rx, const SV * const sv,
+Plugin_numbered_buff_LENGTH(pTHX_ REGEXP * const RX, const SV * const sv,
                               const I32 paren)
 {
     dSP;
-    I32 items;
     SV * callback;
-    re__engine__Plugin self;
-
-    SELF_FROM_PPRIVATE(self,rx->pprivate);
+    struct regexp *rx = rxREGEXP(RX);
+    GET_SELF_FROM_PPRIVATE(rx->pprivate);
 
     callback = self->cb_num_capture_buff_LENGTH;
 
@@ -326,44 +333,38 @@ Plugin_numbered_buff_LENGTH(pTHX_ REGEXP * const rx, const SV * const sv,
 
 
 SV*
-Plugin_named_buff (pTHX_ REGEXP * const rx, SV * const key, SV * const value,
+Plugin_named_buff (pTHX_ REGEXP * const RX, SV * const key, SV * const value,
                    const U32 flags)
 {
     return NULL;
 }
 
 SV*
-Plugin_named_buff_iter (pTHX_ REGEXP * const rx, const SV * const lastkey,
+Plugin_named_buff_iter (pTHX_ REGEXP * const RX, const SV * const lastkey,
                         const U32 flags)
 {
     return NULL;
 }
 
 SV*
-Plugin_package(pTHX_ REGEXP * const rx)
+Plugin_package(pTHX_ REGEXP * const RX)
 {
-    PERL_UNUSED_ARG(rx);
+    PERL_UNUSED_ARG(RX);
     return newSVpvs("re::engine::Plugin");
 }
 
 MODULE = re::engine::Plugin    PACKAGE = re::engine::Plugin
-PROTOTYPES: ENABLE
+PROTOTYPES: DISABLE
 
-SV *
+void
 pattern(re::engine::Plugin self, ...)
-CODE:
-    SvREFCNT_inc(self->pattern);
-    RETVAL = self->pattern;
-OUTPUT:
-    RETVAL
+PPCODE:
+    XPUSHs(self->pattern);
 
-SV *
+void
 str(re::engine::Plugin self, ...)
-CODE:
-    SvREFCNT_inc(self->str);
-    RETVAL = self->str;
-OUTPUT:
-    RETVAL
+PPCODE:
+    XPUSHs(self->str);
 
 char*
 mod(re::engine::Plugin self, ...)
@@ -398,50 +399,58 @@ PPCODE:
       XPUSHs(&PL_sv_yes);
     }
 
-SV *
+void
 stash(re::engine::Plugin self, ...)
-PREINIT:
-    SV * stash;
-CODE:
+PPCODE:
     if (items > 1) {
-        self->stash = sv_mortalcopy(ST(1));
+        self->stash = ST(1);
         SvREFCNT_inc(self->stash);
+        XSRETURN_EMPTY;
+    } else {
+        XPUSHs(self->stash);
     }
-    SvREFCNT_inc(self->stash);
-    RETVAL = self->stash;
-OUTPUT:
-    RETVAL
 
-SV *
+void
 minlen(re::engine::Plugin self, ...)
-CODE:
+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));
+        }
     }
 
-    RETVAL = self->rx->minlen ? newSViv(self->rx->minlen) : &PL_sv_undef;
-OUTPUT:
-    RETVAL
-
-SV *
+void
 gofs(re::engine::Plugin self, ...)
-CODE:
+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));
+        }
     }
-    RETVAL = self->rx->gofs ? newSVuv(self->rx->gofs) : &PL_sv_undef;
-OUTPUT:
-    RETVAL
 
-SV *
+void
 nparens(re::engine::Plugin self, ...)
-CODE:
+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));
+        }
     }
-    RETVAL = self->rx->nparens ? newSVuv(self->rx->nparens) : &PL_sv_undef;
-OUTPUT:
-    RETVAL
 
 void
 _num_capture_buff_FETCH(re::engine::Plugin self, ...)