work on RPA2 ALT expressions

diff --git a/rpa2/rpacompiler.c b/rpa2/rpacompiler.c
index 9ead57b..40f8c23 100644 (file)
--- a/rpa2/rpacompiler.c
+++ b/rpa2/rpacompiler.c
@@ -161,8 +161,102 @@ rint rpa_compiler_exp_end(rpa_compiler_t *co, ruint qflag)
        rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, R0, DA, XX, -1));
        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_BXLWHT, R_MNODE_NAN, DA, XX, 0));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_JUMP, exp.labelidx, rvm_asm(RVM_MOV, R_WHT, DA, XX, 0));
+       if (qflag == RPA_MATCH_OPTIONAL) {
+               rvm_codegen_addrelocins_s(co->cg, RVM_RELOC_BRANCH, "rpacompiler_mnode_opt", rvm_asm(RVM_BL, DA, XX, XX, 0));
+       } else if (qflag == RPA_MATCH_MULTIPLE) {
+               rvm_codegen_addrelocins_s(co->cg, RVM_RELOC_BRANCH, "rpacompiler_mnode_mul", rvm_asm(RVM_BL, DA, XX, XX, 0));
+       } else if (qflag == RPA_MATCH_MULTIOPT) {
+               rvm_codegen_addrelocins_s(co->cg, RVM_RELOC_BRANCH, "rpacompiler_mnode_mop", rvm_asm(RVM_BL, DA, XX, XX, 0));
+       } else {
+               rvm_codegen_addrelocins_s(co->cg, RVM_RELOC_BRANCH, "rpacompiler_mnode_nan", rvm_asm(RVM_BL, DA, XX, XX, 0));
+       }
+       return 0;
+}
+
+
+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);
+       r_array_add(co->expressions, &exp);
+       return 0;
+}
+
+
+rint rpa_compiler_altexp_end(rpa_compiler_t *co, ruint qflag)
+{
+       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_WHT)|BIT(LR)));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, 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_WHT)|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_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(RVM_MOV, R_WHT, DA, XX, 0));
+       if (qflag == RPA_MATCH_OPTIONAL) {
+               rvm_codegen_addrelocins_s(co->cg, RVM_RELOC_BRANCH, "rpacompiler_mnode_opt", rvm_asm(RVM_BL, DA, XX, XX, 0));
+       } else if (qflag == RPA_MATCH_MULTIPLE) {
+               rvm_codegen_addrelocins_s(co->cg, RVM_RELOC_BRANCH, "rpacompiler_mnode_mul", rvm_asm(RVM_BL, DA, XX, XX, 0));
+       } else if (qflag == RPA_MATCH_MULTIOPT) {
+               rvm_codegen_addrelocins_s(co->cg, RVM_RELOC_BRANCH, "rpacompiler_mnode_mop", rvm_asm(RVM_BL, DA, XX, XX, 0));
+       } else {
+               rvm_codegen_addrelocins_s(co->cg, RVM_RELOC_BRANCH, "rpacompiler_mnode_nan", rvm_asm(RVM_BL, DA, XX, XX, 0));
+       }
        return 0;
 }
 
+
+rint rpa_compiler_altbranch_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);
+       r_array_add(co->expressions, &exp);
+       return 0;
+}
+
+
+rint rpa_compiler_altbranch_end(rpa_compiler_t *co, ruint qflag)
+{
+       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(R_WHT)|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(R_TOP)|BIT(R_WHT)|BIT(LR)));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, R0, DA, XX, -1));
+       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(RVM_MOV, R_WHT, DA, XX, 0));
+       if (qflag == RPA_MATCH_OPTIONAL) {
+               rvm_codegen_addrelocins_s(co->cg, RVM_RELOC_BRANCH, "rpacompiler_mnode_opt", rvm_asm(RVM_BL, DA, XX, XX, 0));
+       } else if (qflag == RPA_MATCH_MULTIPLE) {
+               rvm_codegen_addrelocins_s(co->cg, RVM_RELOC_BRANCH, "rpacompiler_mnode_mul", rvm_asm(RVM_BL, DA, XX, XX, 0));
+       } else if (qflag == RPA_MATCH_MULTIOPT) {
+               rvm_codegen_addrelocins_s(co->cg, RVM_RELOC_BRANCH, "rpacompiler_mnode_mop", rvm_asm(RVM_BL, DA, XX, XX, 0));
+       } else {
+               rvm_codegen_addrelocins_s(co->cg, RVM_RELOC_BRANCH, "rpacompiler_mnode_nan", rvm_asm(RVM_BL, 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));
+
+       return 0;
+}

