RPA Toolkit
use ruledata blob
authorMartin Stoilov <martin@rpasearch.com>
Sun, 10 Apr 2011 02:06:44 +0000 (19:06 -0700)
committerMartin Stoilov <martin@rpasearch.com>
Sun, 10 Apr 2011 02:06:44 +0000 (19:06 -0700)
rpa2/rpacompiler.c
rpa2/rpacompiler.h
rpa2/rpadbex.c
rpa2/rpadbex.h
rpa2/rpaparser.c
rpa2/rpastat.c
rpa2/rpavm.c
rpa2/rpavm.h
rvm/rvmrelocmap.c
rvm/rvmrelocmap.h
testrpa2/build/linux/testrpa2.mk

index 6114ee8..b46178b 100644 (file)
@@ -177,6 +177,35 @@ void rpa_compiler_add_ruleuid_s(rpa_compiler_t *co, const rchar *name, ruint32 u
        rpa_compiler_add_ruleuid(co, name, r_strlen(name), uid);
 }
 
+#define RPA_RULEBLOB_SIZE (RPA_RULENAME_MAXSIZE + sizeof(rpa_ruledata_t) + 2*sizeof(rulong))
+
+rlong rpa_compiler_addblob(rpa_compiler_t *co, rlong ruleid, rlong ruleuid, rulong flags, const rchar *name, rulong namesize)
+{
+       rchar blob[RPA_RULEBLOB_SIZE];
+       rchar *ptr;
+       rpa_ruledata_t *pblob = (rpa_ruledata_t *)blob;
+
+       if (namesize >= RPA_RULENAME_MAXSIZE)
+               return -1;
+       r_memset(pblob, 0, RPA_RULEBLOB_SIZE);
+       ptr = blob + sizeof(rpa_ruledata_t);
+       pblob->name = ptr - blob;
+       pblob->ruleid = ruleid;
+       pblob->ruleuid = ruleuid;
+       pblob->flags = flags;
+       pblob->namesize = namesize;
+       r_strncpy(ptr, name, namesize);
+       ptr += namesize;
+       pblob->size = ptr - blob + 1;
+       return rvm_codegen_adddata_s(co->cg, NULL, pblob, pblob->size);
+}
+
+
+rlong rpa_compiler_addblob_s(rpa_compiler_t *co, rlong ruleid, rlong ruleuid, rulong flags, const rchar *name)
+{
+       return 0;
+}
+
 
 rint rpa_compiler_loop_begin(rpa_compiler_t *co, const rchar *name, ruint namesize)
 {
@@ -186,12 +215,14 @@ rint rpa_compiler_loop_begin(rpa_compiler_t *co, const rchar *name, ruint namesi
        r_memset(&exp, 0, sizeof(exp));
        exp.start = rvm_codegen_getcodesize(co->cg);
        exp.recuid = puid ? *puid : RPA_RECORD_INVALID_UID;
-       exp.emitidx = rvm_codegen_adddata_s(co->cg, NULL, name, namesize);
        exp.startidx = rvm_codegen_addlabel(co->cg, name, namesize);
        exp.endidx = rpa_codegen_invalid_add_numlabel_s(co->cg, "__end", exp.start);
        exp.successidx = rpa_codegen_invalid_add_numlabel_s(co->cg, "__success", exp.start);
        exp.failidx = rpa_codegen_invalid_add_numlabel_s(co->cg, "__fail", exp.start);
        exp.againidx = rpa_codegen_invalid_add_numlabel_s(co->cg, "__again", exp.start);
+       exp.dataidx = rpa_compiler_addblob(co, exp.start, exp.recuid, 0, name, namesize);
+       exp.dataidx = rvm_codegen_adddata_s(co->cg, NULL, name, namesize);
+
 
        rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, R_RID, DA, XX, exp.start));
        rvm_codegen_addins(co->cg, rvm_asm(RPA_LOOPDETECT, R_RID, R_TOP, XX, 0));
@@ -201,17 +232,13 @@ rint rpa_compiler_loop_begin(rpa_compiler_t *co, const rchar *name, ruint namesi
        rvm_codegen_addins(co->cg, rvm_asm(RVM_MOVS, R0, DA, XX, -1));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_ADD, R_TOP, R_TOP, R0, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_BX, LR, XX, XX, 0));
-//     rvm_codegen_addins(co->cg, rvm_asm(RPA_CHECKCACHE, DA, R_TOP, XX, exp.start));
-//     rvm_codegen_addins(co->cg, rvm_asm(RVM_BXGRE, LR, XX, XX, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RPA_GETRECLEN, R0, XX, XX, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_CLR, R_LOO, XX, XX, 0));
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSHM, DA, XX, XX, BIT(R0)|BIT(R_RID)|BIT(R_LOO)|BIT(R_TOP)|BIT(R_REC)|BIT(FP)|BIT(LR)));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSHM, DA, XX, XX, BIT(R0)|BIT(R_RID)|BIT(R_LOO)|BIT(R_TOP)|BIT(FP)|BIT(LR)));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, FP, SP, XX, 0));
 
        exp.loopidx = rpa_codegen_add_numlabel_s(co->cg, "__loop", exp.start);
