Add compiler side support for regsub() but only a dummy function in VRT.

git-svn-id: svn+ssh://projects.linpro.no/svn/varnish/trunk@1666 d4fa192b-c00b-0410-8231-f00ffab90ce4

diff --git a/varnish-cache/bin/varnishd/cache_vrt_re.c b/varnish-cache/bin/varnishd/cache_vrt_re.c
index fc61b85ef85cd076057b7c0ae27aba0d232556af..6fa2b651db9da73550b48f27d9dc45827092beac 100644 (file)
--- a/varnish-cache/bin/varnishd/cache_vrt_re.c
+++ b/varnish-cache/bin/varnishd/cache_vrt_re.c
@@ -45,14 +45,14 @@
 #include "cache.h"
 
 void
-VRT_re_init(void **rep, const char *re)
+VRT_re_init(void **rep, const char *re, int sub)
 {
        regex_t *t;
 
        t = calloc(sizeof *t, 1);
        XXXAN(t);
        /* This was already check-compiled by the VCL compiler */
-       AZ(regcomp(t, re, REG_EXTENDED | REG_NOSUB));
+       AZ(regcomp(t, re, REG_EXTENDED | (sub ? 0 : REG_NOSUB)));
        *rep = t;
 }
 
@@ -82,14 +82,14 @@ VRT_re_match(const char *s, void *re)
 }
 
 int
-VRT_re_test(struct vsb *sb, const char *re)
+VRT_re_test(struct vsb *sb, const char *re, int sub)
 {
        int i;
        regex_t t;
        char buf[BUFSIZ];
 
        memset(&t, 0, sizeof t);
-       i = regcomp(&t, re, REG_EXTENDED | REG_NOSUB);
+       i = regcomp(&t, re, REG_EXTENDED | (sub ? 0 : REG_NOSUB));
        if (i == 0) {
                regfree(&t);
                return (0);
@@ -99,3 +99,14 @@ VRT_re_test(struct vsb *sb, const char *re)
        regfree(&t);
        return (1);
 }
+
+char *
+VRT_regsub(struct sess *sp, const char *str, void *re, const char *sub)
+{
+       static char foo[4] = "FOO";
+       (void)sp;
+       (void)str;
+       (void)re;
+       (void)sub;
+       return (foo);
+}

diff --git a/varnish-cache/include/vrt.h b/varnish-cache/include/vrt.h
index 0a45732bd6e38404b56a9282a4641910b1da2abb..6dbf869afffd28eb214cbe43d0b26b936b0ce867 100644 (file)
--- a/varnish-cache/include/vrt.h
+++ b/varnish-cache/include/vrt.h
@@ -64,10 +64,11 @@ void VRT_acl_init(struct vrt_acl *);
 void VRT_acl_fini(struct vrt_acl *);
 
 /* Regexp related */
-void VRT_re_init(void **, const char *);
+void VRT_re_init(void **, const char *, int sub);
 void VRT_re_fini(void *);
 int VRT_re_match(const char *, void *re);
-int VRT_re_test(struct vsb *, const char *);
+int VRT_re_test(struct vsb *, const char *, int sub);
+char *VRT_regsub(struct sess *sp, const char *, void *, const char *);
 
 void VRT_count(struct sess *, unsigned);
 int VRT_rewrite(const char *, const char *);

diff --git a/varnish-cache/lib/libvcl/vcc_compile.h b/varnish-cache/lib/libvcl/vcc_compile.h
index bd7d64253735e8cc7b4fdea8c2d39dc90cc82527..dd0da2758ed768add8d0c4472f2a2c4352367b12 100644 (file)
--- a/varnish-cache/lib/libvcl/vcc_compile.h
+++ b/varnish-cache/lib/libvcl/vcc_compile.h
@@ -168,6 +168,7 @@ unsigned vcc_UintVal(struct tokenlist *tl);
 double vcc_DoubleVal(struct tokenlist *tl);
 
 /* vcc_string.c */
+char *vcc_regexp(struct tokenlist *tl, int sub);
 int vcc_StringVal(struct tokenlist *tl);
 void vcc_ExpectedStringval(struct tokenlist *tl);
 

diff --git a/varnish-cache/lib/libvcl/vcc_fixed_token.c b/varnish-cache/lib/libvcl/vcc_fixed_token.c
index a4fb3f746b3d2781eed82d21c860522a29480dd2..9d606baf1c88c6e54f997605f113e977d31d445b 100644 (file)
--- a/varnish-cache/lib/libvcl/vcc_fixed_token.c
+++ b/varnish-cache/lib/libvcl/vcc_fixed_token.c
@@ -420,10 +420,11 @@ vcl_output_lang_h(struct vsb *sb)
        vsb_cat(sb, "void VRT_acl_fini(struct vrt_acl *);\n");
        vsb_cat(sb, "\n");
        vsb_cat(sb, "/* Regexp related */\n");
-       vsb_cat(sb, "void VRT_re_init(void **, const char *);\n");
+       vsb_cat(sb, "void VRT_re_init(void **, const char *, int sub);\n");
        vsb_cat(sb, "void VRT_re_fini(void *);\n");
        vsb_cat(sb, "int VRT_re_match(const char *, void *re);\n");
-       vsb_cat(sb, "int VRT_re_test(struct vsb *, const char *);\n");
+       vsb_cat(sb, "int VRT_re_test(struct vsb *, const char *, int sub);\n");
+       vsb_cat(sb, "char *VRT_regsub(struct sess *sp, const char *, void *, const char *);\n");
        vsb_cat(sb, "\n");
        vsb_cat(sb, "void VRT_count(struct sess *, unsigned);\n");
        vsb_cat(sb, "int VRT_rewrite(const char *, const char *);\n");

diff --git a/varnish-cache/lib/libvcl/vcc_parse.c b/varnish-cache/lib/libvcl/vcc_parse.c
index a0860d0dfcdbd97debac7dbea48e5805f988e539..efba57cd1e1ed0a1b491ae00408435825471e847 100644 (file)
--- a/varnish-cache/lib/libvcl/vcc_parse.c
+++ b/varnish-cache/lib/libvcl/vcc_parse.c
@@ -218,41 +218,19 @@ vcc_RateVal(struct tokenlist *tl)
        Fb(tl, 0, "(%g * %g)", v, sc);
 }
 