diff --git a/rpa2/rpacompiler.h b/rpa2/rpacompiler.h
index 2831ebc..93014d6 100644 (file)
--- a/rpa2/rpacompiler.h
+++ b/rpa2/rpacompiler.h
@@ -34,10 +34,14 @@ void rpa_compiler_destroy(rpa_compiler_t *co);
 rint rpa_compiler_rule_begin(rpa_compiler_t *co, const rchar *name, ruint namesize);
 rint rpa_compiler_rule_begin_s(rpa_compiler_t *co, const rchar *name);
 rint rpa_compiler_rule_end(rpa_compiler_t *co);
-
 rint rpa_compiler_exp_begin(rpa_compiler_t *co);
 rint rpa_compiler_exp_end(rpa_compiler_t *co, ruint qflag);
 
+rint rpa_compiler_altbranch_begin(rpa_compiler_t *co);
+rint rpa_compiler_altbranch_end(rpa_compiler_t *co, ruint qflag);
+rint rpa_compiler_altexp_begin(rpa_compiler_t *co);
+rint rpa_compiler_altexp_end(rpa_compiler_t *co, ruint qflag);
+
 
 #ifdef __cplusplus
 }

diff --git a/testrpa2/build/linux/testrpa2.mk b/testrpa2/build/linux/testrpa2.mk
index d7c6e8e..8ff870a 100644 (file)
--- a/testrpa2/build/linux/testrpa2.mk
+++ b/testrpa2/build/linux/testrpa2.mk
@@ -15,6 +15,7 @@ TESTS += $(OUTDIR)/rpavm-matchchr
 TESTS  += $(OUTDIR)/rpavm-mnode
 TESTS  += $(OUTDIR)/rpacompiler-rule
 TESTS  += $(OUTDIR)/rpacompiler-exp
+TESTS  += $(OUTDIR)/rpacompiler-altexp
 
 all : $(OUTDIR) $(TESTS)
 