-       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_STRING, exp.emitidx, rvm_asm(RPA_EMITSTART, DA, R_TOP, XX, 0));
-       rvm_codegen_addins(co->cg, rvm_asm(RPA_SETRECID, DA, XX, XX, exp.start));
-       rvm_codegen_addins(co->cg, rvm_asm(RPA_SETRECUID, DA, XX, XX, exp.recuid));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BLOB, exp.dataidx, rvm_asm(RPA_EMITSTART, DA, R_TOP, XX, 0));
        r_array_add(co->expressions, &exp);
        return 0;
 }
@@ -233,14 +260,14 @@ rint rpa_compiler_loop_end(rpa_compiler_t *co)
         * Load R_TOP from the stack and check if we have made a progress
         * Load the old R_TOP, without popping it from the stack.
         */
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_LDS, R2, SP, DA, -3));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_LDS, R2, SP, DA, -2));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_SUBS, R0, R_TOP, R2, 0));
        rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, exp.againidx, rvm_asm(RVM_BGRE, DA, XX, XX, 0));
 
        /*
         * If R_LOO is 0, nothing matched - goto end
         */
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_LDS, R_LOO, SP, DA, -4));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_LDS, R_LOO, SP, DA, -3));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_CMP, R_LOO, DA, XX, 0));
        rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, exp.successidx, rvm_asm(RVM_BGRE, DA, XX, XX, 0));
        rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, exp.failidx, rvm_asm(RVM_B, DA, XX, XX, 0));
@@ -250,13 +277,11 @@ rint rpa_compiler_loop_end(rpa_compiler_t *co)
         */
        rvm_codegen_redefinelabel(co->cg, exp.againidx);
        rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, R_LOO, R0, XX, 0));
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_STS, R_LOO, SP, DA, -4));
-       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_STRING, exp.emitidx, rvm_asm(RPA_EMITEND, DA, R2, R0, 0));
-       rvm_codegen_addins(co->cg, rvm_asm(RPA_SETRECID, DA, XX, XX, exp.start));
-       rvm_codegen_addins(co->cg, rvm_asm(RPA_SETRECUID, DA, XX, XX, exp.recuid));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_STS, R_LOO, SP, DA, -3));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BLOB, exp.dataidx, rvm_asm(RPA_EMITEND, DA, R2, R0, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, R_TOP, R2, XX, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RPA_GETRECLEN, R1, XX, XX, 0));
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_STS, R1, SP, DA, -6));           /* Store the record lenngth directly on the stack */
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_STS, R1, SP, DA, -5));           /* Store the record lenngth directly on the stack */
        rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, exp.loopidx, rvm_asm(RVM_B, DA, XX, XX, 0));
 
        /*
@@ -265,16 +290,15 @@ rint rpa_compiler_loop_end(rpa_compiler_t *co)
         */
        rvm_codegen_redefinelabel(co->cg, exp.successidx);
        rvm_codegen_addins(co->cg, rvm_asm(RVM_MOVS, R0, R_LOO, XX, 0));
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R1)|BIT(R_RID)|BIT(R_LOO)|BIT(R_TOP)|BIT(R_REC)|BIT(FP)|BIT(LR)));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R1)|BIT(R_RID)|BIT(R_LOO)|BIT(R_TOP)|BIT(FP)|BIT(LR)));
        rvm_codegen_addins(co->cg, rvm_asm(RPA_SETRECLEN, R1, XX, XX, 0));
-       rvm_codegen_addins(co->cg, rvm_asml(RVM_NOP, DA, R0, R1, exp.start)); // TBD: RPA_SETCACHE
        rvm_codegen_addins(co->cg, rvm_asm(RVM_ADD, R_TOP, R_TOP, R0, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_BX, LR, XX, XX, 0));
        /*
         *  END FAILED:
         */
        rvm_codegen_redefinelabel(co->cg, exp.failidx);
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R0)|BIT(R_RID)|BIT(R_LOO)|BIT(R_TOP)|BIT(R_REC)|BIT(FP)|BIT(LR)));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R0)|BIT(R_RID)|BIT(R_LOO)|BIT(R_TOP)|BIT(FP)|BIT(LR)));
        rvm_codegen_addins(co->cg, rvm_asm(RPA_SETRECLEN, R0, XX, XX, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_MOVS, R0, DA, XX, -1));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_BX, LR, XX, XX, 0));