-/*--------------------------------------------------------------------*/
-
-static void
-vcc_re(struct tokenlist *tl, const char *str, const struct token *re)
-{
-       char buf[32];
-
-       assert(re->tok == CSTR);
-       if (VRT_re_test(tl->sb, re->dec)) {
-               vcc_ErrWhere(tl, re);
-               return;
-       }
-       sprintf(buf, "VGC_re_%u", tl->recnt++);
-
-       Fb(tl, 1, "VRT_re_match(%s, %s)\n", str, buf);
-       Fh(tl, 0, "void *%s;\n", buf);
-       Fi(tl, 0, "\tVRT_re_init(&%s, ",buf);
-       EncToken(tl->fi, re);
-       Fi(tl, 0, ");\n");
-       Ff(tl, 0, "\tVRT_re_fini(%s);\n", buf);
-}
-
-
 /*--------------------------------------------------------------------*/
 
 static void
 Cond_String(const struct var *vp, struct tokenlist *tl)
 {
+       char *p;
 
        switch (tl->t->tok) {
        case '~':
                vcc_NextToken(tl);
-               ExpectErr(tl, CSTR);
-               vcc_re(tl, vp->rname, tl->t);
+               p = vcc_regexp(tl, 0);
                vcc_NextToken(tl);
+               Fb(tl, 1, "VRT_re_match(%s, %s)\n", vp->rname, p);
                break;
        case T_EQ:
        case T_NEQ:

diff --git a/varnish-cache/lib/libvcl/vcc_string.c b/varnish-cache/lib/libvcl/vcc_string.c
index ec7723d4a16c7169c286b99c3eae35a51f296101..6ec7a6a5361f73ab1137cacc0fc87f415c5ac425 100644 (file)
--- a/varnish-cache/lib/libvcl/vcc_string.c
+++ b/varnish-cache/lib/libvcl/vcc_string.c
@@ -38,6 +38,75 @@
 #include "vcc_compile.h"
 #include "libvarnish.h"
 
+#include "vrt.h"
+
+/*--------------------------------------------------------------------*/
+
+char *
+vcc_regexp(struct tokenlist *tl, int sub)
+{
+       char buf[32], *p;
+
+       Expect(tl, CSTR);
+       if (VRT_re_test(tl->sb, tl->t->dec, sub)) {
+               vcc_ErrWhere(tl, tl->t);
+               return (NULL);
+       }
+       sprintf(buf, "VGC_re_%u", tl->recnt++);
+       p = TlAlloc(tl, strlen(buf) + 1);
+       strcpy(p, buf);
+
+       Fh(tl, 0, "void *%s;\n", buf);
+       Fi(tl, 0, "\tVRT_re_init(&%s, ",buf);
+       EncToken(tl->fi, tl->t);
+       Fi(tl, 0, ", %d);\n", sub);
+       Ff(tl, 0, "\tVRT_re_fini(%s);\n", buf);
+       return (p);
+}
+
+/*--------------------------------------------------------------------*/
+
+static int
+vcc_regsub(struct tokenlist *tl)
+{
+       char *p;
+
+       vcc_NextToken(tl);
+
+       Fb(tl, 0, "VRT_regsub(sp, ");
+
+       Expect(tl, '(');
+       vcc_NextToken(tl);
+
+       if (!vcc_StringVal(tl)) {
+               vcc_ExpectedStringval(tl);
+               return (0);
+       }
+
+       Expect(tl, ',');
+       vcc_NextToken(tl);
+       
+       Expect(tl, CSTR);
+       p = vcc_regexp(tl, 1);
+       vcc_NextToken(tl);
+       Fb(tl, 0, ", %s, ", p);
+
+       Expect(tl, ',');
+       vcc_NextToken(tl);
+       
+       Expect(tl, CSTR);
+       if (!vcc_StringVal(tl)) {
+               vcc_ExpectedStringval(tl);
+               return (0);
+       }
+
+       Expect(tl, ')');
+       vcc_NextToken(tl);
+       Fb(tl, 0, ")");
+
+       return (1);
+}
+
 /*--------------------------------------------------------------------
  * Parse a string value and emit something that results in a usable
  * "const char *".
@@ -57,6 +126,8 @@ vcc_StringVal(struct tokenlist *tl)
                vcc_NextToken(tl);
                return (1);
        }
+       if (tl->t->tok == ID && vcc_IdIs(tl->t, "regsub"))
+               return (vcc_regsub(tl));
        if (tl->t->tok == VAR) {
                vp = vcc_FindVar(tl, tl->t, vcc_vars);
                if (tl->err)