diff --git a/testrpa2/rpacompiler-altexp.c b/testrpa2/rpacompiler-altexp.c
new file mode 100644 (file)
index 0000000..1ea71d8
--- /dev/null
+++ b/testrpa2/rpacompiler-altexp.c
@@ -0,0 +1,109 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include "rmem.h"
+#include "rpacompiler.h"
+#include "rpastat.h"
+#include "common.h"
+
+
+
+void code_rpa_matchaltexp(rpa_compiler_t *co, rpastat_t *stat)
+{
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, R_TOP, DA, XX, 0));
+       rpa_compiler_altexp_begin(co);
+       rpa_compiler_altbranch_begin(co);
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'd'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'e'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'f'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rpa_compiler_altbranch_end(co, RPA_MATCH_NONE);
+       rpa_compiler_altbranch_begin(co);
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'a'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'b'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'c'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rpa_compiler_altbranch_end(co, RPA_MATCH_NONE);
+       rpa_compiler_altexp_end(co, RPA_MATCH_NONE);
+       VMTEST_REG(co->cg, 0, 3, "RPA_MATCH_NONE 'abc|def'");
+       VMTEST_STATUS(co->cg, 0, "RPA_MATCH_NONE STATUS");
+
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, R_TOP, DA, XX, 0));
+       rpa_compiler_altexp_begin(co);
+       rpa_compiler_altbranch_begin(co);
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'd'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'e'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'f'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rpa_compiler_altbranch_end(co, RPA_MATCH_NONE);
+       rpa_compiler_altbranch_begin(co);
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'a'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'b'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'c'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rpa_compiler_altbranch_end(co, RPA_MATCH_NONE);
+       rpa_compiler_altexp_end(co, RPA_MATCH_MULTIPLE);
+       VMTEST_REG(co->cg, 0, 15, "RPA_MATCH_MULTIPLE 'abc|def'");
+       VMTEST_STATUS(co->cg, 0, "RPA_MATCH_MULTIPLE STATUS");
+
+}
+
+
+int main(int argc, char *argv[])
+{
+       rvm_codelabel_t *err;
+       rpa_compiler_t *co;
+       rpastat_t *stat;
+       ruint mainoff;
+       char teststr[] = "abcabcabcabcabc";
+
+       co = rpa_compiler_create();
+       stat = rpa_stat_create(4096);
+       rvm_cpu_addswitable(stat->cpu, common_calltable);
+
+       rpa_stat_init(stat, teststr, teststr, teststr+15);
+
+       mainoff = rvm_codegen_addins(co->cg, rvm_asml(RVM_NOP, XX, XX, XX, -1));
+       rvm_codegen_addins(co->cg, rvm_asml(RVM_MOV, R_TOP, DA, XX, -1));
+       rvm_codegen_addins(co->cg, rvm_asml(RVM_MOV, FP, DA, XX, 0));
+       rvm_codegen_addins(co->cg, rvm_asml(RVM_MOV, SP, DA, XX, 0));
+
+       rvm_codegen_addrelocins_s(co->cg, RVM_RELOC_JUMP, "rpacompiler_mnode_nan", rvm_asm(RVM_MOV, R_MNODE_NAN, DA, XX, 0));
+       rvm_codegen_addrelocins_s(co->cg, RVM_RELOC_JUMP, "rpacompiler_mnode_mul", rvm_asm(RVM_MOV, R_MNODE_MUL, DA, XX, 0));
+       rvm_codegen_addrelocins_s(co->cg, RVM_RELOC_JUMP, "rpacompiler_mnode_opt", rvm_asm(RVM_MOV, R_MNODE_OPT, DA, XX, 0));
+       rvm_codegen_addrelocins_s(co->cg, RVM_RELOC_JUMP, "rpacompiler_mnode_mop", rvm_asm(RVM_MOV, R_MNODE_MOP, DA, XX, 0));
+
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_SHIFT, XX, XX, XX, 0));
+       code_rpa_matchaltexp(co, stat);
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_NOP, XX, XX, XX, 0xabc));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_EXT, XX, XX, XX, 0));
+
+       if (rvm_codegen_relocate(co->cg, &err) < 0) {
+               r_printf("Unresolved symbol: %s\n", err->name->str);
+               goto end;
+       }
+
+       rvm_cpu_exec(stat->cpu, rvm_codegen_getcode(co->cg, 0), mainoff);
+
+end:
+       rpa_stat_destroy(stat);
+       rpa_compiler_destroy(co);
+
+
+       r_printf("Max alloc mem: %ld\n", r_debug_get_maxmem());
+       r_printf("Leaked mem: %ld\n", r_debug_get_allocmem());
+       return 0;
+}

diff --git a/testrpa2/rpacompiler-exp.c b/testrpa2/rpacompiler-exp.c
index 4915d17..5e992f7 100644 (file)
--- a/testrpa2/rpacompiler-exp.c
+++ b/testrpa2/rpacompiler-exp.c
@@ -13,76 +13,109 @@
 
 
 
-void code_rpa_matchabc(rpa_compiler_t *co, rpastat_t *stat)
+void code_rpa_matchexp(rpa_compiler_t *co, rpastat_t *stat)
 {
-       rpa_compiler_rule_begin_s(co, "rpa_matchabc");
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, R_TOP, DA, XX, 0));
        rpa_compiler_exp_begin(co);
        rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'a'));
        rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'b'));
        rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
-       rpa_compiler_exp_end(co, RPA_MATCH_NONE);
        rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'c'));
        rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
-       rpa_compiler_rule_end(co);
-}
-
+       rpa_compiler_exp_end(co, RPA_MATCH_NONE);
+       VMTEST_REG(co->cg, 0, 3, "RPA_MATCH_NONE 'abc'");
+       VMTEST_STATUS(co->cg, 0, "RPA_MATCH_NONE STATUS");
 
-void code_rpa_matchxyz(rpa_compiler_t *co, rpastat_t *stat)
-{
-       rpa_compiler_rule_begin_s(co, "rpa_matchxyz");
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, R_TOP, DA, XX, 0));
        rpa_compiler_exp_begin(co);
        rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'x'));
        rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'y'));
        rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
-       rpa_compiler_exp_end(co, RPA_MATCH_NONE);
        rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'z'));
        rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
-       rpa_compiler_rule_end(co);
-}
+       rpa_compiler_exp_end(co, RPA_MATCH_NONE);
+       VMTEST_REG(co->cg, 0, -1, "RPA_MATCH_NONE 'xyz'");
+       VMTEST_STATUS(co->cg, RVM_STATUS_N, "RPA_MATCH_NONE STATUS");
 
