nfa_api: remove subtype from dispatch

diff --git a/src/nfa/castle.c b/src/nfa/castle.c
index 6a72ae3168ea725160c5ac9234a7867384f66e4e..7c158b31c0111dd8808007b54b50b84707fa473b 100644 (file)
--- a/src/nfa/castle.c
+++ b/src/nfa/castle.c
@@ -745,10 +745,10 @@ void clear_repeats(const struct Castle *c, const struct mq *q, u8 *active) {
 }
 
 static really_inline
-char nfaExecCastle0_Q_i(const struct NFA *n, struct mq *q, s64a end,
-                        enum MatchMode mode) {
+char nfaExecCastle_Q_i(const struct NFA *n, struct mq *q, s64a end,
+                       enum MatchMode mode) {
     assert(n && q);
-    assert(n->type == CASTLE_NFA_0);
+    assert(n->type == CASTLE_NFA);
 
     DEBUG_PRINTF("state=%p, streamState=%p\n", q->state, q->streamState);
 
@@ -856,14 +856,14 @@ char nfaExecCastle0_Q_i(const struct NFA *n, struct mq *q, s64a end,
     return mmbit_any_precise(active, c->numRepeats);
 }
 
-char nfaExecCastle0_Q(const struct NFA *n, struct mq *q, s64a end) {
+char nfaExecCastle_Q(const struct NFA *n, struct mq *q, s64a end) {
     DEBUG_PRINTF("entry\n");
-    return nfaExecCastle0_Q_i(n, q, end, CALLBACK_OUTPUT);
+    return nfaExecCastle_Q_i(n, q, end, CALLBACK_OUTPUT);
 }
 
-char nfaExecCastle0_Q2(const struct NFA *n, struct mq *q, s64a end) {
+char nfaExecCastle_Q2(const struct NFA *n, struct mq *q, s64a end) {
     DEBUG_PRINTF("entry\n");
-    return nfaExecCastle0_Q_i(n, q, end, STOP_AT_MATCH);
+    return nfaExecCastle_Q_i(n, q, end, STOP_AT_MATCH);
 }
 
 static
@@ -896,9 +896,9 @@ s64a castleLastKillLoc(const struct Castle *c, struct mq *q) {
     return sp - 1; /* the repeats are never killed */
 }
 
-char nfaExecCastle0_QR(const struct NFA *n, struct mq *q, ReportID report) {
+char nfaExecCastle_QR(const struct NFA *n, struct mq *q, ReportID report) {
     assert(n && q);
-    assert(n->type == CASTLE_NFA_0);
+    assert(n->type == CASTLE_NFA);
     DEBUG_PRINTF("entry\n");
 
     if (q->cur == q->end) {
@@ -959,9 +959,9 @@ char nfaExecCastle0_QR(const struct NFA *n, struct mq *q, ReportID report) {
     return 1;
 }
 
-char nfaExecCastle0_reportCurrent(const struct NFA *n, struct mq *q) {
+char nfaExecCastle_reportCurrent(const struct NFA *n, struct mq *q) {
     assert(n && q);
-    assert(n->type == CASTLE_NFA_0);
+    assert(n->type == CASTLE_NFA);
     DEBUG_PRINTF("entry\n");
 
     const struct Castle *c = getImplNfa(n);
@@ -969,19 +969,19 @@ char nfaExecCastle0_reportCurrent(const struct NFA *n, struct mq *q) {
     return 0;
 }
 
-char nfaExecCastle0_inAccept(const struct NFA *n, ReportID report,
-                             struct mq *q) {
+char nfaExecCastle_inAccept(const struct NFA *n, ReportID report,
+                            struct mq *q) {
     assert(n && q);
-    assert(n->type == CASTLE_NFA_0);
+    assert(n->type == CASTLE_NFA);
     DEBUG_PRINTF("entry\n");
 
     const struct Castle *c = getImplNfa(n);
     return castleInAccept(c, q, report, q_cur_offset(q));
 }
 
-char nfaExecCastle0_inAnyAccept(const struct NFA *n, struct mq *q) {
+char nfaExecCastle_inAnyAccept(const struct NFA *n, struct mq *q) {
     assert(n && q);
-    assert(n->type == CASTLE_NFA_0);
+    assert(n->type == CASTLE_NFA);
     DEBUG_PRINTF("entry\n");
 
     const struct Castle *c = getImplNfa(n);
@@ -1019,9 +1019,9 @@ char nfaExecCastle0_inAnyAccept(const struct NFA *n, struct mq *q) {
 }
 
 
-char nfaExecCastle0_queueInitState(UNUSED const struct NFA *n, struct mq *q) {
+char nfaExecCastle_queueInitState(UNUSED const struct NFA *n, struct mq *q) {
     assert(n && q);
-    assert(n->type == CASTLE_NFA_0);
+    assert(n->type == CASTLE_NFA);
     DEBUG_PRINTF("entry\n");
 
     const struct Castle *c = getImplNfa(n);
@@ -1038,10 +1038,10 @@ char nfaExecCastle0_queueInitState(UNUSED const struct NFA *n, struct mq *q) {
     return 0;
 }
 
-char nfaExecCastle0_initCompressedState(const struct NFA *n, UNUSED u64a offset,
-                                        void *state, UNUSED u8 key) {
+char nfaExecCastle_initCompressedState(const struct NFA *n, UNUSED u64a offset,
+                                       void *state, UNUSED u8 key) {
     assert(n && state);
-    assert(n->type == CASTLE_NFA_0);
+    assert(n->type == CASTLE_NFA);
     DEBUG_PRINTF("entry\n");
 
     const struct Castle *c = getImplNfa(n);
@@ -1070,10 +1070,10 @@ void subCastleQueueCompressState(const struct Castle *c, const u32 subIdx,
     repeatPack(packed, info, rctrl, offset);
 }
 
-char nfaExecCastle0_queueCompressState(const struct NFA *n, const struct mq *q,
-                                       s64a loc) {
+char nfaExecCastle_queueCompressState(const struct NFA *n, const struct mq *q,
+                                      s64a loc) {
     assert(n && q);
-    assert(n->type == CASTLE_NFA_0);
+    assert(n->type == CASTLE_NFA);
     DEBUG_PRINTF("entry, loc=%lld\n", loc);
 
     const struct Castle *c = getImplNfa(n);
@@ -1118,11 +1118,10 @@ void subCastleExpandState(const struct Castle *c, const u32 subIdx,
                                  packed + info->packedCtrlSize, offset));
 }
 
-char nfaExecCastle0_expandState(const struct NFA *n, void *dest,
-                                const void *src, u64a offset,
-                                UNUSED u8 key) {
+char nfaExecCastle_expandState(const struct NFA *n, void *dest, const void *src,
+                               u64a offset, UNUSED u8 key) {
     assert(n && dest && src);
-    assert(n->type == CASTLE_NFA_0);
+    assert(n->type == CASTLE_NFA);
     DEBUG_PRINTF("entry, src=%p, dest=%p, offset=%llu\n", src, dest, offset);
 
     const struct Castle *c = getImplNfa(n);

diff --git a/src/nfa/castle.h b/src/nfa/castle.h
index 84d79097e72127e206ff540547e8c38380058808..cc7496ca71213e154e8e7584e7bdd0795d446a9a 100644 (file)
--- a/src/nfa/castle.h
+++ b/src/nfa/castle.h
@@ -38,24 +38,24 @@ extern "C" {
 struct mq;
 struct NFA;
 
-char nfaExecCastle0_Q(const struct NFA *n, struct mq *q, s64a end);
-char nfaExecCastle0_Q2(const struct NFA *n, struct mq *q, s64a end);
-char nfaExecCastle0_QR(const struct NFA *n, struct mq *q, ReportID report);
-char nfaExecCastle0_reportCurrent(const struct NFA *n, struct mq *q);
-char nfaExecCastle0_inAccept(const struct NFA *n, ReportID report,
-                             struct mq *q);
-char nfaExecCastle0_inAnyAccept(const struct NFA *n, struct mq *q);
-char nfaExecCastle0_queueInitState(const struct NFA *n, struct mq *q);
-char nfaExecCastle0_initCompressedState(const struct NFA *n, u64a offset,
-                                        void *state, u8 key);
-char nfaExecCastle0_queueCompressState(const struct NFA *nfa,
-                                       const struct mq *q, s64a loc);
-char nfaExecCastle0_expandState(const struct NFA *nfa, void *dest,
-                                const void *src, u64a offset, u8 key);
+char nfaExecCastle_Q(const struct NFA *n, struct mq *q, s64a end);
+char nfaExecCastle_Q2(const struct NFA *n, struct mq *q, s64a end);
+char nfaExecCastle_QR(const struct NFA *n, struct mq *q, ReportID report);
+char nfaExecCastle_reportCurrent(const struct NFA *n, struct mq *q);
+char nfaExecCastle_inAccept(const struct NFA *n, ReportID report,
+                            struct mq *q);
+char nfaExecCastle_inAnyAccept(const struct NFA *n, struct mq *q);
+char nfaExecCastle_queueInitState(const struct NFA *n, struct mq *q);
+char nfaExecCastle_initCompressedState(const struct NFA *n, u64a offset,
+                                       void *state, u8 key);
+char nfaExecCastle_queueCompressState(const struct NFA *nfa, const struct mq *q,
+                                      s64a loc);
+char nfaExecCastle_expandState(const struct NFA *nfa, void *dest,
+                               const void *src, u64a offset, u8 key);
 
-#define nfaExecCastle0_testEOD NFA_API_NO_IMPL
-#define nfaExecCastle0_B_Reverse NFA_API_NO_IMPL
-#define nfaExecCastle0_zombie_status NFA_API_ZOMBIE_NO_IMPL
+#define nfaExecCastle_testEOD NFA_API_NO_IMPL
+#define nfaExecCastle_B_Reverse NFA_API_NO_IMPL
+#define nfaExecCastle_zombie_status NFA_API_ZOMBIE_NO_IMPL
 
 #ifdef __cplusplus
 }

diff --git a/src/nfa/castle_dump.cpp b/src/nfa/castle_dump.cpp
index fd1521a5b86dd2959f3eb55e0778a124f3227d8b..6d51b2ce9f877d4f6f01705eeee690b2c0a74065 100644 (file)
--- a/src/nfa/castle_dump.cpp
+++ b/src/nfa/castle_dump.cpp
@@ -48,8 +48,8 @@
 
 namespace ue2 {
 
-void nfaExecCastle0_dumpDot(const struct NFA *, FILE *,
-                            UNUSED const std::string &base) {
+void nfaExecCastle_dumpDot(const struct NFA *, FILE *,
+                           UNUSED const std::string &base) {
     // No GraphViz output for Castles.
 }
 
@@ -68,7 +68,7 @@ void dumpTextSubCastle(const SubCastle &sub, FILE *f) {
     fprintf(f, "\n");
 }
 
-void nfaExecCastle0_dumpText(const struct NFA *nfa, FILE *f) {
+void nfaExecCastle_dumpText(const struct NFA *nfa, FILE *f) {
     const Castle *c = (const Castle *)getImplNfa(nfa);
 
     fprintf(f, "Castle multi-tenant repeat engine\n");

diff --git a/src/nfa/castle_dump.h b/src/nfa/castle_dump.h
index 94dadec08c81d25cca9696c4a456ce89f73a689c..d5ec7d3dd3e499a751ee8362d641d3a5785e81a4 100644 (file)
--- a/src/nfa/castle_dump.h
+++ b/src/nfa/castle_dump.h
@@ -38,9 +38,8 @@ struct NFA;
 
 namespace ue2 {
 
-void nfaExecCastle0_dumpDot(const NFA *nfa, FILE *file,
-                            const std::string &base);
-void nfaExecCastle0_dumpText(const NFA *nfa, FILE *file);
+void nfaExecCastle_dumpDot(const NFA *nfa, FILE *file, const std::string &base);
+void nfaExecCastle_dumpText(const NFA *nfa, FILE *file);
 
 } // namespace ue2
 

diff --git a/src/nfa/castlecompile.cpp b/src/nfa/castlecompile.cpp
index a956c92a5e154f65ce458eae993a1e5f1ed5368e..1f76735303c93dc78accb7c607157d4df7ff4a4d 100644 (file)
--- a/src/nfa/castlecompile.cpp
+++ b/src/nfa/castlecompile.cpp
@@ -577,7 +577,7 @@ buildCastle(const CastleProto &proto,
     total_size += byte_length(stale_iter); // stale sparse iter
 
     aligned_unique_ptr<NFA> nfa = aligned_zmalloc_unique<NFA>(total_size);
-    nfa->type = verify_u8(CASTLE_NFA_0);
+    nfa->type = verify_u8(CASTLE_NFA);
     nfa->length = verify_u32(total_size);
     nfa->nPositions = verify_u32(subs.size());
     nfa->streamStateSize = streamStateSize;

diff --git a/src/nfa/lbr.c b/src/nfa/lbr.c
index 07e59239206f1a02eedf0cb67ee3698b20068773..3075be3334bcfa96457eaf87478f510322880836 100644 (file)
--- a/src/nfa/lbr.c
+++ b/src/nfa/lbr.c
@@ -307,7 +307,7 @@ char lbrRevScanDot(UNUSED const struct NFA *nfa, UNUSED const u8 *buf,
                    UNUSED size_t begin, UNUSED size_t end,
                    UNUSED size_t *loc) {
     assert(begin <= end);
-    assert(nfa->type == LBR_NFA_Dot);
+    assert(nfa->type == LBR_NFA_DOT);
     // Nothing can kill a dot!
     return 0;
 }
@@ -316,7 +316,7 @@ static really_inline
 char lbrRevScanVerm(const struct NFA *nfa, const u8 *buf,
                     size_t begin, size_t end, size_t *loc) {
     assert(begin <= end);
-    assert(nfa->type == LBR_NFA_Verm);
+    assert(nfa->type == LBR_NFA_VERM);
     const struct lbr_verm *l = getImplNfa(nfa);
 
     if (begin == end) {
@@ -340,7 +340,7 @@ static really_inline
 char lbrRevScanNVerm(const struct NFA *nfa, const u8 *buf,
                      size_t begin, size_t end, size_t *loc) {
     assert(begin <= end);
-    assert(nfa->type == LBR_NFA_NVerm);
+    assert(nfa->type == LBR_NFA_NVERM);
     const struct lbr_verm *l = getImplNfa(nfa);
 
     if (begin == end) {
@@ -365,7 +365,7 @@ char lbrRevScanShuf(const struct NFA *nfa, const u8 *buf,
                     size_t begin, size_t end,
                     size_t *loc) {
     assert(begin <= end);
-    assert(nfa->type == LBR_NFA_Shuf);
+    assert(nfa->type == LBR_NFA_SHUF);
     const struct lbr_shuf *l = getImplNfa(nfa);
 
     if (begin == end) {
@@ -389,7 +389,7 @@ char lbrRevScanTruf(const struct NFA *nfa, const u8 *buf,
                     size_t begin, size_t end,
                     size_t *loc) {
     assert(begin <= end);
-    assert(nfa->type == LBR_NFA_Truf);
+    assert(nfa->type == LBR_NFA_TRUF);
     const struct lbr_truf *l = getImplNfa(nfa);
 
     if (begin == end) {
@@ -413,7 +413,7 @@ char lbrFwdScanDot(UNUSED const struct NFA *nfa, UNUSED const u8 *buf,
                    UNUSED size_t begin, UNUSED size_t end,
                    UNUSED size_t *loc) {
     assert(begin <= end);
-    assert(nfa->type == LBR_NFA_Dot);
+    assert(nfa->type == LBR_NFA_DOT);
     // Nothing can kill a dot!
     return 0;
 }
@@ -422,7 +422,7 @@ static really_inline
 char lbrFwdScanVerm(const struct NFA *nfa, const u8 *buf,
                     size_t begin, size_t end, size_t *loc) {
     assert(begin <= end);
-    assert(nfa->type == LBR_NFA_Verm);
+    assert(nfa->type == LBR_NFA_VERM);
     const struct lbr_verm *l = getImplNfa(nfa);
 
     if (begin == end) {
@@ -446,7 +446,7 @@ static really_inline
 char lbrFwdScanNVerm(const struct NFA *nfa, const u8 *buf,
                      size_t begin, size_t end, size_t *loc) {
     assert(begin <= end);
-    assert(nfa->type == LBR_NFA_NVerm);
+    assert(nfa->type == LBR_NFA_NVERM);
     const struct lbr_verm *l = getImplNfa(nfa);
 
     if (begin == end) {
@@ -471,7 +471,7 @@ char lbrFwdScanShuf(const struct NFA *nfa, const u8 *buf,
                     size_t begin, size_t end,
                     size_t *loc) {
     assert(begin <= end);
-    assert(nfa->type == LBR_NFA_Shuf);
+    assert(nfa->type == LBR_NFA_SHUF);
     const struct lbr_shuf *l = getImplNfa(nfa);
 
     if (begin == end) {
@@ -495,7 +495,7 @@ char lbrFwdScanTruf(const struct NFA *nfa, const u8 *buf,
                     size_t begin, size_t end,
                     size_t *loc) {
     assert(begin <= end);
-    assert(nfa->type == LBR_NFA_Truf);
+    assert(nfa->type == LBR_NFA_TRUF);
     const struct lbr_truf *l = getImplNfa(nfa);
 
     if (begin == end) {

diff --git a/src/nfa/lbr_dump.cpp b/src/nfa/lbr_dump.cpp
index 3412ddf5e96dcf627a328966fc410ac62c84f254..9619b8d6c490ba74004b089dd531bdb1f5349b98 100644 (file)
--- a/src/nfa/lbr_dump.cpp
+++ b/src/nfa/lbr_dump.cpp
@@ -90,7 +90,7 @@ void lbrDumpCommon(const lbr_common *lc, FILE *f) {
 
 void nfaExecLbrDot_dumpText(const NFA *nfa, FILE *f) {
     assert(nfa);
-    assert(nfa->type == LBR_NFA_Dot);
+    assert(nfa->type == LBR_NFA_DOT);
     const lbr_dot *ld = (const lbr_dot *)getImplNfa(nfa);
     lbrDumpCommon(&ld->common, f);
     fprintf(f, "DOT model\n");
@@ -100,7 +100,7 @@ void nfaExecLbrDot_dumpText(const NFA *nfa, FILE *f) {
 
 void nfaExecLbrVerm_dumpText(const NFA *nfa, FILE *f) {
     assert(nfa);
-    assert(nfa->type == LBR_NFA_Verm);
+    assert(nfa->type == LBR_NFA_VERM);
     const lbr_verm *lv = (const lbr_verm *)getImplNfa(nfa);
     lbrDumpCommon(&lv->common, f);
     fprintf(f, "VERM model, scanning for 0x%02x\n", lv->c);
@@ -110,7 +110,7 @@ void nfaExecLbrVerm_dumpText(const NFA *nfa, FILE *f) {
 
 void nfaExecLbrNVerm_dumpText(const NFA *nfa, FILE *f) {
     assert(nfa);
-    assert(nfa->type == LBR_NFA_NVerm);
+    assert(nfa->type == LBR_NFA_NVERM);
     const lbr_verm *lv = (const lbr_verm *)getImplNfa(nfa);
     lbrDumpCommon(&lv->common, f);
     fprintf(f, "NEGATED VERM model, scanning for 0x%02x\n", lv->c);
@@ -120,7 +120,7 @@ void nfaExecLbrNVerm_dumpText(const NFA *nfa, FILE *f) {
 
 void nfaExecLbrShuf_dumpText(const NFA *nfa, FILE *f) {
     assert(nfa);
-    assert(nfa->type == LBR_NFA_Shuf);
+    assert(nfa->type == LBR_NFA_SHUF);
     const lbr_shuf *ls = (const lbr_shuf *)getImplNfa(nfa);
     lbrDumpCommon(&ls->common, f);
 
@@ -133,7 +133,7 @@ void nfaExecLbrShuf_dumpText(const NFA *nfa, FILE *f) {
 
 void nfaExecLbrTruf_dumpText(const NFA *nfa, FILE *f) {
     assert(nfa);
-    assert(nfa->type == LBR_NFA_Truf);
+    assert(nfa->type == LBR_NFA_TRUF);
     const lbr_truf *lt = (const lbr_truf *)getImplNfa(nfa);
     lbrDumpCommon(&lt->common, f);
 

diff --git a/src/nfa/mpv.c b/src/nfa/mpv.c
index c6c8cb88f593a6911f6c354cc67a5b49b5f0cccc..552754d6080d2331577c13ecd4084c228b0a9220 100644 (file)
--- a/src/nfa/mpv.c
+++ b/src/nfa/mpv.c
@@ -825,21 +825,21 @@ void mpvStoreState(const struct NFA *n, char *state,
     }
 }
 
-char nfaExecMpv0_queueCompressState(const struct NFA *nfa, const struct mq *q,
-                                    UNUSED s64a loc) {
+char nfaExecMpv_queueCompressState(const struct NFA *nfa, const struct mq *q,
+                                   UNUSED s64a loc) {
     void *dest = q->streamState;
     const void *src = q->state;
     mpvStoreState(nfa, dest, src);
     return 0;
 }
 
-char nfaExecMpv0_expandState(const struct NFA *nfa, void *dest, const void *src,
-                             UNUSED u64a offset, UNUSED u8 key) {
+char nfaExecMpv_expandState(const struct NFA *nfa, void *dest, const void *src,
+                            UNUSED u64a offset, UNUSED u8 key) {
     mpvLoadState(dest, nfa, src);
     return 0;
 }
 
-char nfaExecMpv0_reportCurrent(const struct NFA *n, struct mq *q) {
+char nfaExecMpv_reportCurrent(const struct NFA *n, struct mq *q) {
     const struct mpv *m = getImplNfa(n);
     u64a offset = q_cur_offset(q);
     struct mpv_decomp_state *s = (struct mpv_decomp_state *)q->state;
@@ -855,7 +855,7 @@ char nfaExecMpv0_reportCurrent(const struct NFA *n, struct mq *q) {
     return 0;
 }
 
-char nfaExecMpv0_queueInitState(const struct NFA *n, struct mq *q) {
+char nfaExecMpv_queueInitState(const struct NFA *n, struct mq *q) {
     struct mpv_decomp_state *out = (void *)q->state;
     const struct mpv *m = getImplNfa(n);
     assert(sizeof(*out) <= n->scratchStateSize);
@@ -880,8 +880,8 @@ char nfaExecMpv0_queueInitState(const struct NFA *n, struct mq *q) {
     return 0;
 }
 
-char nfaExecMpv0_initCompressedState(const struct NFA *n, u64a offset,
-                                     void *state, UNUSED u8 key) {
+char nfaExecMpv_initCompressedState(const struct NFA *n, u64a offset,
+                                    void *state, UNUSED u8 key) {
     const struct mpv *m = getImplNfa(n);
     memset(state, 0, m->active_offset); /* active_offset marks end of comp
                                          * counters */
@@ -896,7 +896,7 @@ char nfaExecMpv0_initCompressedState(const struct NFA *n, u64a offset,
 }
 
 static really_inline
-char nfaExecMpv0_Q_i(const struct NFA *n, struct mq *q, s64a end) {
+char nfaExecMpv_Q_i(const struct NFA *n, struct mq *q, s64a end) {
     u64a offset = q->offset;
     const u8 *buffer = q->buffer;
     size_t length = q->length;
@@ -1021,18 +1021,18 @@ char nfaExecMpv0_Q_i(const struct NFA *n, struct mq *q, s64a end) {
     return alive;
 }
 
-char nfaExecMpv0_Q(const struct NFA *n, struct mq *q, s64a end) {
+char nfaExecMpv_Q(const struct NFA *n, struct mq *q, s64a end) {
     DEBUG_PRINTF("_Q %lld\n", end);
-    return nfaExecMpv0_Q_i(n, q, end);
+    return nfaExecMpv_Q_i(n, q, end);
 }
 
-s64a nfaExecMpv0_QueueExecRaw(const struct NFA *nfa, struct mq *q, s64a end) {
+s64a nfaExecMpv_QueueExecRaw(const struct NFA *nfa, struct mq *q, s64a end) {
     DEBUG_PRINTF("nfa=%p end=%lld\n", nfa, end);
 #ifdef DEBUG
     debugQueue(q);
 #endif
 
-    assert(nfa->type == MPV_NFA_0);
+    assert(nfa->type == MPV_NFA);
     assert(q && q->context && q->state);
     assert(end >= 0);
     assert(q->cur < q->end);
@@ -1058,7 +1058,7 @@ s64a nfaExecMpv0_QueueExecRaw(const struct NFA *nfa, struct mq *q, s64a end) {
     /* TODO: restore max offset stuff, if/when _interesting_ max offset stuff
      * is filled in */
 
-    char rv = nfaExecMpv0_Q_i(nfa, q, end);
+    char rv = nfaExecMpv_Q_i(nfa, q, end);
 
     assert(!q->report_current);
     DEBUG_PRINTF("returned rv=%d, q_trimmed=%d\n", rv, q_trimmed);

diff --git a/src/nfa/mpv.h b/src/nfa/mpv.h
index a3f9071940c93bef8410bf83d627ba78b7b94f63..3780728d7fdb1aa3a9dee56ed9f135ca641179e1 100644 (file)
--- a/src/nfa/mpv.h
+++ b/src/nfa/mpv.h
@@ -34,27 +34,27 @@
 struct mq;
 struct NFA;
 
-char nfaExecMpv0_Q(const struct NFA *n, struct mq *q, s64a end);
-char nfaExecMpv0_reportCurrent(const struct NFA *n, struct mq *q);
-char nfaExecMpv0_queueInitState(const struct NFA *n, struct mq *q);
-char nfaExecMpv0_initCompressedState(const struct NFA *n, u64a offset,
-                                     void *state, u8 key);
-char nfaExecMpv0_queueCompressState(const struct NFA *nfa, const struct mq *q,
-                                    s64a loc);
-char nfaExecMpv0_expandState(const struct NFA *nfa, void *dest, const void *src,
-                             u64a offset, u8 key);
+char nfaExecMpv_Q(const struct NFA *n, struct mq *q, s64a end);
+char nfaExecMpv_reportCurrent(const struct NFA *n, struct mq *q);
+char nfaExecMpv_queueInitState(const struct NFA *n, struct mq *q);
+char nfaExecMpv_initCompressedState(const struct NFA *n, u64a offset,
+                                    void *state, u8 key);
+char nfaExecMpv_queueCompressState(const struct NFA *nfa, const struct mq *q,
+                                   s64a loc);
+char nfaExecMpv_expandState(const struct NFA *nfa, void *dest, const void *src,
+                            u64a offset, u8 key);
 
-#define nfaExecMpv0_testEOD NFA_API_NO_IMPL
-#define nfaExecMpv0_inAccept NFA_API_NO_IMPL
-#define nfaExecMpv0_inAnyAccept NFA_API_NO_IMPL
-#define nfaExecMpv0_QR NFA_API_NO_IMPL
-#define nfaExecMpv0_Q2 NFA_API_NO_IMPL /* for non-chained suffixes. */
-#define nfaExecMpv0_B_Reverse NFA_API_NO_IMPL
-#define nfaExecMpv0_zombie_status NFA_API_ZOMBIE_NO_IMPL
+#define nfaExecMpv_testEOD NFA_API_NO_IMPL
+#define nfaExecMpv_inAccept NFA_API_NO_IMPL
+#define nfaExecMpv_inAnyAccept NFA_API_NO_IMPL
+#define nfaExecMpv_QR NFA_API_NO_IMPL
+#define nfaExecMpv_Q2 NFA_API_NO_IMPL /* for non-chained suffixes. */
+#define nfaExecMpv_B_Reverse NFA_API_NO_IMPL
+#define nfaExecMpv_zombie_status NFA_API_ZOMBIE_NO_IMPL
 
 /**
  * return 0 if the mpv dies, otherwise returns the location of the next possible
  * match (given the currently known events). */
-s64a nfaExecMpv0_QueueExecRaw(const struct NFA *nfa, struct mq *q, s64a end);
+s64a nfaExecMpv_QueueExecRaw(const struct NFA *nfa, struct mq *q, s64a end);
 
 #endif

diff --git a/src/nfa/mpv_dump.cpp b/src/nfa/mpv_dump.cpp
index da21d7cfe3e3f6de5b695806bd09a6fccabce878..e91d378fc18d4de8307dfaff051cb4fc173a25fe 100644 (file)
--- a/src/nfa/mpv_dump.cpp
+++ b/src/nfa/mpv_dump.cpp
@@ -48,8 +48,8 @@
 
 namespace ue2 {
 
-void nfaExecMpv0_dumpDot(UNUSED const NFA *nfa, UNUSED FILE *file,
-                         UNUSED const std::string &base) {
+void nfaExecMpv_dumpDot(UNUSED const NFA *nfa, UNUSED FILE *file,
+                        UNUSED const std::string &base) {
 }
 
 static really_inline
@@ -128,7 +128,7 @@ void dumpCounter(FILE *f, const mpv_counter_info *c) {
     fprintf(f, "\n");
 }
 
-void nfaExecMpv0_dumpText(const NFA *nfa, FILE *f) {
+void nfaExecMpv_dumpText(const NFA *nfa, FILE *f) {
     const mpv *m = (const mpv *)getImplNfa(nfa);
 
     fprintf(f, "Puff the Magic Engines\n");

diff --git a/src/nfa/mpv_dump.h b/src/nfa/mpv_dump.h
index 23910dcec07d6b0ed4699997b15d21faa079f4b9..b44d2b7484ecc5c0027472e1a93f9139035e5c37 100644 (file)
--- a/src/nfa/mpv_dump.h
+++ b/src/nfa/mpv_dump.h
@@ -38,9 +38,9 @@ struct NFA;
 
 namespace ue2 {
 
-void nfaExecMpv0_dumpDot(const struct NFA *nfa, FILE *file,
-                         const std::string &base);
-void nfaExecMpv0_dumpText(const struct NFA *nfa, FILE *file);
+void nfaExecMpv_dumpDot(const struct NFA *nfa, FILE *file,
+                        const std::string &base);
+void nfaExecMpv_dumpText(const struct NFA *nfa, FILE *file);
 
 } // namespace ue2
 

diff --git a/src/nfa/mpvcompile.cpp b/src/nfa/mpvcompile.cpp
index b024b530222c95f96bbe234fd47eb1cda5250d46..4d70fa2dd89629f5aea286c4a00edc11570b1271 100644 (file)
--- a/src/nfa/mpvcompile.cpp
+++ b/src/nfa/mpvcompile.cpp
@@ -207,7 +207,7 @@ void writeCoreNfa(NFA *nfa, u32 len, u32 min_width, u32 max_counter,
 
     nfa->length = len;
     nfa->nPositions = max_counter - 1;
-    nfa->type = MPV_NFA_0;
+    nfa->type = MPV_NFA;
     nfa->streamStateSize = streamStateSize;
     assert(16 >= sizeof(mpv_decomp_kilo));
     nfa->scratchStateSize = scratchStateSize;

diff --git a/src/nfa/nfa_api_dispatch.c b/src/nfa/nfa_api_dispatch.c
index 2a213ed66c899ef19dff97a611a0a6d613c2236e..d4e9eb78416923c464873b6e67c1255609ad27d2 100644 (file)
--- a/src/nfa/nfa_api_dispatch.c
+++ b/src/nfa/nfa_api_dispatch.c
@@ -45,36 +45,36 @@
 #include "sheng.h"
 #include "tamarama.h"
 
-#define DISPATCH_CASE(dc_ltype, dc_ftype, dc_subtype, dc_func_call) \
-    case dc_ltype##_NFA_##dc_subtype:                               \
-    return nfaExec##dc_ftype##dc_subtype##dc_func_call;             \
+#define DISPATCH_CASE(dc_ltype, dc_ftype, dc_func_call)                        \
+    case dc_ltype:                                                             \
+        return nfaExec##dc_ftype##dc_func_call;                                \
     break
 
 // general framework calls
 
-#define DISPATCH_BY_NFA_TYPE(dbnt_func)                       \
-    switch (nfa->type) {                                      \
-        DISPATCH_CASE(LIMEX, LimEx, 32, dbnt_func);           \
-        DISPATCH_CASE(LIMEX, LimEx, 64, dbnt_func);           \
-        DISPATCH_CASE(LIMEX, LimEx, 128, dbnt_func);          \
-        DISPATCH_CASE(LIMEX, LimEx, 256, dbnt_func);          \
-        DISPATCH_CASE(LIMEX, LimEx, 384, dbnt_func);          \
-        DISPATCH_CASE(LIMEX, LimEx, 512, dbnt_func);          \
-        DISPATCH_CASE(MCCLELLAN, McClellan, 8, dbnt_func);    \
-        DISPATCH_CASE(MCCLELLAN, McClellan, 16, dbnt_func);   \
-        DISPATCH_CASE(GOUGH, Gough, 8, dbnt_func);            \
-        DISPATCH_CASE(GOUGH, Gough, 16, dbnt_func);           \
-        DISPATCH_CASE(MPV, Mpv, 0, dbnt_func);                \
-        DISPATCH_CASE(LBR, Lbr, Dot, dbnt_func);              \
-        DISPATCH_CASE(LBR, Lbr, Verm, dbnt_func);             \
-        DISPATCH_CASE(LBR, Lbr, NVerm, dbnt_func);            \
-        DISPATCH_CASE(LBR, Lbr, Shuf, dbnt_func);             \
-        DISPATCH_CASE(LBR, Lbr, Truf, dbnt_func);             \
-        DISPATCH_CASE(CASTLE, Castle, 0, dbnt_func);          \
-        DISPATCH_CASE(SHENG, Sheng, 0, dbnt_func);            \
-        DISPATCH_CASE(TAMARAMA, Tamarama, 0, dbnt_func);      \
-    default:                                                  \
-        assert(0);                                            \
+#define DISPATCH_BY_NFA_TYPE(dbnt_func)                                        \
+    switch (nfa->type) {                                                       \
+        DISPATCH_CASE(LIMEX_NFA_32, LimEx32, dbnt_func);                       \
+        DISPATCH_CASE(LIMEX_NFA_64, LimEx64, dbnt_func);                       \
+        DISPATCH_CASE(LIMEX_NFA_128, LimEx128, dbnt_func);                     \
+        DISPATCH_CASE(LIMEX_NFA_256, LimEx256, dbnt_func);                     \
+        DISPATCH_CASE(LIMEX_NFA_384, LimEx384, dbnt_func);                     \
+        DISPATCH_CASE(LIMEX_NFA_512, LimEx512, dbnt_func);                     \
+        DISPATCH_CASE(MCCLELLAN_NFA_8, McClellan8, dbnt_func);                 \
+        DISPATCH_CASE(MCCLELLAN_NFA_16, McClellan16, dbnt_func);               \
+        DISPATCH_CASE(GOUGH_NFA_8, Gough8, dbnt_func);                         \
+        DISPATCH_CASE(GOUGH_NFA_16, Gough16, dbnt_func);                       \
+        DISPATCH_CASE(MPV_NFA, Mpv, dbnt_func);                                \
+        DISPATCH_CASE(LBR_NFA_DOT, LbrDot, dbnt_func);                         \
+        DISPATCH_CASE(LBR_NFA_VERM, LbrVerm, dbnt_func);                       \
+        DISPATCH_CASE(LBR_NFA_NVERM, LbrNVerm, dbnt_func);                     \
+        DISPATCH_CASE(LBR_NFA_SHUF, LbrShuf, dbnt_func);                       \
+        DISPATCH_CASE(LBR_NFA_TRUF, LbrTruf, dbnt_func);                       \
+        DISPATCH_CASE(CASTLE_NFA, Castle, dbnt_func);                          \
+        DISPATCH_CASE(SHENG_NFA, Sheng, dbnt_func);                            \
+        DISPATCH_CASE(TAMARAMA_NFA, Tamarama, dbnt_func);                      \
+    default:                                                                   \
+        assert(0);                                                             \
     }
 
 char nfaCheckFinalState(const struct NFA *nfa, const char *state,

diff --git a/src/nfa/nfa_build_util.cpp b/src/nfa/nfa_build_util.cpp
index f3b5329dd2b5996287a200491fe9c08fc23cb37e..3b235bf4f1b7f2b26efa0edb16fff013f0da2855 100644 (file)
--- a/src/nfa/nfa_build_util.cpp
+++ b/src/nfa/nfa_build_util.cpp
@@ -269,7 +269,7 @@ const nfa_dispatch_fn NFATraits<GOUGH_NFA_16>::has_repeats_other_than_firsts = d
 const char *NFATraits<GOUGH_NFA_16>::name = "Goughfish 16";
 #endif
 
-template<> struct NFATraits<MPV_NFA_0> {
+template<> struct NFATraits<MPV_NFA> {
     UNUSED static const char *name;
     static const NFACategory category = NFA_OTHER;
     static const u32 stateAlign = 8;
@@ -278,14 +278,14 @@ template<> struct NFATraits<MPV_NFA_0> {
     static const nfa_dispatch_fn has_repeats;
     static const nfa_dispatch_fn has_repeats_other_than_firsts;
 };
-const nfa_dispatch_fn NFATraits<MPV_NFA_0>::has_accel = dispatch_false;
-const nfa_dispatch_fn NFATraits<MPV_NFA_0>::has_repeats = dispatch_false;
-const nfa_dispatch_fn NFATraits<MPV_NFA_0>::has_repeats_other_than_firsts = dispatch_false;
+const nfa_dispatch_fn NFATraits<MPV_NFA>::has_accel = dispatch_false;
+const nfa_dispatch_fn NFATraits<MPV_NFA>::has_repeats = dispatch_false;
+const nfa_dispatch_fn NFATraits<MPV_NFA>::has_repeats_other_than_firsts = dispatch_false;
 #if defined(DUMP_SUPPORT)
-const char *NFATraits<MPV_NFA_0>::name = "Mega-Puff-Vac";
+const char *NFATraits<MPV_NFA>::name = "Mega-Puff-Vac";
 #endif
 
-template<> struct NFATraits<CASTLE_NFA_0> {
+template<> struct NFATraits<CASTLE_NFA> {
     UNUSED static const char *name;
     static const NFACategory category = NFA_OTHER;
     static const u32 stateAlign = 8;
@@ -294,14 +294,14 @@ template<> struct NFATraits<CASTLE_NFA_0> {
     static const nfa_dispatch_fn has_repeats;
     static const nfa_dispatch_fn has_repeats_other_than_firsts;
 };
-const nfa_dispatch_fn NFATraits<CASTLE_NFA_0>::has_accel = dispatch_false;
-const nfa_dispatch_fn NFATraits<CASTLE_NFA_0>::has_repeats = dispatch_false;
-const nfa_dispatch_fn NFATraits<CASTLE_NFA_0>::has_repeats_other_than_firsts = dispatch_false;
+const nfa_dispatch_fn NFATraits<CASTLE_NFA>::has_accel = dispatch_false;
+const nfa_dispatch_fn NFATraits<CASTLE_NFA>::has_repeats = dispatch_false;
+const nfa_dispatch_fn NFATraits<CASTLE_NFA>::has_repeats_other_than_firsts = dispatch_false;
 #if defined(DUMP_SUPPORT)
-const char *NFATraits<CASTLE_NFA_0>::name = "Castle";
+const char *NFATraits<CASTLE_NFA>::name = "Castle";
 #endif
 
-template<> struct NFATraits<LBR_NFA_Dot> {
+template<> struct NFATraits<LBR_NFA_DOT> {
     UNUSED static const char *name;
     static const NFACategory category = NFA_OTHER;
     static const u32 stateAlign = 8;
@@ -310,14 +310,14 @@ template<> struct NFATraits<LBR_NFA_Dot> {
     static const nfa_dispatch_fn has_repeats;
     static const nfa_dispatch_fn has_repeats_other_than_firsts;
 };
-const nfa_dispatch_fn NFATraits<LBR_NFA_Dot>::has_accel = dispatch_false;
-const nfa_dispatch_fn NFATraits<LBR_NFA_Dot>::has_repeats = dispatch_false;
-const nfa_dispatch_fn NFATraits<LBR_NFA_Dot>::has_repeats_other_than_firsts = dispatch_false;
+const nfa_dispatch_fn NFATraits<LBR_NFA_DOT>::has_accel = dispatch_false;
+const nfa_dispatch_fn NFATraits<LBR_NFA_DOT>::has_repeats = dispatch_false;
+const nfa_dispatch_fn NFATraits<LBR_NFA_DOT>::has_repeats_other_than_firsts = dispatch_false;
 #if defined(DUMP_SUPPORT)
-const char *NFATraits<LBR_NFA_Dot>::name = "Lim Bounded Repeat (D)";
+const char *NFATraits<LBR_NFA_DOT>::name = "Lim Bounded Repeat (D)";
 #endif
 
-template<> struct NFATraits<LBR_NFA_Verm> {
+template<> struct NFATraits<LBR_NFA_VERM> {
     UNUSED static const char *name;
     static const NFACategory category = NFA_OTHER;
     static const u32 stateAlign = 8;
@@ -326,14 +326,14 @@ template<> struct NFATraits<LBR_NFA_Verm> {
     static const nfa_dispatch_fn has_repeats;
     static const nfa_dispatch_fn has_repeats_other_than_firsts;
 };
-const nfa_dispatch_fn NFATraits<LBR_NFA_Verm>::has_accel = dispatch_false;
-const nfa_dispatch_fn NFATraits<LBR_NFA_Verm>::has_repeats = dispatch_false;
-const nfa_dispatch_fn NFATraits<LBR_NFA_Verm>::has_repeats_other_than_firsts = dispatch_false;
+const nfa_dispatch_fn NFATraits<LBR_NFA_VERM>::has_accel = dispatch_false;
+const nfa_dispatch_fn NFATraits<LBR_NFA_VERM>::has_repeats = dispatch_false;
+const nfa_dispatch_fn NFATraits<LBR_NFA_VERM>::has_repeats_other_than_firsts = dispatch_false;
 #if defined(DUMP_SUPPORT)
-const char *NFATraits<LBR_NFA_Verm>::name = "Lim Bounded Repeat (V)";
+const char *NFATraits<LBR_NFA_VERM>::name = "Lim Bounded Repeat (V)";
 #endif
 
-template<> struct NFATraits<LBR_NFA_NVerm> {
+template<> struct NFATraits<LBR_NFA_NVERM> {
     UNUSED static const char *name;
     static const NFACategory category = NFA_OTHER;
     static const u32 stateAlign = 8;
@@ -342,14 +342,14 @@ template<> struct NFATraits<LBR_NFA_NVerm> {
     static const nfa_dispatch_fn has_repeats;
     static const nfa_dispatch_fn has_repeats_other_than_firsts;
 };
-const nfa_dispatch_fn NFATraits<LBR_NFA_NVerm>::has_accel = dispatch_false;
-const nfa_dispatch_fn NFATraits<LBR_NFA_NVerm>::has_repeats = dispatch_false;
-const nfa_dispatch_fn NFATraits<LBR_NFA_NVerm>::has_repeats_other_than_firsts = dispatch_false;
+const nfa_dispatch_fn NFATraits<LBR_NFA_NVERM>::has_accel = dispatch_false;
+const nfa_dispatch_fn NFATraits<LBR_NFA_NVERM>::has_repeats = dispatch_false;
+const nfa_dispatch_fn NFATraits<LBR_NFA_NVERM>::has_repeats_other_than_firsts = dispatch_false;
 #if defined(DUMP_SUPPORT)
-const char *NFATraits<LBR_NFA_NVerm>::name = "Lim Bounded Repeat (NV)";
+const char *NFATraits<LBR_NFA_NVERM>::name = "Lim Bounded Repeat (NV)";
 #endif
 
-template<> struct NFATraits<LBR_NFA_Shuf> {
+template<> struct NFATraits<LBR_NFA_SHUF> {
     UNUSED static const char *name;
     static const NFACategory category = NFA_OTHER;
     static const u32 stateAlign = 8;
@@ -358,14 +358,14 @@ template<> struct NFATraits<LBR_NFA_Shuf> {
     static const nfa_dispatch_fn has_repeats;
     static const nfa_dispatch_fn has_repeats_other_than_firsts;
 };
-const nfa_dispatch_fn NFATraits<LBR_NFA_Shuf>::has_accel = dispatch_false;
-const nfa_dispatch_fn NFATraits<LBR_NFA_Shuf>::has_repeats = dispatch_false;
-const nfa_dispatch_fn NFATraits<LBR_NFA_Shuf>::has_repeats_other_than_firsts = dispatch_false;
+const nfa_dispatch_fn NFATraits<LBR_NFA_SHUF>::has_accel = dispatch_false;
+const nfa_dispatch_fn NFATraits<LBR_NFA_SHUF>::has_repeats = dispatch_false;
+const nfa_dispatch_fn NFATraits<LBR_NFA_SHUF>::has_repeats_other_than_firsts = dispatch_false;
 #if defined(DUMP_SUPPORT)
-const char *NFATraits<LBR_NFA_Shuf>::name = "Lim Bounded Repeat (S)";
+const char *NFATraits<LBR_NFA_SHUF>::name = "Lim Bounded Repeat (S)";
 #endif
 
-template<> struct NFATraits<LBR_NFA_Truf> {
+template<> struct NFATraits<LBR_NFA_TRUF> {
     UNUSED static const char *name;
     static const NFACategory category = NFA_OTHER;
     static const u32 stateAlign = 8;
@@ -374,14 +374,14 @@ template<> struct NFATraits<LBR_NFA_Truf> {
     static const nfa_dispatch_fn has_repeats;
     static const nfa_dispatch_fn has_repeats_other_than_firsts;
 };
-const nfa_dispatch_fn NFATraits<LBR_NFA_Truf>::has_accel = dispatch_false;
-const nfa_dispatch_fn NFATraits<LBR_NFA_Truf>::has_repeats = dispatch_false;
-const nfa_dispatch_fn NFATraits<LBR_NFA_Truf>::has_repeats_other_than_firsts = dispatch_false;
+const nfa_dispatch_fn NFATraits<LBR_NFA_TRUF>::has_accel = dispatch_false;
+const nfa_dispatch_fn NFATraits<LBR_NFA_TRUF>::has_repeats = dispatch_false;
+const nfa_dispatch_fn NFATraits<LBR_NFA_TRUF>::has_repeats_other_than_firsts = dispatch_false;
 #if defined(DUMP_SUPPORT)
-const char *NFATraits<LBR_NFA_Truf>::name = "Lim Bounded Repeat (M)";
+const char *NFATraits<LBR_NFA_TRUF>::name = "Lim Bounded Repeat (M)";
 #endif
 
-template<> struct NFATraits<SHENG_NFA_0> {
+template<> struct NFATraits<SHENG_NFA> {
     UNUSED static const char *name;
     static const NFACategory category = NFA_OTHER;
     static const u32 stateAlign = 1;
@@ -390,14 +390,14 @@ template<> struct NFATraits<SHENG_NFA_0> {
     static const nfa_dispatch_fn has_repeats;
     static const nfa_dispatch_fn has_repeats_other_than_firsts;
 };
-const nfa_dispatch_fn NFATraits<SHENG_NFA_0>::has_accel = has_accel_sheng;
-const nfa_dispatch_fn NFATraits<SHENG_NFA_0>::has_repeats = dispatch_false;
-const nfa_dispatch_fn NFATraits<SHENG_NFA_0>::has_repeats_other_than_firsts = dispatch_false;
+const nfa_dispatch_fn NFATraits<SHENG_NFA>::has_accel = has_accel_sheng;
+const nfa_dispatch_fn NFATraits<SHENG_NFA>::has_repeats = dispatch_false;
+const nfa_dispatch_fn NFATraits<SHENG_NFA>::has_repeats_other_than_firsts = dispatch_false;
 #if defined(DUMP_SUPPORT)
-const char *NFATraits<SHENG_NFA_0>::name = "Sheng";
+const char *NFATraits<SHENG_NFA>::name = "Sheng";
 #endif
 
-template<> struct NFATraits<TAMARAMA_NFA_0> {
+template<> struct NFATraits<TAMARAMA_NFA> {
     UNUSED static const char *name;
     static const NFACategory category = NFA_OTHER;
     static const u32 stateAlign = 32;
@@ -406,11 +406,11 @@ template<> struct NFATraits<TAMARAMA_NFA_0> {
     static const nfa_dispatch_fn has_repeats;
     static const nfa_dispatch_fn has_repeats_other_than_firsts;
 };
-const nfa_dispatch_fn NFATraits<TAMARAMA_NFA_0>::has_accel = dispatch_false;
-const nfa_dispatch_fn NFATraits<TAMARAMA_NFA_0>::has_repeats = dispatch_false;
-const nfa_dispatch_fn NFATraits<TAMARAMA_NFA_0>::has_repeats_other_than_firsts = dispatch_false;
+const nfa_dispatch_fn NFATraits<TAMARAMA_NFA>::has_accel = dispatch_false;
+const nfa_dispatch_fn NFATraits<TAMARAMA_NFA>::has_repeats = dispatch_false;
+const nfa_dispatch_fn NFATraits<TAMARAMA_NFA>::has_repeats_other_than_firsts = dispatch_false;
 #if defined(DUMP_SUPPORT)
-const char *NFATraits<TAMARAMA_NFA_0>::name = "Tamarama";
+const char *NFATraits<TAMARAMA_NFA>::name = "Tamarama";
 #endif
 
 } // namespace

diff --git a/src/nfa/nfa_dump_dispatch.cpp b/src/nfa/nfa_dump_dispatch.cpp
index f7a5e05d14aac3cd92f6db63081465249ba85067..841902326cf677a15dc570790f5b4df83490af18 100644 (file)
--- a/src/nfa/nfa_dump_dispatch.cpp
+++ b/src/nfa/nfa_dump_dispatch.cpp
@@ -49,37 +49,37 @@
 
 namespace ue2 {
 
-#define DISPATCH_CASE(dc_ltype, dc_ftype, dc_subtype, dc_func_call) \
-    case dc_ltype##_NFA_##dc_subtype:                               \
-    nfaExec##dc_ftype##dc_subtype##dc_func_call;                    \
+#define DISPATCH_CASE(dc_ltype, dc_ftype, dc_func_call)                        \
+    case dc_ltype:                                                             \
+        nfaExec##dc_ftype##dc_func_call;                                       \
     break
 
 // general framework calls
 
-#define DISPATCH_BY_NFA_TYPE(dbnt_func)                       \
-    DEBUG_PRINTF("dispatch for NFA type %u\n", nfa->type);    \
-    switch (nfa->type) {                                      \
-        DISPATCH_CASE(LIMEX, LimEx, 32, dbnt_func);           \
-        DISPATCH_CASE(LIMEX, LimEx, 64, dbnt_func);           \
-        DISPATCH_CASE(LIMEX, LimEx, 128, dbnt_func);          \
-        DISPATCH_CASE(LIMEX, LimEx, 256, dbnt_func);          \
-        DISPATCH_CASE(LIMEX, LimEx, 384, dbnt_func);          \
-        DISPATCH_CASE(LIMEX, LimEx, 512, dbnt_func);          \
-        DISPATCH_CASE(MCCLELLAN, McClellan, 8, dbnt_func);    \
-        DISPATCH_CASE(MCCLELLAN, McClellan, 16, dbnt_func);   \
-        DISPATCH_CASE(GOUGH, Gough, 8, dbnt_func);            \
-        DISPATCH_CASE(GOUGH, Gough, 16, dbnt_func);           \
-        DISPATCH_CASE(MPV, Mpv, 0, dbnt_func);                \
-        DISPATCH_CASE(LBR, Lbr, Dot, dbnt_func);              \
-        DISPATCH_CASE(LBR, Lbr, Verm, dbnt_func);             \
-        DISPATCH_CASE(LBR, Lbr, NVerm, dbnt_func);            \
-        DISPATCH_CASE(LBR, Lbr, Shuf, dbnt_func);             \
-        DISPATCH_CASE(LBR, Lbr, Truf, dbnt_func);             \
-        DISPATCH_CASE(CASTLE, Castle, 0, dbnt_func);          \
-        DISPATCH_CASE(SHENG, Sheng, 0, dbnt_func);            \
-        DISPATCH_CASE(TAMARAMA, Tamarama, 0, dbnt_func);      \
-    default:                                                  \
-        assert(0);                                            \
+#define DISPATCH_BY_NFA_TYPE(dbnt_func)                                        \
+    DEBUG_PRINTF("dispatch for NFA type %u\n", nfa->type);                     \
+    switch (nfa->type) {                                                       \
+        DISPATCH_CASE(LIMEX_NFA_32, LimEx32, dbnt_func);                       \
+        DISPATCH_CASE(LIMEX_NFA_64, LimEx64, dbnt_func);                       \
+        DISPATCH_CASE(LIMEX_NFA_128, LimEx128, dbnt_func);                     \
+        DISPATCH_CASE(LIMEX_NFA_256, LimEx256, dbnt_func);                     \
+        DISPATCH_CASE(LIMEX_NFA_384, LimEx384, dbnt_func);                     \
+        DISPATCH_CASE(LIMEX_NFA_512, LimEx512, dbnt_func);                     \
+        DISPATCH_CASE(MCCLELLAN_NFA_8, McClellan8, dbnt_func);                 \
+        DISPATCH_CASE(MCCLELLAN_NFA_16, McClellan16, dbnt_func);               \
+        DISPATCH_CASE(GOUGH_NFA_8, Gough8, dbnt_func);                         \
+        DISPATCH_CASE(GOUGH_NFA_16, Gough16, dbnt_func);                       \
+        DISPATCH_CASE(MPV_NFA, Mpv, dbnt_func);                                \
+        DISPATCH_CASE(LBR_NFA_DOT, LbrDot, dbnt_func);                         \
+        DISPATCH_CASE(LBR_NFA_VERM, LbrVerm, dbnt_func);                       \
+        DISPATCH_CASE(LBR_NFA_NVERM, LbrNVerm, dbnt_func);                     \
+        DISPATCH_CASE(LBR_NFA_SHUF, LbrShuf, dbnt_func);                       \
+        DISPATCH_CASE(LBR_NFA_TRUF, LbrTruf, dbnt_func);                       \
+        DISPATCH_CASE(CASTLE_NFA, Castle, dbnt_func);                          \
+        DISPATCH_CASE(SHENG_NFA, Sheng, dbnt_func);                            \
+        DISPATCH_CASE(TAMARAMA_NFA, Tamarama, dbnt_func);                      \
+    default:                                                                   \
+        assert(0);                                                             \
     }
 
 void nfaDumpDot(const struct NFA *nfa, FILE *dotFile,

diff --git a/src/nfa/nfa_internal.h b/src/nfa/nfa_internal.h
index 58c3da6c0a2ea11f6de7cbafc17de86a249f1a33..1ce566ffb2d1012780eed6e4d2736cc4cbd37030 100644 (file)
--- a/src/nfa/nfa_internal.h
+++ b/src/nfa/nfa_internal.h
@@ -61,15 +61,15 @@ enum NFAEngineType {
     MCCLELLAN_NFA_16,   /**< magic pseudo nfa */
     GOUGH_NFA_8,        /**< magic pseudo nfa */
     GOUGH_NFA_16,       /**< magic pseudo nfa */
-    MPV_NFA_0,          /**< magic pseudo nfa */
-    LBR_NFA_Dot,        /**< magic pseudo nfa */
-    LBR_NFA_Verm,       /**< magic pseudo nfa */
-    LBR_NFA_NVerm,      /**< magic pseudo nfa */
-    LBR_NFA_Shuf,       /**< magic pseudo nfa */
-    LBR_NFA_Truf,       /**< magic pseudo nfa */
-    CASTLE_NFA_0,       /**< magic pseudo nfa */
-    SHENG_NFA_0,        /**< magic pseudo nfa */
-    TAMARAMA_NFA_0,     /**< magic nfa container */
+    MPV_NFA,            /**< magic pseudo nfa */
+    LBR_NFA_DOT,        /**< magic pseudo nfa */
+    LBR_NFA_VERM,       /**< magic pseudo nfa */
+    LBR_NFA_NVERM,      /**< magic pseudo nfa */
+    LBR_NFA_SHUF,       /**< magic pseudo nfa */
+    LBR_NFA_TRUF,       /**< magic pseudo nfa */
+    CASTLE_NFA,         /**< magic pseudo nfa */
+    SHENG_NFA,          /**< magic pseudo nfa */
+    TAMARAMA_NFA,       /**< magic nfa container */
     /** \brief bogus NFA - not used */
     INVALID_NFA
 };
@@ -150,7 +150,7 @@ static really_inline int isGoughType(u8 t) {
 
 /** \brief True if the given type (from NFA::type) is a Sheng DFA. */
 static really_inline int isShengType(u8 t) {
-    return t == SHENG_NFA_0;
+    return t == SHENG_NFA;
 }
 
 /**
@@ -180,14 +180,14 @@ static really_inline int isNfaType(u8 t) {
 /** \brief True if the given type (from NFA::type) is an LBR. */
 static really_inline
 int isLbrType(u8 t) {
-    return t == LBR_NFA_Dot || t == LBR_NFA_Verm || t == LBR_NFA_NVerm ||
-           t == LBR_NFA_Shuf || t == LBR_NFA_Truf;
+    return t == LBR_NFA_DOT || t == LBR_NFA_VERM || t == LBR_NFA_NVERM ||
+           t == LBR_NFA_SHUF || t == LBR_NFA_TRUF;
 }
 
 /** \brief True if the given type (from NFA::type) is a container engine. */
 static really_inline
 int isContainerType(u8 t) {
-    return t == TAMARAMA_NFA_0;
+    return t == TAMARAMA_NFA;
 }
 
 static really_inline
@@ -202,14 +202,14 @@ int isMultiTopType(u8 t) {
 /* Use for functions that return an integer. */
 #define NFA_API_NO_IMPL(...)                                                   \
     ({                                                                         \
-        assert(!"not implemented for this engine!");                            \
+        assert(!"not implemented for this engine!");                           \
         0; /* return value, for places that need it */                         \
     })
 
 /* Use for _zombie_status functions. */
 #define NFA_API_ZOMBIE_NO_IMPL(...)                                            \
     ({                                                                         \
-        assert(!"not implemented for this engine!");                            \
+        assert(!"not implemented for this engine!");                           \
         NFA_ZOMBIE_NO;                                                         \
     })
 

diff --git a/src/nfa/sheng.c b/src/nfa/sheng.c
index a5f9680500ac9dc64fc2c4068382ea538bfce078..837aa7dfaa7605dc9e1579781659bfde6209e8bc 100644 (file)
--- a/src/nfa/sheng.c
+++ b/src/nfa/sheng.c
@@ -504,10 +504,10 @@ char runSheng(const struct sheng *sh, struct mq *q, s64a b_end,
     }
 }
 
-char nfaExecSheng0_B(const struct NFA *n, u64a offset, const u8 *buffer,
-                     size_t length, NfaCallback cb, void *context) {
+char nfaExecSheng_B(const struct NFA *n, u64a offset, const u8 *buffer,
+                    size_t length, NfaCallback cb, void *context) {
     DEBUG_PRINTF("smallwrite Sheng\n");
-    assert(n->type == SHENG_NFA_0);
+    assert(n->type == SHENG_NFA);
     const struct sheng *sh = getImplNfa(n);
     u8 state = sh->anchored;
     u8 can_die = sh->flags & SHENG_FLAG_CAN_DIE;
@@ -543,32 +543,31 @@ char nfaExecSheng0_B(const struct NFA *n, u64a offset, const u8 *buffer,
     return state & SHENG_STATE_DEAD ? MO_DEAD : MO_ALIVE;
 }
 
-char nfaExecSheng0_Q(const struct NFA *n, struct mq *q, s64a end) {
+char nfaExecSheng_Q(const struct NFA *n, struct mq *q, s64a end) {
     const struct sheng *sh = get_sheng(n);
     char rv = runSheng(sh, q, end, CALLBACK_OUTPUT);
     return rv;
 }
 
-char nfaExecSheng0_Q2(const struct NFA *n, struct mq *q, s64a end) {
+char nfaExecSheng_Q2(const struct NFA *n, struct mq *q, s64a end) {
     const struct sheng *sh = get_sheng(n);
     char rv = runSheng(sh, q, end, STOP_AT_MATCH);
     return rv;
 }
 
-char nfaExecSheng0_QR(const struct NFA *n, struct mq *q, ReportID report) {
+char nfaExecSheng_QR(const struct NFA *n, struct mq *q, ReportID report) {
     assert(q_cur_type(q) == MQE_START);
 
     const struct sheng *sh = get_sheng(n);
     char rv = runSheng(sh, q, 0 /* end */, NO_MATCHES);
 
-    if (rv && nfaExecSheng0_inAccept(n, report, q)) {
+    if (rv && nfaExecSheng_inAccept(n, report, q)) {
         return MO_MATCHES_PENDING;
     }
     return rv;
 }
 
-char nfaExecSheng0_inAccept(const struct NFA *n, ReportID report,
-                            struct mq *q) {
+char nfaExecSheng_inAccept(const struct NFA *n, ReportID report, struct mq *q) {
     assert(n && q);
 
     const struct sheng *sh = get_sheng(n);
@@ -584,7 +583,7 @@ char nfaExecSheng0_inAccept(const struct NFA *n, ReportID report,
     return shengHasAccept(sh, aux, report);
 }
 
-char nfaExecSheng0_inAnyAccept(const struct NFA *n, struct mq *q) {
+char nfaExecSheng_inAnyAccept(const struct NFA *n, struct mq *q) {
     assert(n && q);
 
     const struct sheng *sh = get_sheng(n);
@@ -595,9 +594,9 @@ char nfaExecSheng0_inAnyAccept(const struct NFA *n, struct mq *q) {
     return !!aux->accept;
 }
 
-char nfaExecSheng0_testEOD(const struct NFA *nfa, const char *state,
-                           UNUSED const char *streamState, u64a offset,
-                           NfaCallback cb, void *ctxt) {
+char nfaExecSheng_testEOD(const struct NFA *nfa, const char *state,
+                          UNUSED const char *streamState, u64a offset,
+                          NfaCallback cb, void *ctxt) {
     assert(nfa);
 
     const struct sheng *sh = get_sheng(nfa);
@@ -613,7 +612,7 @@ char nfaExecSheng0_testEOD(const struct NFA *nfa, const char *state,
     return fireReports(sh, cb, ctxt, s, offset, NULL, NULL, 1);
 }
 
-char nfaExecSheng0_reportCurrent(const struct NFA *n, struct mq *q) {
+char nfaExecSheng_reportCurrent(const struct NFA *n, struct mq *q) {
     const struct sheng *sh = (const struct sheng *)getImplNfa(n);
     NfaCallback cb = q->cb;
     void *ctxt = q->context;
@@ -636,15 +635,15 @@ char nfaExecSheng0_reportCurrent(const struct NFA *n, struct mq *q) {
     return 0;
 }
 
-char nfaExecSheng0_initCompressedState(const struct NFA *nfa, u64a offset,
-                                       void *state, UNUSED u8 key) {
+char nfaExecSheng_initCompressedState(const struct NFA *nfa, u64a offset,
+                                      void *state, UNUSED u8 key) {
     const struct sheng *sh = get_sheng(nfa);
     u8 *s = (u8 *)state;
     *s = offset ? sh->floating: sh->anchored;
     return !(*s & SHENG_STATE_DEAD);
 }
 
-char nfaExecSheng0_queueInitState(const struct NFA *nfa, struct mq *q) {
+char nfaExecSheng_queueInitState(const struct NFA *nfa, struct mq *q) {
     assert(nfa->scratchStateSize == 1);
 
     /* starting in floating state */
@@ -654,8 +653,8 @@ char nfaExecSheng0_queueInitState(const struct NFA *nfa, struct mq *q) {
     return 0;
 }
 
-char nfaExecSheng0_queueCompressState(UNUSED const struct NFA *nfa,
-                                      const struct mq *q, UNUSED s64a loc) {
+char nfaExecSheng_queueCompressState(UNUSED const struct NFA *nfa,
+                                     const struct mq *q, UNUSED s64a loc) {
     void *dest = q->streamState;
     const void *src = q->state;
     assert(nfa->scratchStateSize == 1);
@@ -664,9 +663,9 @@ char nfaExecSheng0_queueCompressState(UNUSED const struct NFA *nfa,
     return 0;
 }
 
-char nfaExecSheng0_expandState(UNUSED const struct NFA *nfa, void *dest,
-                               const void *src, UNUSED u64a offset,
-                               UNUSED u8 key) {
+char nfaExecSheng_expandState(UNUSED const struct NFA *nfa, void *dest,
+                              const void *src, UNUSED u64a offset,
+                              UNUSED u8 key) {
     assert(nfa->scratchStateSize == 1);
     assert(nfa->streamStateSize == 1);
     *(u8 *)dest = *(const u8 *)src;

diff --git a/src/nfa/sheng.h b/src/nfa/sheng.h
index 46ead1800d8c88d8b0369d71d1cf5e57633751c3..84a2b6b515d36280b6a4e5d5269b3d6e483b237e 100644 (file)
--- a/src/nfa/sheng.h
+++ b/src/nfa/sheng.h
@@ -35,27 +35,27 @@
 struct mq;
 struct NFA;
 
-#define nfaExecSheng0_B_Reverse NFA_API_NO_IMPL
-#define nfaExecSheng0_zombie_status NFA_API_ZOMBIE_NO_IMPL
+#define nfaExecSheng_B_Reverse NFA_API_NO_IMPL
+#define nfaExecSheng_zombie_status NFA_API_ZOMBIE_NO_IMPL
 
-char nfaExecSheng0_Q(const struct NFA *n, struct mq *q, s64a end);
-char nfaExecSheng0_Q2(const struct NFA *n, struct mq *q, s64a end);
-char nfaExecSheng0_QR(const struct NFA *n, struct mq *q, ReportID report);
-char nfaExecSheng0_inAccept(const struct NFA *n, ReportID report, struct mq *q);
-char nfaExecSheng0_inAnyAccept(const struct NFA *n, struct mq *q);
-char nfaExecSheng0_queueInitState(const struct NFA *nfa, struct mq *q);
-char nfaExecSheng0_queueCompressState(const struct NFA *nfa, const struct mq *q,
-                                      s64a loc);
-char nfaExecSheng0_expandState(const struct NFA *nfa, void *dest,
-                               const void *src, u64a offset, u8 key);
-char nfaExecSheng0_initCompressedState(const struct NFA *nfa, u64a offset,
-                                       void *state, u8 key);
-char nfaExecSheng0_testEOD(const struct NFA *nfa, const char *state,
-                           const char *streamState, u64a offset,
-                           NfaCallback callback, void *context);
-char nfaExecSheng0_reportCurrent(const struct NFA *n, struct mq *q);
+char nfaExecSheng_Q(const struct NFA *n, struct mq *q, s64a end);
+char nfaExecSheng_Q2(const struct NFA *n, struct mq *q, s64a end);
+char nfaExecSheng_QR(const struct NFA *n, struct mq *q, ReportID report);
+char nfaExecSheng_inAccept(const struct NFA *n, ReportID report, struct mq *q);
+char nfaExecSheng_inAnyAccept(const struct NFA *n, struct mq *q);
+char nfaExecSheng_queueInitState(const struct NFA *nfa, struct mq *q);
+char nfaExecSheng_queueCompressState(const struct NFA *nfa, const struct mq *q,
+                                     s64a loc);
+char nfaExecSheng_expandState(const struct NFA *nfa, void *dest,
+                              const void *src, u64a offset, u8 key);
+char nfaExecSheng_initCompressedState(const struct NFA *nfa, u64a offset,
+                                      void *state, u8 key);
+char nfaExecSheng_testEOD(const struct NFA *nfa, const char *state,
+                          const char *streamState, u64a offset,
+                          NfaCallback callback, void *context);
+char nfaExecSheng_reportCurrent(const struct NFA *n, struct mq *q);
 
-char nfaExecSheng0_B(const struct NFA *n, u64a offset, const u8 *buffer,
+char nfaExecSheng_B(const struct NFA *n, u64a offset, const u8 *buffer,
                     size_t length, NfaCallback cb, void *context);
 
 #endif /* SHENG_H_ */

diff --git a/src/nfa/shengcompile.cpp b/src/nfa/shengcompile.cpp
index 911f6d700702123081f0fd7a47cfaaf5bc97f83a..3902dbaf4f7f6990534795f73d10cb3f7c927545 100644 (file)
--- a/src/nfa/shengcompile.cpp
+++ b/src/nfa/shengcompile.cpp
@@ -358,7 +358,7 @@ void populateBasicInfo(struct NFA *n, dfa_info &info,
     n->scratchStateSize = 1;
     n->streamStateSize = 1;
     n->nPositions = info.size();
-    n->type = SHENG_NFA_0;
+    n->type = SHENG_NFA;
     n->flags |= info.raw.hasEodReports() ? NFA_ACCEPTS_EOD : 0;
 
     sheng *s = (sheng *)getMutableImplNfa(n);

diff --git a/src/nfa/shengdump.cpp b/src/nfa/shengdump.cpp
index 037dfb05d38157e85c0ed0f91eb9e68fd7a19666..a7e7fc2b1c3570d570b9063065865dd652622350 100644 (file)
--- a/src/nfa/shengdump.cpp
+++ b/src/nfa/shengdump.cpp
@@ -115,8 +115,8 @@ void dumpMasks(FILE *f, const sheng *s) {
     }
 }
 
-void nfaExecSheng0_dumpText(const NFA *nfa, FILE *f) {
-    assert(nfa->type == SHENG_NFA_0);
+void nfaExecSheng_dumpText(const NFA *nfa, FILE *f) {
+    assert(nfa->type == SHENG_NFA);
     const sheng *s = (const sheng *)getImplNfa(nfa);
 
     fprintf(f, "sheng DFA\n");
@@ -243,8 +243,8 @@ void shengGetTransitions(const NFA *n, u16 state, u16 *t) {
     t[TOP] = aux->top & SHENG_STATE_MASK;
 }
 
-void nfaExecSheng0_dumpDot(const NFA *nfa, FILE *f, const string &) {
-    assert(nfa->type == SHENG_NFA_0);
+void nfaExecSheng_dumpDot(const NFA *nfa, FILE *f, const string &) {
+    assert(nfa->type == SHENG_NFA);
     const sheng *s = (const sheng *)getImplNfa(nfa);
 
     dumpDotPreambleDfa(f);

diff --git a/src/nfa/shengdump.h b/src/nfa/shengdump.h
index 5334894f6f8653eb4d3513c001b34673a654ef80..008d2aba54dbb265bdbafab7487cfa764f64f654 100644 (file)
--- a/src/nfa/shengdump.h
+++ b/src/nfa/shengdump.h
@@ -38,9 +38,9 @@ struct NFA;
 
 namespace ue2 {
 
-void nfaExecSheng0_dumpDot(const struct NFA *nfa, FILE *file,
-                           const std::string &base);
-void nfaExecSheng0_dumpText(const struct NFA *nfa, FILE *file);
+void nfaExecSheng_dumpDot(const struct NFA *nfa, FILE *file,
+                          const std::string &base);
+void nfaExecSheng_dumpText(const struct NFA *nfa, FILE *file);
 
 } // namespace ue2
 

diff --git a/src/nfa/tamarama.c b/src/nfa/tamarama.c
index b5f90e85e0c1e572b2b888ecd22533ced91983d5..43480f06506130395a5ecdacb14b624e2dc2d598 100644 (file)
--- a/src/nfa/tamarama.c
+++ b/src/nfa/tamarama.c
@@ -265,9 +265,9 @@ void copyBack(const struct  Tamarama *t, struct mq *q, struct mq *q1) {
 #endif
 }
 
-char nfaExecTamarama0_testEOD(const struct NFA *n, const char *state,
-                              const char *streamState, u64a offset,
-                              NfaCallback callback, void *context) {
+char nfaExecTamarama_testEOD(const struct NFA *n, const char *state,
+                             const char *streamState, u64a offset,
+                             NfaCallback callback, void *context) {
     const struct Tamarama *t = getImplNfa(n);
     u32 activeIdx = loadActiveIdx(streamState, t->activeIdxSize);
     if (activeIdx == t->numSubEngines) {
@@ -285,8 +285,7 @@ char nfaExecTamarama0_testEOD(const struct NFA *n, const char *state,
     return MO_CONTINUE_MATCHING;
 }
 
-char nfaExecTamarama0_QR(const struct NFA *n, struct mq *q,
-                         ReportID report) {
+char nfaExecTamarama_QR(const struct NFA *n, struct mq *q, ReportID report) {
     DEBUG_PRINTF("exec rose\n");
     struct mq q1;
     q1.cur = q1.end = 0;
@@ -304,7 +303,7 @@ char nfaExecTamarama0_QR(const struct NFA *n, struct mq *q,
     return rv;
 }
 
-char nfaExecTamarama0_reportCurrent(const struct NFA *n, struct mq *q) {
+char nfaExecTamarama_reportCurrent(const struct NFA *n, struct mq *q) {
     const struct Tamarama *t = getImplNfa(n);
     u32 activeIdx = loadActiveIdx(q->streamState, t->activeIdxSize);
     if (activeIdx == t->numSubEngines) {
@@ -317,8 +316,8 @@ char nfaExecTamarama0_reportCurrent(const struct NFA *n, struct mq *q) {
     return nfaReportCurrentMatches(sub, &q1);
 }
 
-char nfaExecTamarama0_inAccept(const struct NFA *n, ReportID report,
-                               struct mq *q) {
+char nfaExecTamarama_inAccept(const struct NFA *n, ReportID report,
+                              struct mq *q) {
     const struct Tamarama *t = getImplNfa(n);
     u32 activeIdx = loadActiveIdx(q->streamState, t->activeIdxSize);
     if (activeIdx == t->numSubEngines) {
@@ -331,7 +330,7 @@ char nfaExecTamarama0_inAccept(const struct NFA *n, ReportID report,
     return nfaInAcceptState(sub, report, &q1);
 }
 
-char nfaExecTamarama0_inAnyAccept(const struct NFA *n, struct mq *q) {
+char nfaExecTamarama_inAnyAccept(const struct NFA *n, struct mq *q) {
     const struct Tamarama *t = getImplNfa(n);
     u32 activeIdx = loadActiveIdx(q->streamState, t->activeIdxSize);
     if (activeIdx == t->numSubEngines) {
@@ -344,7 +343,7 @@ char nfaExecTamarama0_inAnyAccept(const struct NFA *n, struct mq *q) {
     return nfaInAnyAcceptState(sub, &q1);
 }
 
-char nfaExecTamarama0_queueInitState(const struct NFA *n, struct mq *q) {
+char nfaExecTamarama_queueInitState(const struct NFA *n, struct mq *q) {
     DEBUG_PRINTF("init state\n");
     const struct Tamarama *t = getImplNfa(n);
     char *ptr = q->streamState;
@@ -354,8 +353,8 @@ char nfaExecTamarama0_queueInitState(const struct NFA *n, struct mq *q) {
     return 0;
 }
 
-char nfaExecTamarama0_queueCompressState(const struct NFA *n,
-                                         const struct mq *q, s64a loc) {
+char nfaExecTamarama_queueCompressState(const struct NFA *n, const struct mq *q,
+                                        s64a loc) {
     const struct Tamarama *t = getImplNfa(n);
     u32 activeIdx = loadActiveIdx(q->streamState, t->activeIdxSize);
     if (activeIdx == t->numSubEngines) {
@@ -369,8 +368,8 @@ char nfaExecTamarama0_queueCompressState(const struct NFA *n,
     return nfaQueueCompressState(sub, &q1, loc);
 }
 
-char nfaExecTamarama0_expandState(const struct NFA *n, void *dest,
-                                  const void *src, u64a offset, u8 key) {
+char nfaExecTamarama_expandState(const struct NFA *n, void *dest,
+                                 const void *src, u64a offset, u8 key) {
     const struct Tamarama *t = getImplNfa(n);
     u32 activeIdx = loadActiveIdx(src, t->activeIdxSize);
     if (activeIdx == t->numSubEngines) {
@@ -383,8 +382,8 @@ char nfaExecTamarama0_expandState(const struct NFA *n, void *dest,
     return nfaExpandState(sub, dest, subStreamState, offset, key);
 }
 
-enum nfa_zombie_status nfaExecTamarama0_zombie_status(const struct NFA *n,
-                                                      struct mq *q, s64a loc) {
+enum nfa_zombie_status nfaExecTamarama_zombie_status(const struct NFA *n,
+                                                     struct mq *q, s64a loc) {
     const struct Tamarama *t = getImplNfa(n);
     u32 activeIdx = loadActiveIdx(q->streamState, t->activeIdxSize);
     if (activeIdx == t->numSubEngines) {
@@ -397,7 +396,7 @@ enum nfa_zombie_status nfaExecTamarama0_zombie_status(const struct NFA *n,
     return nfaGetZombieStatus(sub, &q1, loc);
 }
 
-char nfaExecTamarama0_Q(const struct NFA *n, struct mq *q, s64a end) {
+char nfaExecTamarama_Q(const struct NFA *n, struct mq *q, s64a end) {
     DEBUG_PRINTF("exec\n");
     struct mq q1;
     char rv = MO_ALIVE;
@@ -418,8 +417,7 @@ char nfaExecTamarama0_Q(const struct NFA *n, struct mq *q, s64a end) {
     return rv;
 }
 
-char nfaExecTamarama0_Q2(const struct NFA *n,
-                         struct mq *q, s64a end) {
+char nfaExecTamarama_Q2(const struct NFA *n, struct mq *q, s64a end) {
     DEBUG_PRINTF("exec to match\n");
     struct mq q1;
     char rv = 0;

diff --git a/src/nfa/tamarama.h b/src/nfa/tamarama.h
index 7ccfa5a09a1f7413a5731314c18d8cf9f92706f1..3b52d8de73b2688b47cc9715d4935366a1469915 100644 (file)
--- a/src/nfa/tamarama.h
+++ b/src/nfa/tamarama.h
@@ -41,28 +41,27 @@ struct mq;
 struct NFA;
 struct hs_scratch;
 
-char nfaExecTamarama0_testEOD(const struct NFA *n, const char *state,
-                              const char *streamState, u64a offset,
-                              NfaCallback callback, void *context);
-char nfaExecTamarama0_QR(const struct NFA *n, struct mq *q, ReportID report);
-char nfaExecTamarama0_reportCurrent(const struct NFA *n, struct mq *q);
-char nfaExecTamarama0_inAccept(const struct NFA *n, ReportID report,
-                               struct mq *q);
-char nfaExecTamarama0_inAnyAccept(const struct NFA *n, struct mq *q);
-char nfaExecTamarama0_queueInitState(const struct NFA *n, struct mq *q);
-char nfaExecTamarama0_queueCompressState(const struct NFA *n,
-                                         const struct mq *q,
-                                         s64a loc);
-char nfaExecTamarama0_expandState(const struct NFA *n, void *dest,
-                                  const void *src, u64a offset, u8 key);
-enum nfa_zombie_status nfaExecTamarama0_zombie_status(const struct NFA *n,
-                                                      struct mq *q, s64a loc);
-char nfaExecTamarama0_Q(const struct NFA *nfa, struct mq *q, s64a end);
-char nfaExecTamarama0_Q2(const struct NFA *nfa, struct mq *q, s64a end);
+char nfaExecTamarama_testEOD(const struct NFA *n, const char *state,
+                             const char *streamState, u64a offset,
+                             NfaCallback callback, void *context);
+char nfaExecTamarama_QR(const struct NFA *n, struct mq *q, ReportID report);
+char nfaExecTamarama_reportCurrent(const struct NFA *n, struct mq *q);
+char nfaExecTamarama_inAccept(const struct NFA *n, ReportID report,
+                              struct mq *q);
+char nfaExecTamarama_inAnyAccept(const struct NFA *n, struct mq *q);
+char nfaExecTamarama_queueInitState(const struct NFA *n, struct mq *q);
+char nfaExecTamarama_queueCompressState(const struct NFA *n, const struct mq *q,
+                                        s64a loc);
+char nfaExecTamarama_expandState(const struct NFA *n, void *dest,
+                                 const void *src, u64a offset, u8 key);
+enum nfa_zombie_status nfaExecTamarama_zombie_status(const struct NFA *n,
+                                                     struct mq *q, s64a loc);
+char nfaExecTamarama_Q(const struct NFA *nfa, struct mq *q, s64a end);
+char nfaExecTamarama_Q2(const struct NFA *nfa, struct mq *q, s64a end);
 
 // only used by outfix and miracles, no implementation for tamarama
-#define nfaExecTamarama0_initCompressedState NFA_API_NO_IMPL
-#define nfaExecTamarama0_B_Reverse NFA_API_NO_IMPL
+#define nfaExecTamarama_initCompressedState NFA_API_NO_IMPL
+#define nfaExecTamarama_B_Reverse NFA_API_NO_IMPL
 
 #ifdef __cplusplus
 }

diff --git a/src/nfa/tamarama_dump.cpp b/src/nfa/tamarama_dump.cpp
index 181fa9af28b549a0976880a59140f6df6d38924f..f03b842c72e91ae8eb5f4c7cb40d3dfcc6961e30 100644 (file)
--- a/src/nfa/tamarama_dump.cpp
+++ b/src/nfa/tamarama_dump.cpp
@@ -48,8 +48,8 @@
 
 namespace ue2 {
 
-void nfaExecTamarama0_dumpDot(const struct NFA *nfa, UNUSED FILE *f,
-                              const std::string &base) {
+void nfaExecTamarama_dumpDot(const struct NFA *nfa, UNUSED FILE *f,
+                             const std::string &base) {
     const Tamarama *t = (const Tamarama *)getImplNfa(nfa);
     const u32 *subOffset =
         (const u32 *)((const char *)t + sizeof(struct Tamarama) +
@@ -65,7 +65,7 @@ void nfaExecTamarama0_dumpDot(const struct NFA *nfa, UNUSED FILE *f,
     }
 }
 
-void nfaExecTamarama0_dumpText(const struct NFA *nfa, FILE *f) {
+void nfaExecTamarama_dumpText(const struct NFA *nfa, FILE *f) {
     const Tamarama *t = (const Tamarama *)getImplNfa(nfa);
 
     fprintf(f, "Tamarama container engine\n");

diff --git a/src/nfa/tamarama_dump.h b/src/nfa/tamarama_dump.h
index dc976004b61f4783562df3a253c833c9ef06c7e3..6e3f80ca408ba99464a52908ca25a3c0ca44c9af 100644 (file)
--- a/src/nfa/tamarama_dump.h
+++ b/src/nfa/tamarama_dump.h
@@ -38,9 +38,9 @@ struct NFA;
 
 namespace ue2 {
 
-void nfaExecTamarama0_dumpDot(const NFA *nfa, FILE *file,
-                              const std::string &base);
-void nfaExecTamarama0_dumpText(const NFA *nfa, FILE *file);
+void nfaExecTamarama_dumpDot(const NFA *nfa, FILE *file,
+                             const std::string &base);
+void nfaExecTamarama_dumpText(const NFA *nfa, FILE *file);
 
 } // namespace ue2
 

diff --git a/src/nfa/tamaramacompile.cpp b/src/nfa/tamaramacompile.cpp
index 521c9bb248c033f9d6690432ededad2ba1434467..c28caacbe1005fe80fa68f01c93da28a58df6414 100644 (file)
--- a/src/nfa/tamaramacompile.cpp
+++ b/src/nfa/tamaramacompile.cpp
@@ -134,7 +134,7 @@ aligned_unique_ptr<NFA> buildTamarama(const TamaInfo &tamaInfo, const u32 queue,
     // so add one to subSize here
     u32 activeIdxSize = calcPackedBytes(subSize + 1);
     aligned_unique_ptr<NFA> nfa = aligned_zmalloc_unique<NFA>(total_size);
-    nfa->type = verify_u8(TAMARAMA_NFA_0);
+    nfa->type = verify_u8(TAMARAMA_NFA);
     nfa->length = verify_u32(total_size);
     nfa->queueIndex = queue;
 

diff --git a/src/nfagraph/ng_lbr.cpp b/src/nfagraph/ng_lbr.cpp
index d7183817dee1848fa1d95fe5834fd2f90f2f1c24..d68c768155eb6829f5d3746bf9ce5750ba7e4ca0 100644 (file)
--- a/src/nfagraph/ng_lbr.cpp
+++ b/src/nfagraph/ng_lbr.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -153,8 +153,7 @@ aligned_unique_ptr<NFA> buildLbrDot(const CharReach &cr, const depth &repeatMin,
 
     enum RepeatType rtype = chooseRepeatType(repeatMin, repeatMax, minPeriod,
                                              is_reset);
-    aligned_unique_ptr<NFA> nfa
-        = makeLbrNfa<lbr_dot>(LBR_NFA_Dot, rtype, repeatMax);
+    auto nfa = makeLbrNfa<lbr_dot>(LBR_NFA_DOT, rtype, repeatMax);
     struct lbr_dot *ld = (struct lbr_dot *)getMutableImplNfa(nfa.get());
 
     fillNfa<lbr_dot>(nfa.get(), &ld->common, report, repeatMin, repeatMax,
@@ -177,8 +176,7 @@ aligned_unique_ptr<NFA> buildLbrVerm(const CharReach &cr,
 
     enum RepeatType rtype = chooseRepeatType(repeatMin, repeatMax, minPeriod,
                                              is_reset);
-    aligned_unique_ptr<NFA> nfa
-        = makeLbrNfa<lbr_verm>(LBR_NFA_Verm, rtype, repeatMax);
+    auto nfa = makeLbrNfa<lbr_verm>(LBR_NFA_VERM, rtype, repeatMax);
     struct lbr_verm *lv = (struct lbr_verm *)getMutableImplNfa(nfa.get());
     lv->c = escapes.find_first();
 
@@ -202,8 +200,7 @@ aligned_unique_ptr<NFA> buildLbrNVerm(const CharReach &cr,
 
     enum RepeatType rtype = chooseRepeatType(repeatMin, repeatMax, minPeriod,
                                              is_reset);
-    aligned_unique_ptr<NFA> nfa
-        = makeLbrNfa<lbr_verm>(LBR_NFA_NVerm, rtype, repeatMax);
+    auto nfa = makeLbrNfa<lbr_verm>(LBR_NFA_NVERM, rtype, repeatMax);
     struct lbr_verm *lv = (struct lbr_verm *)getMutableImplNfa(nfa.get());
     lv->c = escapes.find_first();
 
@@ -221,8 +218,7 @@ aligned_unique_ptr<NFA> buildLbrShuf(const CharReach &cr,
                                      bool is_reset, ReportID report) {
     enum RepeatType rtype = chooseRepeatType(repeatMin, repeatMax, minPeriod,
                                              is_reset);
-    aligned_unique_ptr<NFA> nfa
-        = makeLbrNfa<lbr_shuf>(LBR_NFA_Shuf, rtype, repeatMax);
+    auto nfa = makeLbrNfa<lbr_shuf>(LBR_NFA_SHUF, rtype, repeatMax);
     struct lbr_shuf *ls = (struct lbr_shuf *)getMutableImplNfa(nfa.get());
 
     fillNfa<lbr_shuf>(nfa.get(), &ls->common, report, repeatMin, repeatMax,
@@ -243,8 +239,7 @@ aligned_unique_ptr<NFA> buildLbrTruf(const CharReach &cr,
                                      bool is_reset, ReportID report) {
     enum RepeatType rtype = chooseRepeatType(repeatMin, repeatMax, minPeriod,
                                              is_reset);
-    aligned_unique_ptr<NFA> nfa
-        = makeLbrNfa<lbr_truf>(LBR_NFA_Truf, rtype, repeatMax);
+    auto nfa = makeLbrNfa<lbr_truf>(LBR_NFA_TRUF, rtype, repeatMax);
     struct lbr_truf *lc = (struct lbr_truf *)getMutableImplNfa(nfa.get());
 
     fillNfa<lbr_truf>(nfa.get(), &lc->common, report, repeatMin, repeatMax,

diff --git a/src/rose/catchup.c b/src/rose/catchup.c
index 017a6bf0e4877e8458360961eeade16b66769af9..8253724178193ac9c48b804c5cb2098b09bb78f4 100644 (file)
--- a/src/rose/catchup.c
+++ b/src/rose/catchup.c
@@ -401,7 +401,7 @@ hwlmcb_rv_t roseCatchUpMPV_i(const struct RoseEngine *t, s64a loc,
     scratch->tctxt.mpv_inactive = 0;
 
     /* we know it is going to be an mpv, skip the indirection */
-    next_pos_match_loc = nfaExecMpv0_QueueExecRaw(q->nfa, q, loc);
+    next_pos_match_loc = nfaExecMpv_QueueExecRaw(q->nfa, q, loc);
     assert(!q->report_current);
 
     if (!next_pos_match_loc) { /* 0 means dead */
@@ -441,7 +441,7 @@ char in_mpv(const struct RoseEngine *rose, const struct hs_scratch *scratch) {
     const struct RoseContext *tctxt = &scratch->tctxt;
     assert(tctxt->curr_qi < rose->queueCount);
     if (tctxt->curr_qi < rose->outfixBeginQueue) {
-        assert(getNfaByQueue(rose, tctxt->curr_qi)->type == MPV_NFA_0);
+        assert(getNfaByQueue(rose, tctxt->curr_qi)->type == MPV_NFA);
         return 1;
     }
     return 0;

diff --git a/src/runtime.c b/src/runtime.c
index 30745d81468aea848441b1306d3dd47bf1025609..d8e2f28deaa6510ed6240684dfd20bf9ef972c37 100644 (file)
--- a/src/runtime.c
+++ b/src/runtime.c
@@ -291,12 +291,12 @@ void runSmallWriteEngine(const struct SmallWriteEngine *smwr,
     if (nfa->type == MCCLELLAN_NFA_8) {
         nfaExecMcClellan8_B(nfa, smwr->start_offset, local_buffer,
                             local_alen, roseReportAdaptor, scratch);
-    } else if (nfa->type == MCCLELLAN_NFA_16){
+    } else if (nfa->type == MCCLELLAN_NFA_16) {
         nfaExecMcClellan16_B(nfa, smwr->start_offset, local_buffer,
                              local_alen, roseReportAdaptor, scratch);
     } else {
-        nfaExecSheng0_B(nfa, smwr->start_offset, local_buffer,
-                        local_alen, roseReportAdaptor, scratch);
+        nfaExecSheng_B(nfa, smwr->start_offset, local_buffer,
+                       local_alen, roseReportAdaptor, scratch);
     }
 }