better RPA expression deffinitions (cleaned up code)

diff --git a/rpa2/rpacompiler.c b/rpa2/rpacompiler.c
index 58f0e21..4c84ca9 100644 (file)
--- a/rpa2/rpacompiler.c
+++ b/rpa2/rpacompiler.c
@@ -4,6 +4,25 @@
 
 #define OPTIMIZE_MNODE_NAN 1
 
+static rlong rpa_codegen_add_numlabel_s(rvm_codegen_t *cg, const rchar *alphaname, rlong numname)
+{
+       rchar label[128];
+
+       r_memset(label, 0, sizeof(label));
+       r_snprintf(label, sizeof(label) - 1, "L%07ld__%s:", numname, alphaname);
+       return rvm_codegen_addlabel_s(cg, label);
+}
+
+
+static rlong rpa_codegen_invalid_add_numlabel_s(rvm_codegen_t *cg, const rchar *alphaname, rlong numname)
+{
+       rchar label[128];
+
+       r_memset(label, 0, sizeof(label));
+       r_snprintf(label, sizeof(label) - 1, "L%07ld__%s:", numname, alphaname);
+       return rvm_codegen_invalid_addlabel_s(cg, label);
+}
+
 
 void rpacompiler_mnode_nan(rpa_compiler_t *co)
 {
@@ -119,15 +138,18 @@ void rpa_compiler_add_ruleuid_s(rpa_compiler_t *co, const rchar *name, ruint32 u
 rint rpa_compiler_loop_begin(rpa_compiler_t *co, const rchar *name, ruint namesize)
 {
        rpa_ruledef_t exp;
-       rchar endlabel[64];
        ruint32 *puid = (ruint32*)r_harray_get(co->userids, r_harray_lookup(co->userids, name, namesize));
 
        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.labelidx = rvm_codegen_addlabel(co->cg, 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.start = rvm_codegen_getcodesize(co->cg);
        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));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_CMP, R0, DA, XX, 0));
@@ -136,24 +158,17 @@ 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_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_WHT)|BIT(FP)|BIT(LR)));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, FP, SP, XX, 0));
 
-       r_snprintf(endlabel, sizeof(endlabel) - 1, "__loop:%ld", exp.start);
-       exp.loopidx = rvm_codegen_addlabel_s(co->cg, endlabel);
-
-//     rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, R0, DA, XX, exp.start));
+       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));
-       r_snprintf(endlabel, sizeof(endlabel) - 1, "__end:%ld", exp.start);
-       exp.endidx = rvm_codemap_invalid_add_s(co->cg->codemap, endlabel);
        r_array_add(co->expressions, &exp);
        return 0;
 }
@@ -177,43 +192,45 @@ rint rpa_compiler_loop_end(rpa_compiler_t *co)
         */
        rvm_codegen_addins(co->cg, rvm_asm(RVM_LDS, R2, SP, DA, -3));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_SUBS, R0, R_TOP, R2, 0));
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_BGRE, DA, XX, XX, 5));
+       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_CMP, R_LOO, DA, XX, 0));
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_BGRE, DA, XX, XX, 11));          // END SUCCESS
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_B, DA, XX, XX, 16));             // END FAILED
+       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));
 
        /*
         * Loop again
         */
+       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_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, -6));           /* 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));
 
        /*
         * End the loop successfully R0 > 0
-        * END SUCCESS
+        * END SUCCESS:
         */
+       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_WHT)|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));
-//     rvm_codegen_redefinelabel(co->cg, exp.endidx);
-// END FAILED:
+       /*
+        *  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_WHT)|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));
@@ -226,25 +243,22 @@ rint rpa_compiler_loop_end(rpa_compiler_t *co)
 rint rpa_compiler_rule_begin(rpa_compiler_t *co, const rchar *name, ruint namesize)
 {
        rpa_ruledef_t exp;
-       rchar endlabel[64];
        ruint32 *puid = (ruint32*)r_harray_get(co->userids, r_harray_lookup(co->userids, name, namesize));
 
        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.labelidx = rvm_codegen_addlabel(co->cg, 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.start = rvm_codegen_getcodesize(co->cg);
        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_WHT)|BIT(LR)));
-//     rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, R0, DA, XX, 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));
-       r_snprintf(endlabel, sizeof(endlabel) - 1, "__end:%ld", exp.start);
-       exp.endidx = rvm_codemap_invalid_add_s(co->cg->codemap, endlabel);
        r_array_add(co->expressions, &exp);
        return 0;
 }
@@ -283,16 +297,13 @@ rint rpa_compiler_rule_end(rpa_compiler_t *co)
 rint rpa_compiler_exp_begin(rpa_compiler_t *co)
 {
        rpa_ruledef_t exp;
-       rchar endlabel[64];
 
        exp.branch = rvm_codegen_addins(co->cg, rvm_asm(RVM_B, DA, XX, XX, 0));
-       r_snprintf(endlabel, sizeof(endlabel) - 1, "__begin:%ld", rvm_codegen_getcodesize(co->cg));
-       exp.labelidx = rvm_codegen_addlabel_s(co->cg, endlabel);
-
-       exp.start = rvm_codegen_addins(co->cg, rvm_asm(RPA_GETRECLEN, R0, XX, XX, 0));
+       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(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_WHT)|BIT(LR)));
-       r_snprintf(endlabel, sizeof(endlabel) - 1, "__end:%ld", exp.start);
-       exp.endidx = rvm_codemap_invalid_add_s(co->cg->codemap, endlabel);
        r_array_add(co->expressions, &exp);
        return 0;
 }
@@ -312,13 +323,13 @@ rint rpa_compiler_exp_end(rpa_compiler_t *co, ruint qflag)
        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));
        if (qflag == RPA_MATCH_OPTIONAL) {
-               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.labelidx, rvm_asm(RPA_BXLOPT, DA, XX, XX, 0));
+               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.startidx, rvm_asm(RPA_BXLOPT, DA, XX, XX, 0));
        } else if (qflag == RPA_MATCH_MULTIPLE) {
-               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.labelidx, rvm_asm(RPA_BXLMUL, DA, XX, XX, 0));
+               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.startidx, rvm_asm(RPA_BXLMUL, DA, XX, XX, 0));
        } else if (qflag == RPA_MATCH_MULTIOPT) {
-               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.labelidx, rvm_asm(RPA_BXLMOP, DA, XX, XX, 0));
+               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.startidx, rvm_asm(RPA_BXLMOP, DA, XX, XX, 0));
        } else {
-               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.labelidx, rvm_asm(RPA_BXLNAN, DA, XX, XX, 0));
+               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.startidx, rvm_asm(RPA_BXLNAN, DA, XX, XX, 0));
        }
        return 0;
 }
@@ -327,14 +338,12 @@ rint rpa_compiler_exp_end(rpa_compiler_t *co, ruint qflag)
 rint rpa_compiler_altexp_begin(rpa_compiler_t *co)
 {
        rpa_ruledef_t exp;
-       rchar endlabel[64];
 
        exp.branch = rvm_codegen_addins(co->cg, rvm_asm(RVM_B, DA, XX, XX, 0));
-       r_snprintf(endlabel, sizeof(endlabel) - 1, "__begin:%ld", rvm_codegen_getcodesize(co->cg));
-       exp.labelidx = rvm_codegen_addlabel_s(co->cg, endlabel);
-       exp.start = rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSHM, DA, XX, XX, BIT(R_TOP)|BIT(R_WHT)|BIT(LR)));
-       r_snprintf(endlabel, sizeof(endlabel) - 1, "__end:%ld", exp.start);
-       exp.endidx = rvm_codemap_invalid_add_s(co->cg->codemap, endlabel);
+       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_WHT)|BIT(LR)));
        r_array_add(co->expressions, &exp);
        return 0;
 }
@@ -354,13 +363,13 @@ rint rpa_compiler_altexp_end(rpa_compiler_t *co, ruint qflag)
 
        rvm_codegen_replaceins(co->cg, exp.branch, rvm_asm(RVM_B, DA, XX, XX, rvm_codegen_getcodesize(co->cg) - exp.branch));
        if (qflag == RPA_MATCH_OPTIONAL) {
-               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.labelidx, rvm_asm(RPA_BXLOPT, DA, XX, XX, 0));
+               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.startidx, rvm_asm(RPA_BXLOPT, DA, XX, XX, 0));
        } else if (qflag == RPA_MATCH_MULTIPLE) {
-               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.labelidx, rvm_asm(RPA_BXLMUL, DA, XX, XX, 0));
+               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.startidx, rvm_asm(RPA_BXLMUL, DA, XX, XX, 0));
        } else if (qflag == RPA_MATCH_MULTIOPT) {
-               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.labelidx, rvm_asm(RPA_BXLMOP, DA, XX, XX, 0));
+               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.startidx, rvm_asm(RPA_BXLMOP, DA, XX, XX, 0));
        } else {
-               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.labelidx, rvm_asm(RPA_BXLNAN, DA, XX, XX, 0));
+               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.startidx, rvm_asm(RPA_BXLNAN, DA, XX, XX, 0));
        }
        return 0;
 }
@@ -369,16 +378,13 @@ rint rpa_compiler_altexp_end(rpa_compiler_t *co, ruint qflag)
 rint rpa_compiler_branch_begin(rpa_compiler_t *co)
 {
        rpa_ruledef_t exp;
-       rchar endlabel[64];
 
        exp.branch = rvm_codegen_addins(co->cg, rvm_asm(RVM_B, DA, XX, XX, 0));
-       r_snprintf(endlabel, sizeof(endlabel) - 1, "__begin:%ld", rvm_codegen_getcodesize(co->cg));
-       exp.labelidx = rvm_codegen_addlabel_s(co->cg, endlabel);
-       exp.start = rvm_codegen_addins(co->cg, rvm_asm(RPA_GETRECLEN, R0, XX, XX, 0));
+       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(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_WHT)|BIT(LR)));
-
-       r_snprintf(endlabel, sizeof(endlabel) - 1, "__end:%ld", exp.start);
-       exp.endidx = rvm_codemap_invalid_add_s(co->cg->codemap, endlabel);
        r_array_add(co->expressions, &exp);
        return 0;
 }
@@ -398,13 +404,13 @@ rint rpa_compiler_branch_end(rpa_compiler_t *co, ruint qflag)
        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));
        if (qflag == RPA_MATCH_OPTIONAL) {
-               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.labelidx, rvm_asm(RPA_BXLOPT, DA, XX, XX, 0));
+               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.startidx, rvm_asm(RPA_BXLOPT, DA, XX, XX, 0));
        } else if (qflag == RPA_MATCH_MULTIPLE) {
-               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.labelidx, rvm_asm(RPA_BXLMUL, DA, XX, XX, 0));
+               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.startidx, rvm_asm(RPA_BXLMUL, DA, XX, XX, 0));
        } else if (qflag == RPA_MATCH_MULTIOPT) {
-               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.labelidx, rvm_asm(RPA_BXLMOP, DA, XX, XX, 0));
+               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.startidx, rvm_asm(RPA_BXLMOP, DA, XX, XX, 0));
        } else {
-               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.labelidx, rvm_asm(RPA_BXLNAN, DA, XX, XX, 0));
+               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.startidx, rvm_asm(RPA_BXLNAN, DA, XX, XX, 0));
        }
        rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BGRE, DA, XX, XX, 0));
 
@@ -415,20 +421,18 @@ rint rpa_compiler_branch_end(rpa_compiler_t *co, ruint qflag)
 rint rpa_compiler_nonloopybranch_begin(rpa_compiler_t *co)
 {
        rpa_ruledef_t exp;
-       rchar endlabel[64];
 
        exp.branch = rvm_codegen_addins(co->cg, rvm_asm(RVM_B, DA, XX, XX, 0));
-       r_snprintf(endlabel, sizeof(endlabel) - 1, "__begin:%ld", rvm_codegen_getcodesize(co->cg));
-       exp.labelidx = rvm_codegen_addlabel_s(co->cg, endlabel);
-       exp.start = rvm_codegen_addins(co->cg, rvm_asm(RPA_GETRECLEN, R0, XX, XX, 0));
+       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(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_WHT)|BIT(LR)));
-       r_snprintf(endlabel, sizeof(endlabel) - 1, "__end:%ld", exp.start);
-       exp.endidx = rvm_codemap_invalid_add_s(co->cg->codemap, endlabel);
        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);
        return 0;
+
 }
 
 
@@ -441,14 +445,12 @@ rint rpa_compiler_nonloopybranch_end(rpa_compiler_t *co, ruint qflag)
 rint rpa_compiler_class_begin(rpa_compiler_t *co)
 {
        rpa_ruledef_t exp;
-       rchar endlabel[64];
 
        exp.branch = rvm_codegen_addins(co->cg, rvm_asm(RVM_B, DA, XX, XX, 0));
-       r_snprintf(endlabel, sizeof(endlabel) - 1, "__begin:%ld", rvm_codegen_getcodesize(co->cg));
-       exp.labelidx = rvm_codegen_addlabel_s(co->cg, endlabel);
-       exp.start = rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSHM, DA, XX, XX, BIT(R_TOP)|BIT(R_WHT)|BIT(LR)));
-       r_snprintf(endlabel, sizeof(endlabel) - 1, "__end:%ld", exp.start);
-       exp.endidx = rvm_codemap_invalid_add_s(co->cg->codemap, endlabel);
+       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_WHT)|BIT(LR)));
        r_array_add(co->expressions, &exp);
        return 0;
 }
@@ -468,13 +470,13 @@ rint rpa_compiler_class_end(rpa_compiler_t *co, ruint qflag)
 
        rvm_codegen_replaceins(co->cg, exp.branch, rvm_asm(RVM_B, DA, XX, XX, rvm_codegen_getcodesize(co->cg) - exp.branch));
        if (qflag == RPA_MATCH_OPTIONAL) {
-               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.labelidx, rvm_asm(RPA_BXLOPT, DA, XX, XX, 0));
+               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.startidx, rvm_asm(RPA_BXLOPT, DA, XX, XX, 0));
        } else if (qflag == RPA_MATCH_MULTIPLE) {
-               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.labelidx, rvm_asm(RPA_BXLMUL, DA, XX, XX, 0));
+               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.startidx, rvm_asm(RPA_BXLMUL, DA, XX, XX, 0));
        } else if (qflag == RPA_MATCH_MULTIOPT) {
-               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.labelidx, rvm_asm(RPA_BXLMOP, DA, XX, XX, 0));
+               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.startidx, rvm_asm(RPA_BXLMOP, DA, XX, XX, 0));
        } else {
-               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.labelidx, rvm_asm(RPA_BXLNAN, DA, XX, XX, 0));
+               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.startidx, rvm_asm(RPA_BXLNAN, DA, XX, XX, 0));
        }
        return 0;
 }
@@ -483,15 +485,13 @@ rint rpa_compiler_class_end(rpa_compiler_t *co, ruint qflag)
 rint rpa_compiler_notexp_begin(rpa_compiler_t *co)
 {
        rpa_ruledef_t exp;
-       rchar endlabel[64];
 
        exp.branch = rvm_codegen_addins(co->cg, rvm_asm(RVM_B, DA, XX, XX, 0));
-       r_snprintf(endlabel, sizeof(endlabel) - 1, "__begin:%ld", rvm_codegen_getcodesize(co->cg));
-       exp.labelidx = rvm_codegen_addlabel_s(co->cg, endlabel);
-       exp.start = rvm_codegen_addins(co->cg, rvm_asm(RPA_GETRECLEN, R0, XX, XX, 0));
+       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(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_WHT)|BIT(LR)));
-       r_snprintf(endlabel, sizeof(endlabel) - 1, "__end:%ld", exp.start);
-       exp.endidx = rvm_codemap_invalid_add_s(co->cg->codemap, endlabel);
        r_array_add(co->expressions, &exp);
        return 0;
 }
@@ -513,13 +513,13 @@ rint rpa_compiler_notexp_end(rpa_compiler_t *co, ruint qflag)
 
        rvm_codegen_replaceins(co->cg, exp.branch, rvm_asm(RVM_B, DA, XX, XX, rvm_codegen_getcodesize(co->cg) - exp.branch));
        if (qflag == RPA_MATCH_OPTIONAL) {
-               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.labelidx, rvm_asm(RPA_BXLOPT, DA, XX, XX, 0));
+               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.startidx, rvm_asm(RPA_BXLOPT, DA, XX, XX, 0));
        } else if (qflag == RPA_MATCH_MULTIPLE) {
-               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.labelidx, rvm_asm(RPA_BXLMUL, DA, XX, XX, 0));
+               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.startidx, rvm_asm(RPA_BXLMUL, DA, XX, XX, 0));
        } else if (qflag == RPA_MATCH_MULTIOPT) {
-               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.labelidx, rvm_asm(RPA_BXLMOP, DA, XX, XX, 0));
+               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.startidx, rvm_asm(RPA_BXLMOP, DA, XX, XX, 0));
        } else {
-               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.labelidx, rvm_asm(RPA_BXLNAN, DA, XX, XX, 0));
+               rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.startidx, rvm_asm(RPA_BXLNAN, DA, XX, XX, 0));
        }
        return 0;
 }
@@ -528,17 +528,16 @@ rint rpa_compiler_notexp_end(rpa_compiler_t *co, ruint qflag)
 rint rpa_compiler_negexp_begin(rpa_compiler_t *co)
 {
        rpa_ruledef_t exp;
-       rchar endlabel[64];
 
        exp.branch = rvm_codegen_addins(co->cg, rvm_asm(RVM_B, DA, XX, XX, 0));
-       r_snprintf(endlabel, sizeof(endlabel) - 1, "__begin:%ld", rvm_codegen_getcodesize(co->cg));
-       exp.labelidx = rvm_codegen_addlabel_s(co->cg, endlabel);
-       exp.start = rvm_codegen_addins(co->cg, rvm_asm(RPA_GETRECLEN, R0, XX, XX, 0));
+       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(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_WHT)|BIT(LR)));
-       r_snprintf(endlabel, sizeof(endlabel) - 1, "__end:%ld", exp.start);
-       exp.endidx = rvm_codemap_invalid_add_s(co->cg->codemap, endlabel);
        r_array_add(co->expressions, &exp);
        return 0;
+
 }
 
 
@@ -556,6 +555,6 @@ rint rpa_compiler_negexp_end(rpa_compiler_t *co)
        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));
-       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.labelidx, rvm_asm(RPA_BXLNAN, DA, XX, XX, 0));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.startidx, rvm_asm(RPA_BXLNAN, DA, XX, XX, 0));
        return 0;
 }

diff --git a/rpa2/rpacompiler.h b/rpa2/rpacompiler.h
index 510ea10..f83d258 100644 (file)
--- a/rpa2/rpacompiler.h
+++ b/rpa2/rpacompiler.h
@@ -12,10 +12,13 @@ extern "C" {
 typedef struct rpa_ruledef_s {
        rulong branch;
        rulong start;
-       rlong labelidx;
+       rlong startidx;
        rlong emitidx;
        rlong endidx;
        rlong loopidx;
+       rlong successidx;
+       rlong failidx;
+       rlong againidx;
        ruint32 recuid;
 } rpa_ruledef_t;
 

diff --git a/rpa2/rpavm.c b/rpa2/rpavm.c
index b27100f..dc7a15f 100644 (file)
--- a/rpa2/rpavm.c
+++ b/rpa2/rpavm.c
@@ -396,26 +396,28 @@ static void rpavm_swi_loopdetect(rvmcpu_t *cpu, rvm_asmins_t *ins)
                loo = RVM_STACK_READ(cpu->stack, fp - 4);
                rid = RVM_STACK_READ(cpu->stack, fp - 5);
 
-               if (rid.v.l == ruleid && top.v.l == tp)
+               if (rid.v.l == ruleid && top.v.l == tp) {
+                       RVM_CPUREG_SETU(cpu, R0, loo.v.l);
                        break;
+               }
                RVM_REG_CLEAR(&loo);
                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));
+//     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;
-               }
-       }
+//                     r_printf("LOO = %ld, loo = %ld\n", RVM_CPUREG_GETU(cpu, R0), loo.v.l);
+//                     RVM_CPUREG_SETU(cpu, R0, loo.v.l);
+//                     break;
+//             }
+//     }
 }
 
 

diff --git a/rvm/rvmcodegen.c b/rvm/rvmcodegen.c
index 3e75395..b0dcb1f 100644 (file)
--- a/rvm/rvmcodegen.c
+++ b/rvm/rvmcodegen.c
@@ -83,6 +83,18 @@ rlong rvm_codegen_addlabel_s(rvm_codegen_t *cg, const rchar* name)
 }
 
 
+rlong rvm_codegen_invalid_addlabel(rvm_codegen_t *cg, const rchar* name, ruint namesize)
+{
+       return rvm_codemap_invalid_add(cg->codemap, name, namesize);
+}
+
+
+rlong rvm_codegen_invalid_addlabel_s(rvm_codegen_t *cg, const rchar* name)
+{
+       return rvm_codegen_invalid_addlabel(cg, name, r_strlen(name));
+}
+
+
 ruint rvm_codegen_addlabelins(rvm_codegen_t *cg, const rchar* name, ruint namesize, rvm_asmins_t ins)
 {
        rvm_codemap_addoffset(cg->codemap, name, namesize, rvm_codemap_lookup_s(cg->codemap, ".code"), RVM_CODE2BYTE_OFFSET(rvm_codegen_getcodesize(cg)));

diff --git a/rvm/rvmcodegen.h b/rvm/rvmcodegen.h
index 1a3c61a..8ec32bd 100644 (file)
--- a/rvm/rvmcodegen.h
+++ b/rvm/rvmcodegen.h
@@ -48,6 +48,8 @@ rint rvm_codegen_relocate(rvm_codegen_t *cg, rvm_codelabel_t **err);
 rlong rvm_codegen_redefinelabel(rvm_codegen_t *cg, rlong index);
 rlong rvm_codegen_addlabel(rvm_codegen_t *cg, const rchar* name, ruint namesize);
 rlong rvm_codegen_addlabel_s(rvm_codegen_t *cg, const rchar* name);
+rlong rvm_codegen_invalid_addlabel(rvm_codegen_t *cg, const rchar* name, ruint namesize);
+rlong rvm_codegen_invalid_addlabel_s(rvm_codegen_t *cg, const rchar* name);
 rlong rvm_codegen_adddata(rvm_codegen_t *cg, const rchar *name, ruint namesize, rconstpointer data, rsize_t size);
 rlong rvm_codegen_adddata_s(rvm_codegen_t *cg, const rchar *name, rconstpointer data, rsize_t size);
 rlong rvm_codegen_addstring(rvm_codegen_t *cg, const rchar *name, ruint namesize, const rchar* data);