-void code_rpa_matchmnode(rpa_compiler_t *co, rpastat_t *stat)
-{
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, R_TOP, DA, XX, 0));
-       rvm_codegen_addrelocins_s(co->cg, RVM_RELOC_JUMP, "rpa_matchabc", rvm_asm(RPA_BXLWHT, R_MNODE_NAN, DA, XX, 0));
-       VMTEST_REG(co->cg, 0, 3, "RPA_MNODE_NAN 'abc'");
-       VMTEST_STATUS(co->cg, 0, "RPA_MNODE_NAN STATUS");
 
        rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, R_TOP, DA, XX, 0));
-       rvm_codegen_addrelocins_s(co->cg, RVM_RELOC_JUMP, "rpa_matchxyz", rvm_asm(RPA_BXLWHT, R_MNODE_NAN, DA, XX, 0));
-       VMTEST_REG(co->cg, 0, -1, "RPA_MNODE_NAN 'xyz'");
-       VMTEST_STATUS(co->cg, RVM_STATUS_N, "RPA_MNODE_NAN STATUS");
+       rpa_compiler_exp_begin(co);
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'a'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'b'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'c'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rpa_compiler_exp_end(co, RPA_MATCH_OPTIONAL);
+       VMTEST_REG(co->cg, 0, 3, "RPA_MATCH_OPTIONAL 'abc'");
+       VMTEST_STATUS(co->cg, 0, "RPA_MATCH_OPTIONAL STATUS");
 
-       rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, R_TOP, DA, XX, 0));
-       rvm_codegen_addrelocins_s(co->cg, RVM_RELOC_JUMP, "rpa_matchabc", rvm_asm(RPA_BXLWHT, R_MNODE_OPT, DA, XX, 0));
-       VMTEST_REG(co->cg, 0, 3, "RPA_MNODE_OPT 'abc'");
-       VMTEST_STATUS(co->cg, 0, "RPA_MNODE_OPT STATUS");
 
        rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, R_TOP, DA, XX, 0));
-       rvm_codegen_addrelocins_s(co->cg, RVM_RELOC_JUMP, "rpa_matchxyz", rvm_asm(RPA_BXLWHT, R_MNODE_OPT, DA, XX, 0));
-       VMTEST_REG(co->cg, 0, 0, "RPA_MNODE_OPT 'xyz'");
-       VMTEST_STATUS(co->cg, RVM_STATUS_Z, "RPA_MNODE_OPT STATUS");
+       rpa_compiler_exp_begin(co);
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'x'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'y'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'z'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rpa_compiler_exp_end(co, RPA_MATCH_OPTIONAL);
+       VMTEST_REG(co->cg, 0, 0, "RPA_MATCH_OPTIONAL 'xyz'");
+       VMTEST_STATUS(co->cg, RVM_STATUS_Z, "RPA_MATCH_OPTIONAL STATUS");
+
 
        rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, R_TOP, DA, XX, 0));
-       rvm_codegen_addrelocins_s(co->cg, RVM_RELOC_JUMP, "rpa_matchabc", rvm_asm(RPA_BXLWHT, R_MNODE_MUL, DA, XX, 0));
-       VMTEST_REG(co->cg, 0, 12, "RPA_MNODE_MUL 'abc'");
-       VMTEST_STATUS(co->cg, 0, "RPA_MNODE_MUL STATUS");
+       rpa_compiler_exp_begin(co);
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'a'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'b'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'c'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rpa_compiler_exp_end(co, RPA_MATCH_MULTIOPT);
+       VMTEST_REG(co->cg, 0, 12, "RPA_MATCH_MULTIOPT 'abc'");
+       VMTEST_STATUS(co->cg, 0, "RPA_MATCH_MULTIOPT STATUS");
+
 
        rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, R_TOP, DA, XX, 0));
-       rvm_codegen_addrelocins_s(co->cg, RVM_RELOC_JUMP, "rpa_matchxyz", rvm_asm(RPA_BXLWHT, R_MNODE_MUL, DA, XX, 0));
-       VMTEST_REG(co->cg, 0, -1, "RPA_MNODE_MUL 'xyz'");
-       VMTEST_STATUS(co->cg, RVM_STATUS_N, "RPA_MNODE_MUL STATUS");
+       rpa_compiler_exp_begin(co);
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'x'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'y'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'z'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rpa_compiler_exp_end(co, RPA_MATCH_MULTIOPT);
+       VMTEST_REG(co->cg, 0, 0, "RPA_MATCH_MULTIOPT 'xyz'");
+       VMTEST_STATUS(co->cg, RVM_STATUS_Z, "RPA_MATCH_MULTIOPT STATUS");
+
 
        rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, R_TOP, DA, XX, 0));
