X-Git-Url: http://git.vpit.fr/?a=blobdiff_plain;f=Plugin.xs;h=6d003d9c53272b2a9358d8633d31e052dc38796d;hb=dd88e700bfcc92fc03db9d994ec747ca1c14ade7;hp=e9d1307a58d92df669fcb66abbecca469f032852;hpb=2dd7bc5f80da4fe2220e28de1102641c239d084c;p=perl%2Fmodules%2Fre-engine-Plugin.git

diff --git a/Plugin.xs b/Plugin.xs
index e9d1307..6d003d9 100644
--- a/Plugin.xs
+++ b/Plugin.xs
@@ -67,7 +67,7 @@ Plugin_comp(pTHX_ const SV * const pattern, const U32 flags)
     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 */
+    /* Precompiled regexp for pp_regcomp to use */
     rx->prelen = plen;
     rx->precomp = savepvn(exp, rx->prelen);
 
@@ -126,32 +126,36 @@ Plugin_exec(pTHX_ REGEXP * const rx, char *stringarg, char *strend,
     SV * callback = get_H_callback("exec");
     GET_SELF_FROM_PPRIVATE(rx->pprivate);
 
-    /* Store the current str for ->str */
-    self->str = (SV*)sv;
-    SvREFCNT_inc(self->str);
+    if (callback) {
+        /* Store the current str for ->str */
+        self->str = (SV*)sv;
+        SvREFCNT_inc(self->str);
 
-    ENTER;
-    SAVETMPS;
+        ENTER;
+        SAVETMPS;
    
-    PUSHMARK(SP);
-    XPUSHs(rx->pprivate);
-    XPUSHs(sv);
-    PUTBACK;
+        PUSHMARK(SP);
+        XPUSHs(rx->pprivate);
+        XPUSHs(sv);
+        PUTBACK;
 
-    call_sv(callback, G_SCALAR);
+        call_sv(callback, G_SCALAR);
  
-    SPAGAIN;
+        SPAGAIN;
 
-    SV * ret = POPs;
+        SV * ret = POPs;
 
-    if (SvTRUE(ret))
-        matched = 1;
-    else
-        matched = 0;
+        if (SvTRUE(ret))
+            matched = 1;
+        else
+            matched = 0;
 
-    PUTBACK;
-    FREETMPS;
-    LEAVE;
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+    } else {
+        matched = 0;
+    }
 
     return matched;
 }
@@ -212,7 +216,6 @@ Plugin_dupe(pTHX_ const REGEXP * rx, CLONE_PARAMS *param)
     return rx->pprivate;
 }
 
-
 void
 Plugin_numbered_buff_FETCH(pTHX_ REGEXP * const rx, const I32 paren,
                            SV * const sv)
