RPA Toolkit
added rule id, input offset to the rparecord_t structure.
authorMartin Stoilov <martin@rpasearch.com>
Sat, 2 Jul 2011 03:15:04 +0000 (20:15 -0700)
committerMartin Stoilov <martin@rpasearch.com>
Sat, 2 Jul 2011 03:15:04 +0000 (20:15 -0700)
rpa/doc/example/personname.c
rpa/rpacompiler.c
rpa/rpacompiler.h
rpa/rpadbex.c
rpa/rpadbex.h
rpa/rpaparser.c
rpa/rparecord.h
rpa/rpavm.c

index 732104c..0742eee 100644 (file)
@@ -44,6 +44,7 @@ int main(int argc, char *argv[])
                "middle ::= [A-Za-z]+ '.'?\n"
                "last   ::= [A-Za-z]+\n"
                "name   ::= <first> ' ' <middle> ' ' <last>\n";
+
        dbex = rpa_dbex_create();
        rpa_dbex_open(dbex);
        rpa_dbex_load(dbex, bnf, strlen(bnf));
@@ -51,18 +52,18 @@ int main(int argc, char *argv[])
        rpa_dbex_compile(dbex);
        stat = rpa_stat_create(dbex, RPA_DEFAULT_STACKSIZE);
        rpa_stat_parse(stat, rpa_dbex_last(dbex), RPA_ENCODING_UTF8, name, name, name+sizeof(name), records);
-       rpa_stat_destroy(stat);
-       rpa_dbex_destroy(dbex);
        for (i = 0; i < rpa_records_length(records); i++) {
                record = rpa_records_slot(records, i);
                if (record->type == RPA_RECORD_START)
-                       fprintf(stdout, "RPA_RECORD_START   (ID: %d)  ", record->ruleuid);
+                       fprintf(stdout, "RPA_RECORD_START   (UID: %d)  ", record->ruleuid);
                if (record->type == RPA_RECORD_END)
-                       fprintf(stdout, "RPA_RECORD_END     (ID: %d)  ", record->ruleuid);
-               fprintf(stdout, "%s: ", record->rule);
-               fwrite(record->input, 1, record->inputsiz, stdout);
+                       fprintf(stdout, "RPA_RECORD_END     (UID: %d)  ", record->ruleuid);
+               fprintf(stdout, "%s: ", rpa_dbex_name(dbex, record->ruleid));
+               fwrite(&name[record->inputoff], 1, record->inputsiz, stdout);
                fprintf(stdout, "\n");
        }
        rpa_records_destroy(records);
+       rpa_stat_destroy(stat);
+       rpa_dbex_destroy(dbex);
        return 0;
 }
index f13092a..a855991 100644 (file)
@@ -211,6 +211,21 @@ rpa_rulepref_t *rpa_compiler_rulepref_s(rpa_compiler_t *co, const rchar *name)
 }
 
 