@@ -291,17 +315,15 @@ rint rpa_compiler_rule_begin(rpa_compiler_t *co, const rchar *name, ruint namesi
        r_memset(&exp, 0, sizeof(exp));
        exp.start = rvm_codegen_getcodesize(co->cg);
        exp.recuid = puid ? *puid : RPA_RECORD_INVALID_UID;
-       exp.emitidx = rvm_codegen_adddata_s(co->cg, NULL, name, namesize);
        exp.startidx = rvm_codegen_addlabel(co->cg, name, namesize);
        exp.endidx = rpa_codegen_invalid_add_numlabel_s(co->cg, "__end", exp.start);
+       exp.dataidx = rpa_compiler_addblob(co, exp.start, exp.recuid, 0, name, namesize);
 
        rvm_codegen_addins(co->cg, rvm_asm(RPA_CHECKCACHE, DA, R_TOP, XX, exp.start));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_BXGRE, LR, XX, XX, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RPA_GETRECLEN, R0, XX, XX, 0));
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSHM, DA, XX, XX, BIT(R0)|BIT(R_TOP)|BIT(R_REC)|BIT(LR)));
-       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_STRING, exp.emitidx, rvm_asm(RPA_EMITSTART, DA, R_TOP, XX, 0));
-       rvm_codegen_addins(co->cg, rvm_asm(RPA_SETRECID, DA, XX, XX, exp.start));
-       rvm_codegen_addins(co->cg, rvm_asm(RPA_SETRECUID, DA, XX, XX, exp.recuid));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSHM, DA, XX, XX, BIT(R0)|BIT(R_TOP)|BIT(LR)));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BLOB, exp.dataidx, rvm_asm(RPA_EMITSTART, DA, R_TOP, XX, 0));
        r_array_add(co->expressions, &exp);
        return 0;
 }
@@ -317,19 +339,17 @@ rint rpa_compiler_rule_end(rpa_compiler_t *co)
 {
        rpa_ruledef_t exp = r_array_pop(co->expressions, rpa_ruledef_t);
 
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R1)|BIT(R2)|BIT(R_REC)|BIT(LR)));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R1)|BIT(R2)|BIT(LR)));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_SUBS, R0, R_TOP, R2, 0));
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_BEQ, DA, XX, XX, 6));
-       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_STRING, exp.emitidx, rvm_asm(RPA_EMITEND, DA, R2, R0, 0));
-       rvm_codegen_addins(co->cg, rvm_asm(RPA_SETRECID, DA, XX, XX, exp.start));
-       rvm_codegen_addins(co->cg, rvm_asm(RPA_SETRECUID, DA, XX, XX, exp.recuid));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_BEQ, DA, XX, XX, 4));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BLOB, exp.dataidx, rvm_asm(RPA_EMITEND, DA, R2, R0, 0));
        rvm_codegen_addins(co->cg, rvm_asml(RPA_SETCACHE, DA, R0, R1, exp.start));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_BX, LR, XX, XX, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RPA_SETRECLEN, R1, XX, XX, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_MOVS, R0, DA, XX, -1));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_BX, LR, XX, XX, 0));
        rvm_codegen_redefinelabel(co->cg, exp.endidx);
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R0)|BIT(R_TOP)|BIT(R_REC)|BIT(LR)));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R0)|BIT(R_TOP)|BIT(LR)));
        rvm_codegen_addins(co->cg, rvm_asm(RPA_SETRECLEN, R0, XX, XX, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_MOVS, R0, DA, XX, -1));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_BX, LR, XX, XX, 0));
@@ -347,7 +367,7 @@ rint rpa_compiler_exp_begin(rpa_compiler_t *co, ruint flags)
        exp.startidx = rpa_codegen_add_numlabel_s(co->cg, "__begin", exp.start);
        exp.endidx = rpa_codegen_invalid_add_numlabel_s(co->cg, "__end", exp.start);
        rvm_codegen_addins(co->cg, rvm_asm(RPA_GETRECLEN, R0, XX, XX, 0));
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSHM, DA, XX, XX, BIT(R0)|BIT(R_TOP)|BIT(R_REC)|BIT(LR)));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSHM, DA, XX, XX, BIT(R0)|BIT(R_TOP)|BIT(LR)));
        r_array_add(co->expressions, &exp);
        return 0;
 }
@@ -357,11 +377,11 @@ rint rpa_compiler_exp_end(rpa_compiler_t *co)
 {
        rpa_ruledef_t exp = r_array_pop(co->expressions, rpa_ruledef_t);
 
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R0)|BIT(R1)|BIT(R_REC)|BIT(LR)));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R0)|BIT(R1)|BIT(LR)));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_SUBS, R0, R_TOP, R1, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_BX, LR, XX, XX, 0));
        rvm_codegen_redefinelabel(co->cg, exp.endidx);
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R0)|BIT(R_TOP)|BIT(R_REC)|BIT(LR)));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R0)|BIT(R_TOP)|BIT(LR)));
        rvm_codegen_addins(co->cg, rvm_asm(RPA_SETRECLEN, R0, XX, XX, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_MOVS, R0, DA, XX, -1));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_BX, LR, XX, XX, 0));
@@ -380,7 +400,7 @@ rint rpa_compiler_altexp_begin(rpa_compiler_t *co, ruint flags)
        exp.start = rvm_codegen_getcodesize(co->cg);
        exp.startidx = rpa_codegen_add_numlabel_s(co->cg, "__begin", exp.start);
        exp.endidx = rpa_codegen_invalid_add_numlabel_s(co->cg, "__end", exp.start);
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSHM, DA, XX, XX, BIT(R_TOP)|BIT(R_REC)|BIT(LR)));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSHM, DA, XX, XX, BIT(R_TOP)|BIT(LR)));
        r_array_add(co->expressions, &exp);
        return 0;
 }
@@ -390,11 +410,11 @@ rint rpa_compiler_altexp_end(rpa_compiler_t *co)
 {
        rpa_ruledef_t exp = r_array_pop(co->expressions, rpa_ruledef_t);
 
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R_TOP)|BIT(R_REC)|BIT(LR)));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R_TOP)|BIT(LR)));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_MOVS, R0, DA, XX, -1));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_BX, LR, XX, XX, 0));
        rvm_codegen_redefinelabel(co->cg, exp.endidx);
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R1)|BIT(R_REC)|BIT(LR)));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R1)|BIT(LR)));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_SUBS, R0, R_TOP, R1, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_BX, LR, XX, XX, 0));
 
@@ -414,7 +434,7 @@ rint rpa_compiler_branch_begin(rpa_compiler_t *co, ruint flags)
        exp.startidx = rpa_codegen_add_numlabel_s(co->cg, "__begin", exp.start);
        exp.endidx = rpa_codegen_invalid_add_numlabel_s(co->cg, "__end", exp.start);
        rvm_codegen_addins(co->cg, rvm_asm(RPA_GETRECLEN, R0, XX, XX, 0));
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSHM, DA, XX, XX, BIT(R0)|BIT(R_TOP)|BIT(R_REC)|BIT(LR)));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSHM, DA, XX, XX, BIT(R0)|BIT(R_TOP)|BIT(LR)));
        r_array_add(co->expressions, &exp);
        return 0;
 }
@@ -424,11 +444,11 @@ rint rpa_compiler_branch_end(rpa_compiler_t *co)
 {
        rpa_ruledef_t exp = r_array_pop(co->expressions, rpa_ruledef_t);
 
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R0)|BIT(R1)|BIT(R_REC)|BIT(LR)));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R0)|BIT(R1)|BIT(LR)));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_SUBS, R0, R_TOP, R1, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_BX, LR, XX, XX, 0));
        rvm_codegen_redefinelabel(co->cg, exp.endidx);
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R0)|BIT(R_TOP)|BIT(R_REC)|BIT(LR)));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R0)|BIT(R_TOP)|BIT(LR)));
        rvm_codegen_addins(co->cg, rvm_asm(RPA_SETRECLEN, R0, XX, XX, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_MOVS, R0, DA, XX, -1));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_BX, LR, XX, XX, 0));
@@ -450,7 +470,7 @@ rint rpa_compiler_nonloopybranch_begin(rpa_compiler_t *co, ruint flags)
        exp.startidx = rpa_codegen_add_numlabel_s(co->cg, "__begin", exp.start);
        exp.endidx = rpa_codegen_invalid_add_numlabel_s(co->cg, "__end", exp.start);
        rvm_codegen_addins(co->cg, rvm_asm(RPA_GETRECLEN, R0, XX, XX, 0));
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSHM, DA, XX, XX, BIT(R0)|BIT(R_TOP)|BIT(R_REC)|BIT(LR)));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSHM, DA, XX, XX, BIT(R0)|BIT(R_TOP)|BIT(LR)));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_CMP, R_LOO, DA, XX, 0));
        rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, exp.endidx, rvm_asm(RVM_BGRE, DA, XX, XX, 0));
        r_array_add(co->expressions, &exp);
@@ -474,7 +494,7 @@ rint rpa_compiler_class_begin(rpa_compiler_t *co, ruint flags)
        exp.start = rvm_codegen_getcodesize(co->cg);
        exp.startidx = rpa_codegen_add_numlabel_s(co->cg, "__begin", exp.start);
        exp.endidx = rpa_codegen_invalid_add_numlabel_s(co->cg, "__end", exp.start);
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSHM, DA, XX, XX, BIT(R_TOP)|BIT(R_REC)|BIT(LR)));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSHM, DA, XX, XX, BIT(R_TOP)|BIT(LR)));
        r_array_add(co->expressions, &exp);
        return 0;
 }
@@ -484,11 +504,11 @@ rint rpa_compiler_class_end(rpa_compiler_t *co)
 {
        rpa_ruledef_t exp = r_array_pop(co->expressions, rpa_ruledef_t);
 
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R_TOP)|BIT(R_REC)|BIT(LR)));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R_TOP)|BIT(LR)));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_MOVS, R0, DA, XX, -1));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_BX, LR, XX, XX, 0));
        rvm_codegen_redefinelabel(co->cg, exp.endidx);
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R1)|BIT(R_REC)|BIT(LR)));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R1)|BIT(LR)));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_SUBS, R0, R_TOP, R1, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_BX, LR, XX, XX, 0));
 
@@ -508,7 +528,7 @@ rint rpa_compiler_notexp_begin(rpa_compiler_t *co, ruint flags)
        exp.startidx = rpa_codegen_add_numlabel_s(co->cg, "__begin", exp.start);
        exp.endidx = rpa_codegen_invalid_add_numlabel_s(co->cg, "__end", exp.start);
        rvm_codegen_addins(co->cg, rvm_asm(RPA_GETRECLEN, R0, XX, XX, 0));
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSHM, DA, XX, XX, BIT(R0)|BIT(R_TOP)|BIT(R_REC)|BIT(LR)));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSHM, DA, XX, XX, BIT(R0)|BIT(R_TOP)|BIT(LR)));
        r_array_add(co->expressions, &exp);
        return 0;
 }
@@ -518,13 +538,13 @@ rint rpa_compiler_notexp_end(rpa_compiler_t *co)
 {
        rpa_ruledef_t exp = r_array_pop(co->expressions, rpa_ruledef_t);
 
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R0)|BIT(R_TOP)|BIT(R_REC)|BIT(LR)));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R0)|BIT(R_TOP)|BIT(LR)));
        rvm_codegen_addins(co->cg, rvm_asm(RPA_SETRECLEN, R0, XX, XX, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_MOVS, R0, DA, XX, -1));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_CMP, R0, DA, XX, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_BX, LR, XX, XX, 0));
        rvm_codegen_redefinelabel(co->cg, exp.endidx);
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R0)|BIT(R_TOP)|BIT(R_REC)|BIT(LR)));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R0)|BIT(R_TOP)|BIT(LR)));
        rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHSPCHR_NAN, DA, XX, XX, '.'));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_BX, LR, XX, XX, 0));
 
@@ -544,7 +564,7 @@ rint rpa_compiler_negexp_begin(rpa_compiler_t *co, ruint flags)
        exp.startidx = rpa_codegen_add_numlabel_s(co->cg, "__begin", exp.start);
        exp.endidx = rpa_codegen_invalid_add_numlabel_s(co->cg, "__end", exp.start);
        rvm_codegen_addins(co->cg, rvm_asm(RPA_GETRECLEN, R0, XX, XX, 0));
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSHM, DA, XX, XX, BIT(R0)|BIT(R_TOP)|BIT(R_REC)|BIT(LR)));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSHM, DA, XX, XX, BIT(R0)|BIT(R_TOP)|BIT(LR)));
        r_array_add(co->expressions, &exp);
        return 0;
 
@@ -555,13 +575,13 @@ rint rpa_compiler_negexp_end(rpa_compiler_t *co)
 {
        rpa_ruledef_t exp = r_array_pop(co->expressions, rpa_ruledef_t);
 
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R0)|BIT(R_TOP)|BIT(R_REC)|BIT(LR)));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R0)|BIT(R_TOP)|BIT(LR)));
        rvm_codegen_addins(co->cg, rvm_asm(RPA_SETRECLEN, R0, XX, XX, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_MOVS, R0, DA, XX, -1));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_CMP, R0, DA, XX, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_BX, LR, XX, XX, 0));
        rvm_codegen_redefinelabel(co->cg, exp.endidx);
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R0)|BIT(R_TOP)|BIT(R_REC)|BIT(LR)));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_POPM, DA, XX, XX, BIT(R0)|BIT(R_TOP)|BIT(LR)));
        rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHSPCHR_NAN, DA, XX, XX, '.'));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_BX, LR, XX, XX, 0));
        rvm_codegen_replaceins(co->cg, exp.branch, rvm_asm(RVM_B, DA, XX, XX, rvm_codegen_getcodesize(co->cg) - exp.branch));
index 8c30fa9..879581b 100644 (file)
@@ -9,11 +9,13 @@
 extern "C" {
 #endif
 
+#define RPA_RULENAME_MAXSIZE 256
+
 typedef struct rpa_ruledef_s {
        rulong branch;
        rulong start;
        rlong startidx;
-       rlong emitidx;
+       rlong dataidx;
        rlong endidx;
        rlong loopidx;
        rlong successidx;
@@ -39,6 +41,9 @@ typedef struct rpa_compiler_s {
 
 rpa_compiler_t *rpa_compiler_create();
 void rpa_compiler_destroy(rpa_compiler_t *co);
+rlong rpa_compiler_addblob(rpa_compiler_t *co, rlong ruleid, rlong ruleuid, rulong flags, const rchar *name, rulong namesize);
+rlong rpa_compiler_addblob_s(rpa_compiler_t *co, rlong ruleid, rlong ruleuid, rulong flags, const rchar *name);
+
 rint rpa_compiler_loop_begin(rpa_compiler_t *co, const rchar *name, ruint namesize);
 rint rpa_compiler_loop_begin_s(rpa_compiler_t *co, const rchar *name);
 rint rpa_compiler_loop_end(rpa_compiler_t *co);
index e655dcb..a3c3fed 100644 (file)
@@ -23,7 +23,6 @@ struct rpadbex_s {
        rpa_dbex_recordhandler *handlers;
        ruint error;
        rvm_codelabel_t *labelerr;
-       rulong init;
 };
 
 static rparecord_t *rpa_dbex_rulerecord(rpadbex_t *dbex, rparule_t rid);
@@ -1043,9 +1042,6 @@ rint rpa_dbex_compile(rpadbex_t *dbex)
                rpa_compiler_destroy(dbex->co);
        dbex->co = rpa_compiler_create();
 
-       dbex->init = rvm_codegen_addins(dbex->co->cg, rvm_asml(RVM_NOP, XX, XX, XX, -1));
-       rvm_codegen_addins(dbex->co->cg, rvm_asm(RVM_EXT, XX, XX, XX, 0));
-
        for (rid = rpa_dbex_first(dbex); rid >= 0; rid = rpa_dbex_next(dbex, rid)) {
                if (rpa_dbex_compile_rule(dbex, rid) < 0) {
                        return -1;
@@ -1085,11 +1081,3 @@ rlong rvm_dbex_codeoffset(rpadbex_t *dbex, rparule_t rid)
 
        return info->codeoff;
 }
-
-
-rlong rvm_dbex_initoffset(rpadbex_t *dbex)
-{
-       if (!dbex)
-               return -1;
-       return dbex->init;
-}
index 26b72a1..3527251 100644 (file)
@@ -43,8 +43,6 @@ rlong rpa_dbex_load_s(rpadbex_t *dbex, const rchar *rules);
 const rchar *rpa_dbex_version();
 rvm_asmins_t *rvm_dbex_getcode(rpadbex_t *dbex);
 rlong rvm_dbex_codeoffset(rpadbex_t *dbex, rparule_t rid);
-rlong rvm_dbex_initoffset(rpadbex_t *dbex);
-
 
 rparule_t rpa_dbex_lookup(rpadbex_t *dbex, const rchar *name);
 rparule_t rpa_dbex_default(rpadbex_t *dbex);
index 1daeb97..34ef844 100644 (file)
@@ -1187,7 +1187,6 @@ static rint rpa_parser_init(rpa_parser_t *pa)
        rvm_codegen_addins(co->cg, rvm_asml(RVM_MOV, SP, DA, XX, 0));
        rvm_codegen_addins(co->cg, rvm_asml(RVM_MOV, R_LOO, DA, XX, 0));
        rvm_codegen_addins(co->cg, rvm_asml(RVM_MOV, R_TOP, DA, XX, -1));
-       rvm_codegen_addins(co->cg, rvm_asml(RVM_MOV, R_REC, DA, XX, 0));
 
        rvm_codegen_addins(co->cg, rvm_asm(RPA_SHIFT, XX, XX, XX, 0));
        rpa_compiler_reference_nan_s(co, "bnf");
index e141c6a..be0ab42 100644 (file)
@@ -83,7 +83,6 @@ rint rpa_stat_init(rpastat_t *stat, const rchar *input, const rchar *start, cons
        rpa_stat_cacheinvalidate(stat);
        RVM_CPUREG_SETU(stat->cpu, SP, 0);
        RVM_CPUREG_SETU(stat->cpu, R_LOO, 0);
-       RVM_CPUREG_SETU(stat->cpu, R_REC, 0);
        RVM_CPUREG_SETU(stat->cpu, R_TOP, -1);
        return 0;
 }
@@ -140,9 +139,6 @@ rlong rpa_stat_scan(rpastat_t *stat, rparule_t rid, const rchar *input, const rc
                return -1;
        }
 
-       if (rvm_cpu_exec(stat->cpu, rvm_dbex_getcode(stat->dbex), rvm_dbex_initoffset(stat->dbex)) < 0)
-               return -1;
-
        while (input < end) {
                if ((ret = rpa_stat_exec_noinit(stat, rid, input, start, end)) > 0) {
                        *where = input;
@@ -160,9 +156,6 @@ rlong rpa_stat_match(rpastat_t *stat, rparule_t rid, const rchar *input, const r
                return -1;
        }
 
-       if (rvm_cpu_exec(stat->cpu, rvm_dbex_getcode(stat->dbex), rvm_dbex_initoffset(stat->dbex)) < 0)
-               return -1;
-
        return rpa_stat_exec_noinit(stat, rid, input, start, end);
 }
 
@@ -176,9 +169,6 @@ rarray_t *rpa_stat_parse(rpastat_t *stat, rparule_t rid, const rchar *input, con
                return NULL;
        }
 
-       if (rvm_cpu_exec(stat->cpu, rvm_dbex_getcode(stat->dbex), rvm_dbex_initoffset(stat->dbex)) < 0)
-               return NULL;
-
        res = rpa_stat_exec_noinit(stat, rid, input, start, end);
        if (res > 0 && !r_array_empty(stat->records)) {
                records = stat->records;
index cdda66f..55f1302 100644 (file)
@@ -230,20 +230,24 @@ static void rpavm_swi_matchrng_mop(rvmcpu_t *cpu, rvm_asmins_t *ins)
 
 static void rpavm_swi_emitstart(rvmcpu_t *cpu, rvm_asmins_t *ins)
 {
+       rpa_ruledata_t *ruledata = RVM_CPUREG_GETP(cpu, ins->op1);
        rpastat_t *stat = (rpastat_t *)cpu->userdata1;
        rparecord_t *rec;
        rlong index;
        rword tp = RVM_CPUREG_GETU(cpu, ins->op2);
-       rstr_t name = {RVM_CPUREG_GETSTR(cpu, ins->op1), RVM_CPUREG_GETSIZE(cpu, ins->op1)};
+//     rstr_t name = {RVM_CPUREG_GETSTR(cpu, ins->op1), RVM_CPUREG_GETSIZE(cpu, ins->op1)};
+       rstr_t name = {(rchar*)ruledata + ruledata->name, ruledata->namesize};
 
        index = r_array_add(stat->records, NULL);
        rec = (rparecord_t *)r_array_slot(stat->records, index);
        rec->rule = name.str;
        rec->top = tp;
+       rec->ruleid = ruledata->ruleid;
+       rec->userid = ruledata->ruleuid;
        rec->type = RPA_RECORD_START;
        rec->input = stat->instack[tp].input;
        rec->inputsiz = 0;
-       RVM_CPUREG_SETU(cpu, R_REC, r_array_length(stat->records));
+//     RVM_CPUREG_SETU(cpu, R_REC, r_array_length(stat->records));
 
 //     r_printf("START: %s(%ld)\n", name.str, (rulong)tp);
 }
@@ -251,30 +255,31 @@ static void rpavm_swi_emitstart(rvmcpu_t *cpu, rvm_asmins_t *ins)
 
 static void rpavm_swi_emitend(rvmcpu_t *cpu, rvm_asmins_t *ins)
 {
+       rpa_ruledata_t *ruledata = RVM_CPUREG_GETP(cpu, ins->op1);
        rpastat_t *stat = (rpastat_t *)cpu->userdata1;
        rparecord_t *rec;
        rlong index;
        rword tp = RVM_CPUREG_GETU(cpu, ins->op2);
        rword tplen = RVM_CPUREG_GETU(cpu, ins->op3);
-       rstr_t name = {RVM_CPUREG_GETSTR(cpu, ins->op1), RVM_CPUREG_GETSIZE(cpu, ins->op1)};
+//     rstr_t name = {RVM_CPUREG_GETSTR(cpu, ins->op1), RVM_CPUREG_GETSIZE(cpu, ins->op1)};
+       rstr_t name = {(rchar*)ruledata + ruledata->name, ruledata->namesize};
 
        index = r_array_add(stat->records, NULL);
        rec = (rparecord_t *)r_array_slot(stat->records, index);
        rec->rule = name.str;
        rec->top = tp;
        rec->size = tplen;
-       rec->type = RPA_RECORD_START;
+       rec->type = RPA_RECORD_END;
+       rec->ruleid = ruledata->ruleid;
+       rec->userid = ruledata->ruleuid;
        rec->input = stat->instack[tp].input;
        rec->inputsiz = stat->instack[tp + tplen].input - stat->instack[tp].input;
 
        if (tplen) {
-               rec->type = RPA_RECORD_END | RPA_RECORD_MATCH;
+               rec->type |= RPA_RECORD_MATCH;
 //             r_printf("MATCHED: %s(%ld, %ld): %p(%d)\n", name.str, (rulong)tp, (rulong)tplen, name.str, name.size);
-       } else {
-               rec->type = RPA_RECORD_END;
-//             r_printf("MATCHED: %s(%ld, %ld)\n", name.str, (rulong)tp, (rulong)tplen);
        }
-       RVM_CPUREG_SETU(cpu, R_REC, r_array_length(stat->records));
+//     RVM_CPUREG_SETU(cpu, R_REC, r_array_length(stat->records));
 }
 
 
@@ -313,9 +318,7 @@ static void rpavm_swi_setrecid(rvmcpu_t *cpu, rvm_asmins_t *ins)
 
 static void rpavm_swi_loopdetect(rvmcpu_t *cpu, rvm_asmins_t *ins)
 {
-       rpastat_t *stat = (rpastat_t *)cpu->userdata1;
-       rparecord_t *rec;
-       rlong len;
+//     rpastat_t *stat = (rpastat_t *)cpu->userdata1;
        rword ruleid = RVM_CPUREG_GETU(cpu, ins->op1);
        rword tp = RVM_CPUREG_GETU(cpu, ins->op2);
        rword fp = RVM_CPUREG_GETU(cpu, FP);
@@ -324,9 +327,9 @@ static void rpavm_swi_loopdetect(rvmcpu_t *cpu, rvm_asmins_t *ins)
        RVM_CPUREG_SETU(cpu, R0, -1);
 
        while (fp > 5) {
-               top = RVM_STACK_READ(cpu->stack, fp - 3);
-               loo = RVM_STACK_READ(cpu->stack, fp - 4);
-               rid = RVM_STACK_READ(cpu->stack, fp - 5);
+               top = RVM_STACK_READ(cpu->stack, fp - 2);
+               loo = RVM_STACK_READ(cpu->stack, fp - 3);
+               rid = RVM_STACK_READ(cpu->stack, fp - 4);
 
                if (rid.v.l == ruleid && top.v.l == tp) {
                        RVM_CPUREG_SETU(cpu, R0, loo.v.l);
@@ -336,20 +339,6 @@ static void rpavm_swi_loopdetect(rvmcpu_t *cpu, rvm_asmins_t *ins)
                pfp = RVM_STACK_READ(cpu->stack, fp - 1);
                fp = pfp.v.l;
        }
-
-//     for (len = r_array_length(stat->records); len > 0; len--) {
-//             rec = (rparecord_t *)r_array_slot(stat->records, len - 1);
-//             if (rec->type == (RPA_RECORD_END | RPA_RECORD_MATCH)) {
-//                     RVM_CPUREG_SETU(cpu, R0, -1);
-//                     break;
-//             } else if (rec->ruleid == ruleid && rec->top == tp) {
-//                     RVM_CPUREG_SETU(cpu, R0, RVM_CPUREG_GETU(cpu, R_LOO));
-//                     RVM_CPUREG_SETU(cpu, R_TOP, RVM_CPUREG_GETU(cpu, R_TOP) + RVM_CPUREG_GETU(cpu, R_LOO));
-//                     r_printf("LOO = %ld, loo = %ld\n", RVM_CPUREG_GETU(cpu, R0), loo.v.l);
-//                     RVM_CPUREG_SETU(cpu, R0, loo.v.l);
-//                     break;
-//             }
-//     }
 }
 
 
@@ -365,7 +354,7 @@ static void rpavm_swi_setcache(rvmcpu_t *cpu, rvm_asmins_t *ins)
        /*
         * If the record set is too big, don't use the cache
         */
-       if (nrecords > 50)
+       if (nrecords > 100)
                return;
 
        if (!RVM_STATUS_GETBIT(cpu, RVM_STATUS_N) && !RVM_STATUS_GETBIT(cpu, RVM_STATUS_Z)) {
index 053b1a8..23ff236 100644 (file)
@@ -19,10 +19,9 @@ extern "C" {
 #define RPA_NONLOOP_PATH (1<<4)
 #define RPA_LOOP_INDERECTION 1024
 
-#define R_RID R4
-#define R_LOO R5
-#define R_TOP R6
-#define R_REC R7
+#define R_RID (TP - 2)
+#define R_LOO (TP - 1)
+#define R_TOP TP
 #define RPAVM_SWI_TABLEID 0
 
 #define RPA_MATCHCHR_NAN       RVM_OPSWI(RVM_SWI_ID(RPAVM_SWI_TABLEID, 0))
@@ -66,6 +65,16 @@ typedef struct rpainmap_s {
 } rpainmap_t;
 
 
+typedef struct rpa_ruledata_s {
+       rlong size;
+       rlong ruleid;
+       rlong ruleuid;
+       rulong flags;
+       rulong namesize;
+       rulong name;
+} rpa_ruledata_t;
+
+
 rvmcpu_t *rpavm_cpu_create(rulong stacksize);
 void rpavm_cpu_destroy(rvmcpu_t * vm);
 
index 4f75558..b38a1d7 100644 (file)
@@ -69,6 +69,8 @@ rint rvm_relocmap_relocate(rvm_relocmap_t *relocmap, rvm_codemap_t *codemap, rvm
                } else if (reloc->type == RVM_RELOC_STRING) {
                        code[reloc->offset].data.v.w = value;
                        code[reloc->offset].data.size = r_strlen((rchar*)value);
+               } else if (reloc->type == RVM_RELOC_BLOB) {
+                       code[reloc->offset].data.v.w = value;
                } else {
                        code[reloc->offset].data.v.w = value;
                }
index badcb5c..1e75815 100644 (file)
@@ -17,6 +17,7 @@ typedef enum {
        RVM_RELOC_JUMP,
        RVM_RELOC_BRANCH,
        RVM_RELOC_STRING,
+       RVM_RELOC_BLOB,
 } rvm_reloctype_t;
 
 
index 820eb4a..2954f87 100644 (file)
@@ -15,7 +15,7 @@ TESTS += $(OUTDIR)/rpavm-matchchr
 TESTS  += $(OUTDIR)/rpavm-matchrng
 TESTS  += $(OUTDIR)/rpavm-mnode
 TESTS  += $(OUTDIR)/rpavm-ref
-TESTS  += $(OUTDIR)/rpacompiler-ruleloop
+;TESTS += $(OUTDIR)/rpacompiler-ruleloop
 ;TESTS += $(OUTDIR)/rpacompiler-ruleloopcls
 TESTS  += $(OUTDIR)/rpacompiler-rulerec
 TESTS  += $(OUTDIR)/rpacompiler-rulealtrec