@@ -288,9 +291,7 @@ Plugin_numbered_buff_LENGTH(pTHX_ REGEXP * const rx, const SV * const sv,
     dSP;
     I32 items;
     SV * callback;
-    re__engine__Plugin self;
-
-    SELF_FROM_PPRIVATE(self,rx->pprivate);
+    GET_SELF_FROM_PPRIVATE(rx->pprivate);
 
     callback = self->cb_num_capture_buff_LENGTH;
 
@@ -324,11 +325,262 @@ Plugin_numbered_buff_LENGTH(pTHX_ REGEXP * const rx, const SV * const sv,
 SV*
 Plugin_named_buff_FETCH(pTHX_ REGEXP * const rx, SV * const key, U32 flags)
 {
-    PERL_UNUSED_ARG(rx);
-    PERL_UNUSED_ARG(key);
-    PERL_UNUSED_ARG(flags);
+    dSP;
+    SV * callback;
+    GET_SELF_FROM_PPRIVATE(rx->pprivate);
 
-    return NULL;
+    callback = self->cb_named_capture_buff_FETCH;
+
+    if (callback) {
+        ENTER;
+        SAVETMPS;
+   
+        PUSHMARK(SP);
+        XPUSHs(rx->pprivate);
+        XPUSHs(SvREFCNT_inc(key));
+        XPUSHs(sv_2mortal(newSViv(flags & 1 ? 1 : 0)));
+        PUTBACK;
+
+        call_sv(callback, G_SCALAR);
+
+        SPAGAIN;
+
+        SV* ret = POPs;
+        SvREFCNT_inc(ret);
+
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+
+        return ret;
+    } else {
+        return NULL;
+    }
+}
+
+void
+Plugin_named_buff_STORE(pTHX_ REGEXP * const rx, SV * const key,
+                        SV * const value, const U32 flags)
+{
+    dSP;
+    SV * callback;
+    GET_SELF_FROM_PPRIVATE(rx->pprivate);
+
+    callback = self->cb_named_capture_buff_STORE;
+
+    if (callback) {
+        ENTER;
+        SAVETMPS;
+   
+        PUSHMARK(SP);
+        XPUSHs(rx->pprivate);
+        XPUSHs(SvREFCNT_inc(key));
+        XPUSHs(SvREFCNT_inc(value));
+        XPUSHs(sv_2mortal(newSViv(flags)));
+        PUTBACK;
+
+        call_sv(callback, G_DISCARD);
+
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+    }
+}
+
+void
+Plugin_named_buff_DELETE(pTHX_ REGEXP * const rx, SV * const key, const U32 flags)
+{
+    dSP;
+    SV * callback;
+    GET_SELF_FROM_PPRIVATE(rx->pprivate);
+
+    callback = self->cb_named_capture_buff_DELETE;
+
+    if (callback) {
+        ENTER;
+        SAVETMPS;
+   
+        PUSHMARK(SP);
+        XPUSHs(rx->pprivate);
+        XPUSHs(SvREFCNT_inc(key));
+        XPUSHs(sv_2mortal(newSViv(flags)));
+        PUTBACK;
+
+        call_sv(callback, G_DISCARD);
+
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+    }
+}
+
+void
+Plugin_named_buff_CLEAR(pTHX_ REGEXP * const rx, const U32 flags)
+{
+    dSP;
+    SV * callback;
+    GET_SELF_FROM_PPRIVATE(rx->pprivate);
+
+    callback = self->cb_named_capture_buff_CLEAR;
+
+    if (callback) {
+        ENTER;
+        SAVETMPS;
+   
+        PUSHMARK(SP);
+        XPUSHs(rx->pprivate);
+        XPUSHs(sv_2mortal(newSViv(flags)));
+        PUTBACK;
+
+        call_sv(callback, G_DISCARD);
+
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+    }
+}
+
+bool
+Plugin_named_buff_EXISTS(pTHX_ REGEXP * const rx, SV * const key,
+                         const U32 flags)
+{
+    dSP;
+    SV * callback;
+    bool truthiness = FALSE;
+    GET_SELF_FROM_PPRIVATE(rx->pprivate);
+
+    callback = self->cb_named_capture_buff_EXISTS;
+
+    if (callback) {
+        ENTER;
+        SAVETMPS;
+   
+        PUSHMARK(SP);
+        XPUSHs(rx->pprivate);
+        XPUSHs(SvREFCNT_inc(key));
+        XPUSHs(sv_2mortal(newSViv(flags)));
+        PUTBACK;
+
+        call_sv(callback, G_SCALAR);
+
+        SPAGAIN;
+
+        SV * ret = POPs;
+        truthiness = SvTRUE(ret);
+
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+    }
+
+    return truthiness;
+}
+
+SV*
+Plugin_named_buff_FIRSTKEY(pTHX_ REGEXP * const rx, const U32 flags)
+{
+    dSP;
+    SV * callback;
+    GET_SELF_FROM_PPRIVATE(rx->pprivate);
+
+    callback = self->cb_named_capture_buff_FIRSTKEY;
+
+    if (callback) {
+        ENTER;
+        SAVETMPS;
+   
+        PUSHMARK(SP);
+        XPUSHs(rx->pprivate);
+        XPUSHs(sv_2mortal(newSViv(flags)));
+        PUTBACK;
+
+        call_sv(callback, G_SCALAR);
+
+        SPAGAIN;
+
+        SV * ret = POPs;
+        SvREFCNT_inc(ret);
+
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+
+        return ret;
+    } else {
+        return NULL;
+    }
+}
+
+SV*
+Plugin_named_buff_NEXTKEY(pTHX_ REGEXP * const rx, SV * const lastkey,
+                          const U32 flags)
+{
+    dSP;
+    SV * callback;
+    GET_SELF_FROM_PPRIVATE(rx->pprivate);
+
+    callback = self->cb_named_capture_buff_NEXTKEY;
+
+    if (callback) {
+        ENTER;
+        SAVETMPS;
+   
+        PUSHMARK(SP);
+        XPUSHs(rx->pprivate);
+        XPUSHs(SvREFCNT_inc(lastkey));
+        XPUSHs(sv_2mortal(newSViv(flags)));
+        PUTBACK;
+
+        call_sv(callback, G_SCALAR);
+
+        SPAGAIN;
+
+        SV * ret = POPs;
+        SvREFCNT_inc(ret);
+
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+
+        return ret;
+    } else {
+        return NULL;
+    }
+}
+
+SV*
+Plugin_named_buff_SCALAR(pTHX_ REGEXP * const rx, const U32 flags)
+{
+    dSP;
+    SV * callback;
+    GET_SELF_FROM_PPRIVATE(rx->pprivate);
+
+    callback = self->cb_named_capture_buff_SCALAR;
+
+    if (callback) {
+        ENTER;
+        SAVETMPS;
+   
+        PUSHMARK(SP);
+        XPUSHs(rx->pprivate);
+        XPUSHs(sv_2mortal(newSViv(flags)));
+        PUTBACK;
+
+        call_sv(callback, G_SCALAR);
+
+        SPAGAIN;
+
+        SV * ret = POPs;
+        SvREFCNT_inc(ret);
+
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+
+        return ret;
+    } else {
+        return NULL;
+    }
 }
 
 SV*
@@ -339,25 +591,19 @@ Plugin_package(pTHX_ REGEXP * const rx)
 }
 
 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*
+void
 mod(re::engine::Plugin self, ...)
 PPCODE:
     /* /i */
@@ -390,50 +636,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, ...)
@@ -459,6 +713,70 @@ PPCODE:
         SvREFCNT_inc(self->cb_num_capture_buff_LENGTH);
     }
 