+void rpa_compiler_rulepref_set_ruleid(rpa_compiler_t *co, const rchar *name, ruinteger namesize, rlong ruleid)
+{
+       rpa_rulepref_t *rulepref = rpa_compiler_rulepref(co, name, namesize);
+
+       R_ASSERT(rulepref);
+       rulepref->ruleid = ruleid;
+}
+
+
+void rpa_compiler_rulepref_set_ruleid_s(rpa_compiler_t *co, const rchar *name, rlong ruleid)
+{
+       rpa_compiler_rulepref_set_ruleid(co, name, r_strlen(name), ruleid);
+}
+
+
 void rpa_compiler_rulepref_set_ruleuid(rpa_compiler_t *co, const rchar *name, ruinteger namesize, rlong ruleuid)
 {
        rpa_rulepref_t *rulepref = rpa_compiler_rulepref(co, name, namesize);
@@ -256,19 +271,20 @@ void rpa_compiler_rulepref_clear_flag_s(rpa_compiler_t *co, const rchar *name, r
 }
 
 
-void rpa_compiler_rulepref_set_ruleuid_flags(rpa_compiler_t *co, const rchar *name, ruinteger namesize, rlong ruleuid, rulong flags)
+void rpa_compiler_rulepref_set(rpa_compiler_t *co, const rchar *name, ruinteger namesize, rlong ruleid, rlong ruleuid, rulong flags)
 {
        rpa_rulepref_t *rulepref = rpa_compiler_rulepref(co, name, namesize);
 
        R_ASSERT(rulepref);
+       rulepref->ruleid = ruleid;
        rulepref->ruleuid = ruleuid;
        rulepref->flags = flags;
 }
 
 
-void rpa_compiler_rulepref_set_ruleuid_flags_s(rpa_compiler_t *co, const rchar *name, rlong ruleuid, rulong flags)
+void rpa_compiler_rulepref_set_s(rpa_compiler_t *co, const rchar *name, rlong ruleid, rlong ruleuid, rulong flags)
 {
-       rpa_compiler_rulepref_set_ruleuid_flags(co, name, r_strlen(name), ruleuid, flags);
+       rpa_compiler_rulepref_set(co, name, r_strlen(name), ruleid, ruleuid, flags);
 }
 
 
@@ -305,7 +321,8 @@ rlong rpa_compiler_addblob_s(rpa_compiler_t *co, rlong ruleid, rlong ruleuid, ru
 rinteger rpa_compiler_loop_begin(rpa_compiler_t *co, const rchar *name, ruinteger namesize)
 {
        rpa_ruledef_t exp;
-       rlong ruleuid = RPA_RECORD_INVALID_UID;
+       rlong ruleuid = 0;
+       rlong ruleid = 0;
        rulong flags = 0;
 
        r_memset(&exp, 0, sizeof(exp));
@@ -313,6 +330,7 @@ rinteger rpa_compiler_loop_begin(rpa_compiler_t *co, const rchar *name, ruintege
        if (exp.rulepref) {
                flags = exp.rulepref->flags;
                ruleuid = exp.rulepref->ruleuid;
+               ruleid = exp.rulepref->ruleid;
        }
        exp.start = rvm_codegen_getcodesize(co->cg);
        exp.startidx = rvm_codegen_addlabel_default(co->cg, name, namesize);
@@ -320,7 +338,7 @@ rinteger rpa_compiler_loop_begin(rpa_compiler_t *co, const rchar *name, ruintege
        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, ruleuid, flags, name, namesize);
+       exp.dataidx = rpa_compiler_addblob(co, ruleid, ruleuid, flags, name, namesize);
 
        rvm_codegen_addins(co->cg, rvm_asm(RVM_CLR, R3, XX, XX, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_CLR, R0, XX, XX, 0));
@@ -386,7 +404,8 @@ rinteger rpa_compiler_loop_end(rpa_compiler_t *co)
 rinteger rpa_compiler_rule_begin(rpa_compiler_t *co, const rchar *name, ruinteger namesize)
 {
        rpa_ruledef_t exp;
-       rlong ruleuid = RPA_RECORD_INVALID_UID;
+       rlong ruleuid = 0;
+       rlong ruleid = 0;
        rulong flags = 0;
 
        r_memset(&exp, 0, sizeof(exp));
@@ -394,11 +413,12 @@ rinteger rpa_compiler_rule_begin(rpa_compiler_t *co, const rchar *name, ruintege
        if (exp.rulepref) {
                flags = exp.rulepref->flags;
                ruleuid = exp.rulepref->ruleuid;
+               ruleid = exp.rulepref->ruleid;
        }
        exp.start = rvm_codegen_getcodesize(co->cg);
        exp.startidx = rvm_codegen_addlabel_default(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, ruleuid, flags, name, namesize);
+       exp.dataidx = rpa_compiler_addblob(co, ruleid, ruleuid, flags, 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_BXNEQ, LR, XX, XX, 0));
@@ -461,7 +481,8 @@ rinteger rpa_compiler_rule_end(rpa_compiler_t *co)
 rinteger rpa_compiler_inlinerule_begin(rpa_compiler_t *co, const rchar *name, ruinteger namesize, ruinteger flags)
 {
        rpa_ruledef_t exp;
-       rlong ruleuid = RPA_RECORD_INVALID_UID;
+       rlong ruleuid = 0;
+       rlong ruleid = 0;
        rulong ruleflags = 0;
 
        r_memset(&exp, 0, sizeof(exp));
@@ -469,13 +490,14 @@ rinteger rpa_compiler_inlinerule_begin(rpa_compiler_t *co, const rchar *name, ru
        if (exp.rulepref) {
                ruleflags = exp.rulepref->flags;
                ruleuid = exp.rulepref->ruleuid;
+               ruleid = exp.rulepref->ruleid;
        }
 
        exp.branch = rvm_codegen_addins(co->cg, rvm_asm(RVM_B, DA, XX, XX, 0));
        exp.start = rvm_codegen_getcodesize(co->cg);
        exp.startidx = rpa_codegen_add_numlabel_s(co->cg, "__inlined", exp.start);
        exp.endidx = rpa_codegen_invalid_add_numlabel_s(co->cg, "__end", exp.start);
-       exp.dataidx = rpa_compiler_addblob(co, exp.start, ruleuid, ruleflags, name, namesize);
+       exp.dataidx = rpa_compiler_addblob(co, ruleid, ruleuid, ruleflags, name, namesize);
 
        rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSH, R_REC, XX, XX, 0));
        rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSH, R_TOP, XX, XX, 0));
index 4cf1555..eed7139 100644 (file)
@@ -19,6 +19,7 @@ extern "C" {
  * rpa_ruledata_t and access in runtime.
  */
 typedef struct rpa_rulepref_s {
+       rlong ruleid;
        rlong ruleuid;
        rulong flags;
 } rpa_rulepref_t;
@@ -104,15 +105,16 @@ void rpa_compiler_reference_opt_s(rpa_compiler_t *co, const rchar *name);
 void rpa_compiler_reference_mul_s(rpa_compiler_t *co, const rchar *name);
 void rpa_compiler_reference_mop_s(rpa_compiler_t *co, const rchar *name);
 
+void rpa_compiler_rulepref_set_ruleid(rpa_compiler_t *co, const rchar *name, ruinteger namesize, rlong ruleid);
+void rpa_compiler_rulepref_set_ruleid_s(rpa_compiler_t *co, const rchar *name, rlong ruleid);
 void rpa_compiler_rulepref_set_ruleuid(rpa_compiler_t *co, const rchar *name, ruinteger namesize, rlong ruleuid);
 void rpa_compiler_rulepref_set_ruleuid_s(rpa_compiler_t *co, const rchar *name, rlong ruleuid);
 void rpa_compiler_rulepref_set_flag(rpa_compiler_t *co, const rchar *name, ruinteger namesize, rulong flag);
 void rpa_compiler_rulepref_set_flag_s(rpa_compiler_t *co, const rchar *name, rulong flag);
 void rpa_compiler_rulepref_clear_flag(rpa_compiler_t *co, const rchar *name, ruinteger namesize, rulong flag);
 void rpa_compiler_rulepref_clear_flag_s(rpa_compiler_t *co, const rchar *name, rulong flag);
-void rpa_compiler_rulepref_set_ruleuid_flags(rpa_compiler_t *co, const rchar *name, ruinteger namesize, rlong ruleuid, rulong flags);
-void rpa_compiler_rulepref_clear_flag(rpa_compiler_t *co, const rchar *name, ruinteger namesize, rulong flag);
-void rpa_compiler_rulepref_set_ruleuid_flags_s(rpa_compiler_t *co, const rchar *name, rlong ruleuid, rulong flags);
+void rpa_compiler_rulepref_set(rpa_compiler_t *co, const rchar *name, ruinteger namesize, rlong ruleid, rlong ruleuid, rulong flags);
+void rpa_compiler_rulepref_set_s(rpa_compiler_t *co, const rchar *name, rlong ruleid, rlong ruleuid, rulong flags);
 #ifdef __cplusplus
 }
 #endif
index 3b12e60..5eeded7 100644 (file)
@@ -1676,6 +1676,23 @@ rsize_t rpa_dbex_strncpy(rpadbex_t *dbex, rchar *dst, rparule_t rid, rsize_t n)
 }
 
 
+const rchar *rpa_dbex_name(rpadbex_t *dbex, rparule_t rid)
+{
+       rstr_t *name;
+
+       if (!dbex)
+               return NULL;
+       if (!dbex->rules) {
+               RPA_DBEX_SETERRINFO_CODE(dbex, RPA_E_NOTCLOSED);
+               return NULL;
+       }
+       if (rid >= r_array_length(dbex->rules->members))
+               return NULL;
+       name = r_array_index(dbex->rules->names, rid, rstr_t*);
+       return name->str;
+}
+
+
 rparule_t rpa_dbex_first(rpadbex_t *dbex)
 {
        if (!dbex)
@@ -1798,6 +1815,11 @@ static rinteger rpa_dbex_compile_rule(rpadbex_t *dbex, rparule_t rid)
        if (!info)
                return -1;
        codeoff = rvm_codegen_getcodesize(dbex->co->cg);
+       /*
+        * Set the rid in the rulepref, so the compiler associates this rule
+        * with the correct rid.
+        */
+       rpa_compiler_rulepref_set_ruleid_s(dbex->co, rpa_dbex_name(dbex, rid), rid);
        if (rpa_dbex_playrecord(dbex, info->startrec) < 0)
                return -1;
        info->codeoff = codeoff;
index 0613795..324b6e1 100644 (file)
@@ -236,6 +236,20 @@ rparule_t rpa_dbex_lookup_s(rpadbex_t *dbex, const rchar *name);
 
 
 /**
+ * @brief Return the name of the specified rule ID.
+ *
+ * If rid is a valid rule, this function will return a pointer to the rule name.
+ * The returned points directly in the database structures, if you need
+ * to preserved name, you will have to make a copy.
+ *
+ * @param dbex Pointer to \ref rpadbex_t object.
+ * @param rid Rule id
+ * @return Returns the name of the specified ID or NULL in case of error.
+ */
+const rchar *rpa_dbex_name(rpadbex_t *dbex, rparule_t rid);
+
+
+/**
  * \brief Return the first production ID in the database.
  *
  * Depending on how the BNF schema is structured, if the first production is also the
index 8133da3..8a52b0b 100644 (file)
@@ -117,7 +117,7 @@ static void rpa_production_bnf(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-//     rpa_compiler_rulepref_set_ruleuid_flags_s(co, "bnf", RPA_PRODUCTION_BNF);
+//     rpa_compiler_rulepref_set_s(co, "bnf", 0, RPA_PRODUCTION_BNF);
        rpa_compiler_rule_begin_s(co, "bnf");
 
        rpa_compiler_altexp_begin(co, RPA_MATCH_MULTIPLE);
@@ -170,7 +170,7 @@ static void rpa_production_directive_emitid(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "emitid", RPA_PRODUCTION_DIRECTIVEEMITID, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "emitid", 0, RPA_PRODUCTION_DIRECTIVEEMITID, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "emitid");
 
        rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, '#'));
@@ -210,7 +210,7 @@ static void rpa_production_directive_emit(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "emit", RPA_PRODUCTION_DIRECTIVEEMIT, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "emit", 0, RPA_PRODUCTION_DIRECTIVEEMIT, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "emit");
 
        rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, '#'));
@@ -239,7 +239,7 @@ static void rpa_production_directive_abort(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "abort", RPA_PRODUCTION_DIRECTIVEABORT, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "abort", 0, RPA_PRODUCTION_DIRECTIVEABORT, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "abort");
 
        rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, '#'));
@@ -270,7 +270,7 @@ static void rpa_production_directive_emitall(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "emitall", RPA_PRODUCTION_DIRECTIVEEMITALL, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "emitall", 0, RPA_PRODUCTION_DIRECTIVEEMITALL, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "emitall");
 
        rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, '#'));
@@ -301,7 +301,7 @@ static void rpa_production_directive_emitnone(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "emitnone", RPA_PRODUCTION_DIRECTIVEEMITNONE, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "emitnone", 0, RPA_PRODUCTION_DIRECTIVEEMITNONE, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "emitnone");
 
        rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, '#'));
@@ -334,7 +334,7 @@ static void rpa_production_directive_noemit(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "noemit", RPA_PRODUCTION_DIRECTIVENOEMIT, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "noemit", 0, RPA_PRODUCTION_DIRECTIVENOEMIT, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "noemit");
 
        rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, '#'));
@@ -396,7 +396,7 @@ static void rpa_production_namedrule(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "namedrule", RPA_PRODUCTION_NAMEDRULE, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "namedrule", 0, RPA_PRODUCTION_NAMEDRULE, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "namedrule");
 
        rpa_compiler_reference_opt_s(co, "space");
@@ -418,7 +418,7 @@ static void rpa_production_anonymousrule(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "anonymousrule", RPA_PRODUCTION_ANONYMOUSRULE, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "anonymousrule", 0, RPA_PRODUCTION_ANONYMOUSRULE, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "anonymousrule");
 
        rpa_compiler_reference_opt_s(co, "space");
@@ -452,7 +452,7 @@ static void rpa_production_rulename(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "rulename", RPA_PRODUCTION_RULENAME, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "rulename", 0, RPA_PRODUCTION_RULENAME, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "rulename");
 
        rpa_compiler_class_begin(co, RPA_MATCH_NONE);
@@ -486,7 +486,7 @@ static void rpa_production_aliasname(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "aliasname", RPA_PRODUCTION_ALIASNAME, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "aliasname", 0, RPA_PRODUCTION_ALIASNAME, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "aliasname");
 
        rpa_compiler_class_begin(co, RPA_MATCH_NONE);
@@ -599,7 +599,7 @@ static void rpa_production_char(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "char", RPA_PRODUCTION_CHAR, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "char", 0, RPA_PRODUCTION_CHAR, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "char");
        rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHSPCHR_NAN, DA, XX, XX, '.'));
        rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
@@ -633,7 +633,7 @@ static void rpa_production_specialchar(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "specialchar", RPA_PRODUCTION_SPECIALCHAR, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "specialchar", 0, RPA_PRODUCTION_SPECIALCHAR, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "specialchar");
 
        rpa_compiler_class_begin(co, RPA_MATCH_NONE);
@@ -688,7 +688,7 @@ static void rpa_production_clschar(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "clschar", RPA_PRODUCTION_CLSCHAR, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "clschar", 0, RPA_PRODUCTION_CLSCHAR, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "clschar");
 
        rpa_production_clschars(pa);
@@ -702,7 +702,7 @@ static void rpa_production_beginchar(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "beginchar", RPA_PRODUCTION_BEGINCHAR, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "beginchar", 0, RPA_PRODUCTION_BEGINCHAR, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "beginchar");
 
 //     rpa_compiler_class_begin(co, RPA_MATCH_NONE);
@@ -720,7 +720,7 @@ static void rpa_production_endchar(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "endchar", RPA_PRODUCTION_ENDCHAR, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "endchar", 0, RPA_PRODUCTION_ENDCHAR, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "endchar");
 
 //     rpa_compiler_class_begin(co, RPA_MATCH_NONE);
@@ -737,7 +737,7 @@ static void rpa_production_occurence(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "occurence", RPA_PRODUCTION_OCCURENCE, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "occurence", 0, RPA_PRODUCTION_OCCURENCE, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "occurence");
 
        rpa_compiler_class_begin(co, RPA_MATCH_NONE);
@@ -758,7 +758,7 @@ static void rpa_production_charrng(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "charrng", RPA_PRODUCTION_CHARRNG, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "charrng", 0, RPA_PRODUCTION_CHARRNG, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "charrng");
        rpa_compiler_reference_nan_s(co, "beginchar");
        rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
@@ -774,7 +774,7 @@ static void rpa_production_numrng(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "numrng", RPA_PRODUCTION_NUMRNG, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "numrng", 0, RPA_PRODUCTION_NUMRNG, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "numrng");
 
        rpa_compiler_reference_nan_s(co, "num");
@@ -875,7 +875,7 @@ static void rpa_production_clsnum(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "clsnum", RPA_PRODUCTION_CLSNUM, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "clsnum", 0, RPA_PRODUCTION_CLSNUM, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "clsnum");
 
        rpa_compiler_reference_nan_s(co, "num");
@@ -921,7 +921,7 @@ static void rpa_production_cls(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "cls", RPA_PRODUCTION_CLS, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "cls", 0, RPA_PRODUCTION_CLS, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "cls");
 
        rpa_compiler_altexp_begin(co, RPA_MATCH_NONE);
@@ -946,7 +946,7 @@ static void rpa_production_dec(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "dec", RPA_PRODUCTION_DEC, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "dec", 0, RPA_PRODUCTION_DEC, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "dec");
 
        rvm_codegen_addins(co->cg, rvm_asm2(RPA_MATCHRNG_NAN, DA, XX, XX, '1', '9'));
@@ -962,7 +962,7 @@ static void rpa_production_hex(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "hex", RPA_PRODUCTION_HEX, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "hex", 0, RPA_PRODUCTION_HEX, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "hex");
 
        rpa_compiler_class_begin(co, RPA_MATCH_MULTIPLE);
@@ -1020,7 +1020,7 @@ static void rpa_production_aref(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "aref", RPA_PRODUCTION_AREF, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "aref", 0, RPA_PRODUCTION_AREF, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "aref");
 
        rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, '<'));
@@ -1040,7 +1040,7 @@ static void rpa_production_cref(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "cref", RPA_PRODUCTION_CREF, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "cref", 0, RPA_PRODUCTION_CREF, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "cref");
 
        rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, '<'));
@@ -1171,7 +1171,7 @@ static void rpa_production_anchorop(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "anchorop", RPA_PRODUCTION_ANCHOROP, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "anchorop", 0, RPA_PRODUCTION_ANCHOROP, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "anchorop");
        rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, '~'));
        rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
@@ -1207,7 +1207,7 @@ static void rpa_production_notop(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "notop", RPA_PRODUCTION_NOTOP, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "notop", 0, RPA_PRODUCTION_NOTOP, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "notop");
        rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, '^'));
        rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
@@ -1246,7 +1246,7 @@ static void rpa_production_exp(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-//     rpa_compiler_rulepref_set_ruleuid_flags_s(co, "exp", RPA_PRODUCTION_EXP);
+//     rpa_compiler_rulepref_set_s(co, "exp", 0, RPA_PRODUCTION_EXP);
        rpa_compiler_rule_begin_s(co, "exp");
        rpa_compiler_reference_mul_s(co, "notexp");
        rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, RPA_COMPILER_CURRENTEXP(co)->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
@@ -1258,7 +1258,7 @@ static void rpa_production_bracketexp(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "bracketexp", RPA_PRODUCTION_BRACKETEXP, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "bracketexp", 0, RPA_PRODUCTION_BRACKETEXP, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "bracketexp");
 
        rvm_codegen_addins(co->cg, rvm_asm(RPA_MATCHCHR_NAN, DA, XX, XX, '('));
@@ -1283,7 +1283,7 @@ static void rpa_production_negbranch(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "negbranch", RPA_PRODUCTION_NEGBRANCH, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "negbranch", 0, RPA_PRODUCTION_NEGBRANCH, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "negbranch");
 
        rpa_compiler_reference_nan_s(co, "exp");
@@ -1297,7 +1297,7 @@ static void rpa_production_norop(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "norop", RPA_PRODUCTION_NOROP, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "norop", 0, RPA_PRODUCTION_NOROP, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "norop");
 
        rpa_compiler_exp_begin(co, RPA_MATCH_MULTIPLE);
@@ -1318,7 +1318,7 @@ static void rpa_production_reqop(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "reqop", RPA_PRODUCTION_REQOP, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "reqop", 0, RPA_PRODUCTION_REQOP, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "reqop");
 
        rpa_compiler_reference_nan_s(co, "exp");
@@ -1332,7 +1332,7 @@ static void rpa_production_minop(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "minop", RPA_PRODUCTION_MINOP, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "minop", 0, RPA_PRODUCTION_MINOP, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "minop");
 
        rpa_compiler_reference_nan_s(co, "reqop");
@@ -1371,7 +1371,7 @@ static void rpa_production_altbranch(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "altbranch", RPA_PRODUCTION_ALTBRANCH, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "altbranch", 0, RPA_PRODUCTION_ALTBRANCH, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "altbranch");
 
        rpa_compiler_reference_nan_s(co, "minexp");
@@ -1385,7 +1385,7 @@ static void rpa_production_orop(rpa_parser_t *pa)
 {
        rpa_compiler_t *co = pa->co;
 
-       rpa_compiler_rulepref_set_ruleuid_flags_s(co, "orop", RPA_PRODUCTION_OROP, RPA_RFLAG_EMITRECORD);
+       rpa_compiler_rulepref_set_s(co, "orop", 0, RPA_PRODUCTION_OROP, RPA_RFLAG_EMITRECORD);
        rpa_compiler_rule_begin_s(co, "orop");
 
        rpa_compiler_reference_nan_s(co, "altbranch");
index b283205..aaabd87 100644 (file)
@@ -97,8 +97,10 @@ struct rparecord_s {
        ruint32 size;                   /**< This is a private member, used by the engine and is not significant to the user */
        const rchar *rule;              /**< Name of the rule that generated this record */
        const rchar *input;             /**< Pointer in the input stream */
+       rsize_t inputoff;               /**< Input offset, calculated from the start parameter passed to @ref rpa_stat_parse */
        rsize_t inputsiz;               /**< Size of input */
        ruint32 type;                   /**< Record Type: @ref RPA_RECORD_START or @ref RPA_RECORD_END */
+       ruint32 ruleid;                 /**< Unique ID, identifying the BNF rule that created the record */
        ruint32 ruleuid;                /**< User specified Rule ID. If you used directive @ref emitid for this rulename, this member will contain the specified ID */
        ruint32 usertype;               /**< User specified type. */
        rword userdata;                 /**< Scratch area. This member can be used to associate some user specific data with this record. */
index 53247a3..d67041f 100644 (file)
@@ -265,9 +265,11 @@ static void rpavm_swi_emitstart(rvmcpu_t *cpu, rvm_asmins_t *ins)
        rec = (rparecord_t *)r_array_slot(stat->records, index);
        rec->rule = name.str;
        rec->top = tp;
+       rec->ruleid = ruledata->ruleid;
        rec->ruleuid = ruledata->ruleuid;
        rec->type = RPA_RECORD_START;
        rec->input = stat->instack[tp].input;
+       rec->inputoff = stat->instack[tp].input - stat->start;
        rec->inputsiz = 0;
 }
 
@@ -297,9 +299,11 @@ static void rpavm_swi_emitend(rvmcpu_t *cpu, rvm_asmins_t *ins)
        rec->top = tp;
        rec->size = tplen;
        rec->type = RPA_RECORD_END;
+       rec->ruleid = ruledata->ruleid;
        rec->ruleuid = ruledata->ruleuid;
        rec->input = stat->instack[tp].input;
        rec->inputsiz = stat->instack[tp + tplen].input - stat->instack[tp].input;
+       rec->inputoff = stat->instack[tp].input - stat->start;
        startrec->size = tplen;
        startrec->inputsiz = rec->inputsiz;
 }