-       rvm_codegen_addrelocins_s(co->cg, RVM_RELOC_JUMP, "rpa_matchabc", rvm_asm(RPA_BXLWHT, R_MNODE_MOP, DA, XX, 0));
-       VMTEST_REG(co->cg, 0, 12, "RPA_MNODE_MOP 'abc'");
-       VMTEST_STATUS(co->cg, 0, "RPA_MNODE_MOP STATUS");
+       rpa_compiler_exp_begin(co);
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'a'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'b'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'c'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rpa_compiler_exp_end(co, RPA_MATCH_MULTIPLE);
+       VMTEST_REG(co->cg, 0, 12, "RPA_MATCH_MULTIPLE 'abc'");
+       VMTEST_STATUS(co->cg, 0, "RPA_MATCH_MULTIPLE STATUS");
+
 
        rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, R_TOP, DA, XX, 0));
-       rvm_codegen_addrelocins_s(co->cg, RVM_RELOC_JUMP, "rpa_matchxyz", rvm_asm(RPA_BXLWHT, R_MNODE_MOP, DA, XX, 0));
-       VMTEST_REG(co->cg, 0, 0, "RPA_MNODE_MOP 'xyz'");
-       VMTEST_STATUS(co->cg, RVM_STATUS_Z, "RPA_MNODE_MOP STATUS");
+       rpa_compiler_exp_begin(co);
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'x'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'y'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, 'z'));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rpa_compiler_exp_end(co, RPA_MATCH_MULTIPLE);
+       VMTEST_REG(co->cg, 0, -1, "RPA_MATCH_MULTIPLE 'xyz'");
+       VMTEST_STATUS(co->cg, RVM_STATUS_N, "RPA_MATCH_MULTIPLE STATUS");
 
 
 }
@@ -113,18 +146,16 @@ int main(int argc, char *argv[])
        rvm_codegen_addrelocins_s(co->cg, RVM_RELOC_JUMP, "rpacompiler_mnode_mop", rvm_asm(RVM_MOV, R_MNODE_MOP, DA, XX, 0));
 
        rvm_codegen_addins(co->cg, rvm_asm(RPA_SHIFT, XX, XX, XX, 0));
-       code_rpa_matchmnode(co, stat);
+       code_rpa_matchexp(co, stat);
        rvm_codegen_addins(co->cg, rvm_asm(RVM_NOP, XX, XX, XX, 0xabc));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_EXT, XX, XX, XX, 0));
-       code_rpa_matchabc(co, stat);
-       code_rpa_matchxyz(co, stat);
 
        if (rvm_codegen_relocate(co->cg, &err) < 0) {
                r_printf("Unresolved symbol: %s\n", err->name->str);
                goto end;
        }
 
-       rvm_cpu_exec_debug(stat->cpu, rvm_codegen_getcode(co->cg, 0), mainoff);
+       rvm_cpu_exec(stat->cpu, rvm_codegen_getcode(co->cg, 0), mainoff);
 
 end:
        rpa_stat_destroy(stat);

diff --git a/tests/regex-test.c b/tests/regex-test.c
index 17d9f08..e1d990e 100644 (file)
--- a/tests/regex-test.c
+++ b/tests/regex-test.c
@@ -307,20 +307,6 @@ static void rpa_matchrng(rvmcpu_t *cpu, rvm_asmins_t *ins)
 }
 
 
-static void rpa_eqmatchrng(rvmcpu_t *cpu, rvm_asmins_t *ins)
-{
-       if (cpu->status & RVM_STATUS_Z)
-               rpa_matchrng(cpu, ins);
-}
-
-
-static void rpa_neqmatchrng(rvmcpu_t *cpu, rvm_asmins_t *ins)
-{
-       if (!(cpu->status & RVM_STATUS_Z))
-               rpa_matchrng(cpu, ins);
-}
-
-
 static void rpa_emitstart(rvmcpu_t *cpu, rvm_asmins_t *ins)
 {
        rpastat_t *stat = (rpastat_t *)cpu->userdata1;