+void
+_named_capture_buff_FETCH(re::engine::Plugin self, ...)
+PPCODE:
+    if (items > 1) {
+        self->cb_named_capture_buff_FETCH = ST(1);
+        SvREFCNT_inc(self->cb_named_capture_buff_FETCH);
+    }
+
+void
+_named_capture_buff_STORE(re::engine::Plugin self, ...)
+PPCODE:
+    if (items > 1) {
+        self->cb_named_capture_buff_STORE = ST(1);
+        SvREFCNT_inc(self->cb_named_capture_buff_STORE);
+    }
+
+void
+_named_capture_buff_DELETE(re::engine::Plugin self, ...)
+PPCODE:
+    if (items > 1) {
+        self->cb_named_capture_buff_DELETE = ST(1);
+        SvREFCNT_inc(self->cb_named_capture_buff_DELETE);
+    }
+
+void
+_named_capture_buff_CLEAR(re::engine::Plugin self, ...)
+PPCODE:
+    if (items > 1) {
+        self->cb_named_capture_buff_CLEAR = ST(1);
+        SvREFCNT_inc(self->cb_named_capture_buff_CLEAR);
+    }
+
+void
+_named_capture_buff_EXISTS(re::engine::Plugin self, ...)
+PPCODE:
+    if (items > 1) {
+        self->cb_named_capture_buff_EXISTS = ST(1);
+        SvREFCNT_inc(self->cb_named_capture_buff_EXISTS);
+    }
+
+void
+_named_capture_buff_FIRSTKEY(re::engine::Plugin self, ...)
+PPCODE:
+    if (items > 1) {
+        self->cb_named_capture_buff_FIRSTKEY = ST(1);
+        SvREFCNT_inc(self->cb_named_capture_buff_FIRSTKEY);
+    }
+
+void
+_named_capture_buff_NEXTKEY(re::engine::Plugin self, ...)
+PPCODE:
+    if (items > 1) {
+        self->cb_named_capture_buff_NEXTKEY = ST(1);
+        SvREFCNT_inc(self->cb_named_capture_buff_NEXTKEY);
+    }
+
+void
+_named_capture_buff_SCALAR(re::engine::Plugin self, ...)
+PPCODE:
+    if (items > 1) {
+        self->cb_named_capture_buff_SCALAR = ST(1);
+        SvREFCNT_inc(self->cb_named_capture_buff_SCALAR);
+    }
+
 void
 ENGINE()
 PPCODE: