github_mirrors/vectorscan
3
0
Fork 1
mirror of https://github.com/VectorCamp/vectorscan.git synced 2025-06-28 16:41:01 +03:00
Code Issues Packages Projects Releases Wiki Activity

nfa_api: remove subtype from dispatch

Browse Source
This commit is contained in:
Alex Coyte 2016-10-28 09:50:09 +11:00 committed by Matthew Barr
parent 1614c73eeb
commit 71ff480b77
29 changed files with 318 additions and 329 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
src/nfa/castle.c
View File

@ -745,10 +745,10 @@ void clear_repeats(const struct Castle *c, const struct mq *q, u8 *active) {
} }
static really_inline static really_inline
char nfaExecCastle0_Q_i(const struct NFA *n, struct mq *q, s64a end, char nfaExecCastle_Q_i(const struct NFA *n, struct mq *q, s64a end,
enum MatchMode mode) { enum MatchMode mode) {
assert(n && q); 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); 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); 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"); 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"); 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 static
@ -896,9 +896,9 @@ s64a castleLastKillLoc(const struct Castle *c, struct mq *q) {
return sp - 1; /* the repeats are never killed */ 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 && q);
assert(n->type == CASTLE_NFA_0); assert(n->type == CASTLE_NFA);
DEBUG_PRINTF("entry\n"); DEBUG_PRINTF("entry\n");
if (q->cur == q->end) { if (q->cur == q->end) {
@ -959,9 +959,9 @@ char nfaExecCastle0_QR(const struct NFA *n, struct mq *q, ReportID report) {
return 1; 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 && q);
assert(n->type == CASTLE_NFA_0); assert(n->type == CASTLE_NFA);
DEBUG_PRINTF("entry\n"); DEBUG_PRINTF("entry\n");
const struct Castle *c = getImplNfa(n); const struct Castle *c = getImplNfa(n);
@ -969,19 +969,19 @@ char nfaExecCastle0_reportCurrent(const struct NFA *n, struct mq *q) {
return 0; return 0;
} }
char nfaExecCastle0_inAccept(const struct NFA *n, ReportID report, char nfaExecCastle_inAccept(const struct NFA *n, ReportID report,
struct mq *q) { struct mq *q) {
assert(n && q); assert(n && q);
assert(n->type == CASTLE_NFA_0); assert(n->type == CASTLE_NFA);
DEBUG_PRINTF("entry\n"); DEBUG_PRINTF("entry\n");
const struct Castle *c = getImplNfa(n); const struct Castle *c = getImplNfa(n);
return castleInAccept(c, q, report, q_cur_offset(q)); 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 && q);
assert(n->type == CASTLE_NFA_0); assert(n->type == CASTLE_NFA);
DEBUG_PRINTF("entry\n"); DEBUG_PRINTF("entry\n");
const struct Castle *c = getImplNfa(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 && q);
assert(n->type == CASTLE_NFA_0); assert(n->type == CASTLE_NFA);
DEBUG_PRINTF("entry\n"); DEBUG_PRINTF("entry\n");
const struct Castle *c = getImplNfa(n); const struct Castle *c = getImplNfa(n);
@ -1038,10 +1038,10 @@ char nfaExecCastle0_queueInitState(UNUSED const struct NFA *n, struct mq *q) {
return 0; return 0;
} }
char nfaExecCastle0_initCompressedState(const struct NFA *n, UNUSED u64a offset, char nfaExecCastle_initCompressedState(const struct NFA *n, UNUSED u64a offset,
void *state, UNUSED u8 key) { void *state, UNUSED u8 key) {
assert(n && state); assert(n && state);
assert(n->type == CASTLE_NFA_0); assert(n->type == CASTLE_NFA);
DEBUG_PRINTF("entry\n"); DEBUG_PRINTF("entry\n");
const struct Castle *c = getImplNfa(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); repeatPack(packed, info, rctrl, offset);
} }
char nfaExecCastle0_queueCompressState(const struct NFA *n, const struct mq *q, char nfaExecCastle_queueCompressState(const struct NFA *n, const struct mq *q,
s64a loc) { s64a loc) {
assert(n && q); assert(n && q);
assert(n->type == CASTLE_NFA_0); assert(n->type == CASTLE_NFA);
DEBUG_PRINTF("entry, loc=%lld\n", loc); DEBUG_PRINTF("entry, loc=%lld\n", loc);
const struct Castle *c = getImplNfa(n); const struct Castle *c = getImplNfa(n);
@ -1118,11 +1118,10 @@ void subCastleExpandState(const struct Castle *c, const u32 subIdx,
packed + info->packedCtrlSize, offset)); packed + info->packedCtrlSize, offset));
} }
char nfaExecCastle0_expandState(const struct NFA *n, void *dest, char nfaExecCastle_expandState(const struct NFA *n, void *dest, const void *src,
const void *src, u64a offset, u64a offset, UNUSED u8 key) {
UNUSED u8 key) {
assert(n && dest && src); 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); DEBUG_PRINTF("entry, src=%p, dest=%p, offset=%llu\n", src, dest, offset);
const struct Castle *c = getImplNfa(n); const struct Castle *c = getImplNfa(n);

28
src/nfa/castle.h
View File

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

4
src/nfa/castle_dump.cpp
View File

@ -48,7 +48,7 @@
namespace ue2 { namespace ue2 {
void nfaExecCastle0_dumpDot(const struct NFA *, FILE *, void nfaExecCastle_dumpDot(const struct NFA *, FILE *,
UNUSED const std::string &base) { UNUSED const std::string &base) {
// No GraphViz output for Castles. // No GraphViz output for Castles.
} }
@ -68,7 +68,7 @@ void dumpTextSubCastle(const SubCastle &sub, FILE *f) {
fprintf(f, "\n"); 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); const Castle *c = (const Castle *)getImplNfa(nfa);
fprintf(f, "Castle multi-tenant repeat engine\n"); fprintf(f, "Castle multi-tenant repeat engine\n");

5
src/nfa/castle_dump.h
View File

@ -38,9 +38,8 @@ struct NFA;
namespace ue2 { namespace ue2 {
void nfaExecCastle0_dumpDot(const NFA *nfa, FILE *file, void nfaExecCastle_dumpDot(const NFA *nfa, FILE *file, const std::string &base);
const std::string &base); void nfaExecCastle_dumpText(const NFA *nfa, FILE *file);
void nfaExecCastle0_dumpText(const NFA *nfa, FILE *file);
} // namespace ue2 } // namespace ue2

2
src/nfa/castlecompile.cpp
View File

@ -577,7 +577,7 @@ buildCastle(const CastleProto &proto,
total_size += byte_length(stale_iter); // stale sparse iter total_size += byte_length(stale_iter); // stale sparse iter
aligned_unique_ptr<NFA> nfa = aligned_zmalloc_unique<NFA>(total_size); 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->length = verify_u32(total_size);
nfa->nPositions = verify_u32(subs.size()); nfa->nPositions = verify_u32(subs.size());
nfa->streamStateSize = streamStateSize; nfa->streamStateSize = streamStateSize;

20
src/nfa/lbr.c
View File

@ -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 begin, UNUSED size_t end,
UNUSED size_t *loc) { UNUSED size_t *loc) {
assert(begin <= end); assert(begin <= end);
assert(nfa->type == LBR_NFA_Dot); assert(nfa->type == LBR_NFA_DOT);
// Nothing can kill a dot! // Nothing can kill a dot!
return 0; return 0;
} }
@ -316,7 +316,7 @@ static really_inline
char lbrRevScanVerm(const struct NFA *nfa, const u8 *buf, char lbrRevScanVerm(const struct NFA *nfa, const u8 *buf,
size_t begin, size_t end, size_t *loc) { size_t begin, size_t end, size_t *loc) {
assert(begin <= end); assert(begin <= end);
assert(nfa->type == LBR_NFA_Verm); assert(nfa->type == LBR_NFA_VERM);
const struct lbr_verm *l = getImplNfa(nfa); const struct lbr_verm *l = getImplNfa(nfa);
if (begin == end) { if (begin == end) {
@ -340,7 +340,7 @@ static really_inline
char lbrRevScanNVerm(const struct NFA *nfa, const u8 *buf, char lbrRevScanNVerm(const struct NFA *nfa, const u8 *buf,
size_t begin, size_t end, size_t *loc) { size_t begin, size_t end, size_t *loc) {
assert(begin <= end); assert(begin <= end);
assert(nfa->type == LBR_NFA_NVerm); assert(nfa->type == LBR_NFA_NVERM);
const struct lbr_verm *l = getImplNfa(nfa); const struct lbr_verm *l = getImplNfa(nfa);
if (begin == end) { if (begin == end) {
@ -365,7 +365,7 @@ char lbrRevScanShuf(const struct NFA *nfa, const u8 *buf,
size_t begin, size_t end, size_t begin, size_t end,
size_t *loc) { size_t *loc) {
assert(begin <= end); assert(begin <= end);
assert(nfa->type == LBR_NFA_Shuf); assert(nfa->type == LBR_NFA_SHUF);
const struct lbr_shuf *l = getImplNfa(nfa); const struct lbr_shuf *l = getImplNfa(nfa);
if (begin == end) { if (begin == end) {
@ -389,7 +389,7 @@ char lbrRevScanTruf(const struct NFA *nfa, const u8 *buf,
size_t begin, size_t end, size_t begin, size_t end,
size_t *loc) { size_t *loc) {
assert(begin <= end); assert(begin <= end);
assert(nfa->type == LBR_NFA_Truf); assert(nfa->type == LBR_NFA_TRUF);
const struct lbr_truf *l = getImplNfa(nfa); const struct lbr_truf *l = getImplNfa(nfa);
if (begin == end) { 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 begin, UNUSED size_t end,
UNUSED size_t *loc) { UNUSED size_t *loc) {
assert(begin <= end); assert(begin <= end);
assert(nfa->type == LBR_NFA_Dot); assert(nfa->type == LBR_NFA_DOT);
// Nothing can kill a dot! // Nothing can kill a dot!
return 0; return 0;
} }
@ -422,7 +422,7 @@ static really_inline
char lbrFwdScanVerm(const struct NFA *nfa, const u8 *buf, char lbrFwdScanVerm(const struct NFA *nfa, const u8 *buf,
size_t begin, size_t end, size_t *loc) { size_t begin, size_t end, size_t *loc) {
assert(begin <= end); assert(begin <= end);
assert(nfa->type == LBR_NFA_Verm); assert(nfa->type == LBR_NFA_VERM);
const struct lbr_verm *l = getImplNfa(nfa); const struct lbr_verm *l = getImplNfa(nfa);
if (begin == end) { if (begin == end) {
@ -446,7 +446,7 @@ static really_inline
char lbrFwdScanNVerm(const struct NFA *nfa, const u8 *buf, char lbrFwdScanNVerm(const struct NFA *nfa, const u8 *buf,
size_t begin, size_t end, size_t *loc) { size_t begin, size_t end, size_t *loc) {
assert(begin <= end); assert(begin <= end);
assert(nfa->type == LBR_NFA_NVerm); assert(nfa->type == LBR_NFA_NVERM);
const struct lbr_verm *l = getImplNfa(nfa); const struct lbr_verm *l = getImplNfa(nfa);
if (begin == end) { if (begin == end) {
@ -471,7 +471,7 @@ char lbrFwdScanShuf(const struct NFA *nfa, const u8 *buf,
size_t begin, size_t end, size_t begin, size_t end,
size_t *loc) { size_t *loc) {
assert(begin <= end); assert(begin <= end);
assert(nfa->type == LBR_NFA_Shuf); assert(nfa->type == LBR_NFA_SHUF);
const struct lbr_shuf *l = getImplNfa(nfa); const struct lbr_shuf *l = getImplNfa(nfa);
if (begin == end) { if (begin == end) {
@ -495,7 +495,7 @@ char lbrFwdScanTruf(const struct NFA *nfa, const u8 *buf,
size_t begin, size_t end, size_t begin, size_t end,
size_t *loc) { size_t *loc) {
assert(begin <= end); assert(begin <= end);
assert(nfa->type == LBR_NFA_Truf); assert(nfa->type == LBR_NFA_TRUF);
const struct lbr_truf *l = getImplNfa(nfa); const struct lbr_truf *l = getImplNfa(nfa);
if (begin == end) { if (begin == end) {

10
src/nfa/lbr_dump.cpp
View File

@ -90,7 +90,7 @@ void lbrDumpCommon(const lbr_common *lc, FILE *f) {
void nfaExecLbrDot_dumpText(const NFA *nfa, FILE *f) { void nfaExecLbrDot_dumpText(const NFA *nfa, FILE *f) {
assert(nfa); assert(nfa);
assert(nfa->type == LBR_NFA_Dot); assert(nfa->type == LBR_NFA_DOT);
const lbr_dot *ld = (const lbr_dot *)getImplNfa(nfa); const lbr_dot *ld = (const lbr_dot *)getImplNfa(nfa);
lbrDumpCommon(&ld->common, f); lbrDumpCommon(&ld->common, f);
fprintf(f, "DOT model\n"); 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) { void nfaExecLbrVerm_dumpText(const NFA *nfa, FILE *f) {
assert(nfa); assert(nfa);
assert(nfa->type == LBR_NFA_Verm); assert(nfa->type == LBR_NFA_VERM);
const lbr_verm *lv = (const lbr_verm *)getImplNfa(nfa); const lbr_verm *lv = (const lbr_verm *)getImplNfa(nfa);
lbrDumpCommon(&lv->common, f); lbrDumpCommon(&lv->common, f);
fprintf(f, "VERM model, scanning for 0x%02x\n", lv->c); 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) { void nfaExecLbrNVerm_dumpText(const NFA *nfa, FILE *f) {
assert(nfa); assert(nfa);
assert(nfa->type == LBR_NFA_NVerm); assert(nfa->type == LBR_NFA_NVERM);
const lbr_verm *lv = (const lbr_verm *)getImplNfa(nfa); const lbr_verm *lv = (const lbr_verm *)getImplNfa(nfa);
lbrDumpCommon(&lv->common, f); lbrDumpCommon(&lv->common, f);
fprintf(f, "NEGATED VERM model, scanning for 0x%02x\n", lv->c); 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) { void nfaExecLbrShuf_dumpText(const NFA *nfa, FILE *f) {
assert(nfa); assert(nfa);
assert(nfa->type == LBR_NFA_Shuf); assert(nfa->type == LBR_NFA_SHUF);
const lbr_shuf *ls = (const lbr_shuf *)getImplNfa(nfa); const lbr_shuf *ls = (const lbr_shuf *)getImplNfa(nfa);
lbrDumpCommon(&ls->common, f); lbrDumpCommon(&ls->common, f);
@ -133,7 +133,7 @@ void nfaExecLbrShuf_dumpText(const NFA *nfa, FILE *f) {
void nfaExecLbrTruf_dumpText(const NFA *nfa, FILE *f) { void nfaExecLbrTruf_dumpText(const NFA *nfa, FILE *f) {
assert(nfa); assert(nfa);
assert(nfa->type == LBR_NFA_Truf); assert(nfa->type == LBR_NFA_TRUF);
const lbr_truf *lt = (const lbr_truf *)getImplNfa(nfa); const lbr_truf *lt = (const lbr_truf *)getImplNfa(nfa);
lbrDumpCommon(&lt->common, f); lbrDumpCommon(&lt->common, f);

22
src/nfa/mpv.c
View File

@ -825,7 +825,7 @@ void mpvStoreState(const struct NFA *n, char *state,
} }
} }
char nfaExecMpv0_queueCompressState(const struct NFA *nfa, const struct mq *q, char nfaExecMpv_queueCompressState(const struct NFA *nfa, const struct mq *q,
UNUSED s64a loc) { UNUSED s64a loc) {
void *dest = q->streamState; void *dest = q->streamState;
const void *src = q->state; const void *src = q->state;
@ -833,13 +833,13 @@ char nfaExecMpv0_queueCompressState(const struct NFA *nfa, const struct mq *q,
return 0; return 0;
} }
char nfaExecMpv0_expandState(const struct NFA *nfa, void *dest, const void *src, char nfaExecMpv_expandState(const struct NFA *nfa, void *dest, const void *src,
UNUSED u64a offset, UNUSED u8 key) { UNUSED u64a offset, UNUSED u8 key) {
mpvLoadState(dest, nfa, src); mpvLoadState(dest, nfa, src);
return 0; 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); const struct mpv *m = getImplNfa(n);
u64a offset = q_cur_offset(q); u64a offset = q_cur_offset(q);
struct mpv_decomp_state *s = (struct mpv_decomp_state *)q->state; 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; 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; struct mpv_decomp_state *out = (void *)q->state;
const struct mpv *m = getImplNfa(n); const struct mpv *m = getImplNfa(n);
assert(sizeof(*out) <= n->scratchStateSize); assert(sizeof(*out) <= n->scratchStateSize);
@ -880,7 +880,7 @@ char nfaExecMpv0_queueInitState(const struct NFA *n, struct mq *q) {
return 0; return 0;
} }
char nfaExecMpv0_initCompressedState(const struct NFA *n, u64a offset, char nfaExecMpv_initCompressedState(const struct NFA *n, u64a offset,
void *state, UNUSED u8 key) { void *state, UNUSED u8 key) {
const struct mpv *m = getImplNfa(n); const struct mpv *m = getImplNfa(n);
memset(state, 0, m->active_offset); /* active_offset marks end of comp memset(state, 0, m->active_offset); /* active_offset marks end of comp
@ -896,7 +896,7 @@ char nfaExecMpv0_initCompressedState(const struct NFA *n, u64a offset,
} }
static really_inline 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; u64a offset = q->offset;
const u8 *buffer = q->buffer; const u8 *buffer = q->buffer;
size_t length = q->length; size_t length = q->length;
@ -1021,18 +1021,18 @@ char nfaExecMpv0_Q_i(const struct NFA *n, struct mq *q, s64a end) {
return alive; 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); 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); DEBUG_PRINTF("nfa=%p end=%lld\n", nfa, end);
#ifdef DEBUG #ifdef DEBUG
debugQueue(q); debugQueue(q);
#endif #endif
assert(nfa->type == MPV_NFA_0); assert(nfa->type == MPV_NFA);
assert(q && q->context && q->state); assert(q && q->context && q->state);
assert(end >= 0); assert(end >= 0);
assert(q->cur < q->end); 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 /* TODO: restore max offset stuff, if/when _interesting_ max offset stuff
* is filled in */ * is filled in */
char rv = nfaExecMpv0_Q_i(nfa, q, end); char rv = nfaExecMpv_Q_i(nfa, q, end);
assert(!q->report_current); assert(!q->report_current);
DEBUG_PRINTF("returned rv=%d, q_trimmed=%d\n", rv, q_trimmed); DEBUG_PRINTF("returned rv=%d, q_trimmed=%d\n", rv, q_trimmed);

28
src/nfa/mpv.h
View File

@ -34,27 +34,27 @@
struct mq; struct mq;
struct NFA; struct NFA;
char nfaExecMpv0_Q(const struct NFA *n, struct mq *q, s64a end); char nfaExecMpv_Q(const struct NFA *n, struct mq *q, s64a end);
char nfaExecMpv0_reportCurrent(const struct NFA *n, struct mq *q); char nfaExecMpv_reportCurrent(const struct NFA *n, struct mq *q);
char nfaExecMpv0_queueInitState(const struct NFA *n, struct mq *q); char nfaExecMpv_queueInitState(const struct NFA *n, struct mq *q);
char nfaExecMpv0_initCompressedState(const struct NFA *n, u64a offset, char nfaExecMpv_initCompressedState(const struct NFA *n, u64a offset,
void *state, u8 key); void *state, u8 key);
char nfaExecMpv0_queueCompressState(const struct NFA *nfa, const struct mq *q, char nfaExecMpv_queueCompressState(const struct NFA *nfa, const struct mq *q,
s64a loc); s64a loc);
char nfaExecMpv0_expandState(const struct NFA *nfa, void *dest, const void *src, char nfaExecMpv_expandState(const struct NFA *nfa, void *dest, const void *src,
u64a offset, u8 key); u64a offset, u8 key);
#define nfaExecMpv0_testEOD NFA_API_NO_IMPL #define nfaExecMpv_testEOD NFA_API_NO_IMPL
#define nfaExecMpv0_inAccept NFA_API_NO_IMPL #define nfaExecMpv_inAccept NFA_API_NO_IMPL
#define nfaExecMpv0_inAnyAccept NFA_API_NO_IMPL #define nfaExecMpv_inAnyAccept NFA_API_NO_IMPL
#define nfaExecMpv0_QR NFA_API_NO_IMPL #define nfaExecMpv_QR NFA_API_NO_IMPL
#define nfaExecMpv0_Q2 NFA_API_NO_IMPL /* for non-chained suffixes. */ #define nfaExecMpv_Q2 NFA_API_NO_IMPL /* for non-chained suffixes. */
#define nfaExecMpv0_B_Reverse NFA_API_NO_IMPL #define nfaExecMpv_B_Reverse NFA_API_NO_IMPL
#define nfaExecMpv0_zombie_status NFA_API_ZOMBIE_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 * return 0 if the mpv dies, otherwise returns the location of the next possible
* match (given the currently known events). */ * 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 #endif

4
src/nfa/mpv_dump.cpp
View File

@ -48,7 +48,7 @@
namespace ue2 { namespace ue2 {
void nfaExecMpv0_dumpDot(UNUSED const NFA *nfa, UNUSED FILE *file, void nfaExecMpv_dumpDot(UNUSED const NFA *nfa, UNUSED FILE *file,
UNUSED const std::string &base) { UNUSED const std::string &base) {
} }
@ -128,7 +128,7 @@ void dumpCounter(FILE *f, const mpv_counter_info *c) {
fprintf(f, "\n"); 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); const mpv *m = (const mpv *)getImplNfa(nfa);
fprintf(f, "Puff the Magic Engines\n"); fprintf(f, "Puff the Magic Engines\n");

4
src/nfa/mpv_dump.h
View File

@ -38,9 +38,9 @@ struct NFA;
namespace ue2 { namespace ue2 {
void nfaExecMpv0_dumpDot(const struct NFA *nfa, FILE *file, void nfaExecMpv_dumpDot(const struct NFA *nfa, FILE *file,
const std::string &base); const std::string &base);
void nfaExecMpv0_dumpText(const struct NFA *nfa, FILE *file); void nfaExecMpv_dumpText(const struct NFA *nfa, FILE *file);
} // namespace ue2 } // namespace ue2

2
src/nfa/mpvcompile.cpp
View File

@ -207,7 +207,7 @@ void writeCoreNfa(NFA *nfa, u32 len, u32 min_width, u32 max_counter,
nfa->length = len; nfa->length = len;
nfa->nPositions = max_counter - 1; nfa->nPositions = max_counter - 1;
nfa->type = MPV_NFA_0; nfa->type = MPV_NFA;
nfa->streamStateSize = streamStateSize; nfa->streamStateSize = streamStateSize;
assert(16 >= sizeof(mpv_decomp_kilo)); assert(16 >= sizeof(mpv_decomp_kilo));
nfa->scratchStateSize = scratchStateSize; nfa->scratchStateSize = scratchStateSize;

44
src/nfa/nfa_api_dispatch.c
View File

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

90
src/nfa/nfa_build_util.cpp
View File

@ -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"; const char *NFATraits<GOUGH_NFA_16>::name = "Goughfish 16";
#endif #endif
template<> struct NFATraits<MPV_NFA_0> { template<> struct NFATraits<MPV_NFA> {
UNUSED static const char *name; UNUSED static const char *name;
static const NFACategory category = NFA_OTHER; static const NFACategory category = NFA_OTHER;
static const u32 stateAlign = 8; 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;
static const nfa_dispatch_fn has_repeats_other_than_firsts; 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>::has_accel = dispatch_false;
const nfa_dispatch_fn NFATraits<MPV_NFA_0>::has_repeats = dispatch_false; const nfa_dispatch_fn NFATraits<MPV_NFA>::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_repeats_other_than_firsts = dispatch_false;
#if defined(DUMP_SUPPORT) #if defined(DUMP_SUPPORT)
const char *NFATraits<MPV_NFA_0>::name = "Mega-Puff-Vac"; const char *NFATraits<MPV_NFA>::name = "Mega-Puff-Vac";
#endif #endif
template<> struct NFATraits<CASTLE_NFA_0> { template<> struct NFATraits<CASTLE_NFA> {
UNUSED static const char *name; UNUSED static const char *name;
static const NFACategory category = NFA_OTHER; static const NFACategory category = NFA_OTHER;
static const u32 stateAlign = 8; 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;
static const nfa_dispatch_fn has_repeats_other_than_firsts; 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>::has_accel = dispatch_false;
const nfa_dispatch_fn NFATraits<CASTLE_NFA_0>::has_repeats = dispatch_false; const nfa_dispatch_fn NFATraits<CASTLE_NFA>::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_repeats_other_than_firsts = dispatch_false;
#if defined(DUMP_SUPPORT) #if defined(DUMP_SUPPORT)
const char *NFATraits<CASTLE_NFA_0>::name = "Castle"; const char *NFATraits<CASTLE_NFA>::name = "Castle";
#endif #endif
template<> struct NFATraits<LBR_NFA_Dot> { template<> struct NFATraits<LBR_NFA_DOT> {
UNUSED static const char *name; UNUSED static const char *name;
static const NFACategory category = NFA_OTHER; static const NFACategory category = NFA_OTHER;
static const u32 stateAlign = 8; 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;
static const nfa_dispatch_fn has_repeats_other_than_firsts; 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_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 = 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_repeats_other_than_firsts = dispatch_false;
#if defined(DUMP_SUPPORT) #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 #endif
template<> struct NFATraits<LBR_NFA_Verm> { template<> struct NFATraits<LBR_NFA_VERM> {
UNUSED static const char *name; UNUSED static const char *name;
static const NFACategory category = NFA_OTHER; static const NFACategory category = NFA_OTHER;
static const u32 stateAlign = 8; 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;
static const nfa_dispatch_fn has_repeats_other_than_firsts; 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_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 = 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_repeats_other_than_firsts = dispatch_false;
#if defined(DUMP_SUPPORT) #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 #endif
template<> struct NFATraits<LBR_NFA_NVerm> { template<> struct NFATraits<LBR_NFA_NVERM> {
UNUSED static const char *name; UNUSED static const char *name;
static const NFACategory category = NFA_OTHER; static const NFACategory category = NFA_OTHER;
static const u32 stateAlign = 8; 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;
static const nfa_dispatch_fn has_repeats_other_than_firsts; 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_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 = 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_repeats_other_than_firsts = dispatch_false;
#if defined(DUMP_SUPPORT) #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 #endif
template<> struct NFATraits<LBR_NFA_Shuf> { template<> struct NFATraits<LBR_NFA_SHUF> {
UNUSED static const char *name; UNUSED static const char *name;
static const NFACategory category = NFA_OTHER; static const NFACategory category = NFA_OTHER;
static const u32 stateAlign = 8; 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;
static const nfa_dispatch_fn has_repeats_other_than_firsts; 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_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 = 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_repeats_other_than_firsts = dispatch_false;
#if defined(DUMP_SUPPORT) #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 #endif
template<> struct NFATraits<LBR_NFA_Truf> { template<> struct NFATraits<LBR_NFA_TRUF> {
UNUSED static const char *name; UNUSED static const char *name;
static const NFACategory category = NFA_OTHER; static const NFACategory category = NFA_OTHER;
static const u32 stateAlign = 8; 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;
static const nfa_dispatch_fn has_repeats_other_than_firsts; 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_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 = 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_repeats_other_than_firsts = dispatch_false;
#if defined(DUMP_SUPPORT) #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 #endif
template<> struct NFATraits<SHENG_NFA_0> { template<> struct NFATraits<SHENG_NFA> {
UNUSED static const char *name; UNUSED static const char *name;
static const NFACategory category = NFA_OTHER; static const NFACategory category = NFA_OTHER;
static const u32 stateAlign = 1; 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;
static const nfa_dispatch_fn has_repeats_other_than_firsts; 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>::has_accel = has_accel_sheng;
const nfa_dispatch_fn NFATraits<SHENG_NFA_0>::has_repeats = dispatch_false; const nfa_dispatch_fn NFATraits<SHENG_NFA>::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_repeats_other_than_firsts = dispatch_false;
#if defined(DUMP_SUPPORT) #if defined(DUMP_SUPPORT)
const char *NFATraits<SHENG_NFA_0>::name = "Sheng"; const char *NFATraits<SHENG_NFA>::name = "Sheng";
#endif #endif
template<> struct NFATraits<TAMARAMA_NFA_0> { template<> struct NFATraits<TAMARAMA_NFA> {
UNUSED static const char *name; UNUSED static const char *name;
static const NFACategory category = NFA_OTHER; static const NFACategory category = NFA_OTHER;
static const u32 stateAlign = 32; 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;
static const nfa_dispatch_fn has_repeats_other_than_firsts; 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>::has_accel = dispatch_false;
const nfa_dispatch_fn NFATraits<TAMARAMA_NFA_0>::has_repeats = dispatch_false; const nfa_dispatch_fn NFATraits<TAMARAMA_NFA>::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_repeats_other_than_firsts = dispatch_false;
#if defined(DUMP_SUPPORT) #if defined(DUMP_SUPPORT)
const char *NFATraits<TAMARAMA_NFA_0>::name = "Tamarama"; const char *NFATraits<TAMARAMA_NFA>::name = "Tamarama";
#endif #endif
} // namespace } // namespace

44
src/nfa/nfa_dump_dispatch.cpp
View File

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

26
src/nfa/nfa_internal.h
View File

@ -61,15 +61,15 @@ enum NFAEngineType {
MCCLELLAN_NFA_16, /**< magic pseudo nfa */ MCCLELLAN_NFA_16, /**< magic pseudo nfa */
GOUGH_NFA_8, /**< magic pseudo nfa */ GOUGH_NFA_8, /**< magic pseudo nfa */
GOUGH_NFA_16, /**< magic pseudo nfa */ GOUGH_NFA_16, /**< magic pseudo nfa */
MPV_NFA_0, /**< magic pseudo nfa */ MPV_NFA, /**< magic pseudo nfa */
LBR_NFA_Dot, /**< magic pseudo nfa */ LBR_NFA_DOT, /**< magic pseudo nfa */
LBR_NFA_Verm, /**< magic pseudo nfa */ LBR_NFA_VERM, /**< magic pseudo nfa */
LBR_NFA_NVerm, /**< magic pseudo nfa */ LBR_NFA_NVERM, /**< magic pseudo nfa */
LBR_NFA_Shuf, /**< magic pseudo nfa */ LBR_NFA_SHUF, /**< magic pseudo nfa */
LBR_NFA_Truf, /**< magic pseudo nfa */ LBR_NFA_TRUF, /**< magic pseudo nfa */
CASTLE_NFA_0, /**< magic pseudo nfa */ CASTLE_NFA, /**< magic pseudo nfa */
SHENG_NFA_0, /**< magic pseudo nfa */ SHENG_NFA, /**< magic pseudo nfa */
TAMARAMA_NFA_0, /**< magic nfa container */ TAMARAMA_NFA, /**< magic nfa container */
/** \brief bogus NFA - not used */ /** \brief bogus NFA - not used */
INVALID_NFA 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. */ /** \brief True if the given type (from NFA::type) is a Sheng DFA. */
static really_inline int isShengType(u8 t) { 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. */ /** \brief True if the given type (from NFA::type) is an LBR. */
static really_inline static really_inline
int isLbrType(u8 t) { int isLbrType(u8 t) {
return t == LBR_NFA_Dot || t == LBR_NFA_Verm || t == LBR_NFA_NVerm || return t == LBR_NFA_DOT || t == LBR_NFA_VERM || t == LBR_NFA_NVERM ||
t == LBR_NFA_Shuf || t == LBR_NFA_Truf; t == LBR_NFA_SHUF || t == LBR_NFA_TRUF;
} }
/** \brief True if the given type (from NFA::type) is a container engine. */ /** \brief True if the given type (from NFA::type) is a container engine. */
static really_inline static really_inline
int isContainerType(u8 t) { int isContainerType(u8 t) {
return t == TAMARAMA_NFA_0; return t == TAMARAMA_NFA;
} }
static really_inline static really_inline

29
src/nfa/sheng.c
View File

@ -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, char nfaExecSheng_B(const struct NFA *n, u64a offset, const u8 *buffer,
size_t length, NfaCallback cb, void *context) { size_t length, NfaCallback cb, void *context) {
DEBUG_PRINTF("smallwrite Sheng\n"); DEBUG_PRINTF("smallwrite Sheng\n");
assert(n->type == SHENG_NFA_0); assert(n->type == SHENG_NFA);
const struct sheng *sh = getImplNfa(n); const struct sheng *sh = getImplNfa(n);
u8 state = sh->anchored; u8 state = sh->anchored;
u8 can_die = sh->flags & SHENG_FLAG_CAN_DIE; 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; 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); const struct sheng *sh = get_sheng(n);
char rv = runSheng(sh, q, end, CALLBACK_OUTPUT); char rv = runSheng(sh, q, end, CALLBACK_OUTPUT);
return rv; 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); const struct sheng *sh = get_sheng(n);
char rv = runSheng(sh, q, end, STOP_AT_MATCH); char rv = runSheng(sh, q, end, STOP_AT_MATCH);
return rv; 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); assert(q_cur_type(q) == MQE_START);
const struct sheng *sh = get_sheng(n); const struct sheng *sh = get_sheng(n);
char rv = runSheng(sh, q, 0 /* end */, NO_MATCHES); 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 MO_MATCHES_PENDING;
} }
return rv; return rv;
} }
char nfaExecSheng0_inAccept(const struct NFA *n, ReportID report, char nfaExecSheng_inAccept(const struct NFA *n, ReportID report, struct mq *q) {
struct mq *q) {
assert(n && q); assert(n && q);
const struct sheng *sh = get_sheng(n); 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); 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); assert(n && q);
const struct sheng *sh = get_sheng(n); const struct sheng *sh = get_sheng(n);
@ -595,7 +594,7 @@ char nfaExecSheng0_inAnyAccept(const struct NFA *n, struct mq *q) {
return !!aux->accept; return !!aux->accept;
} }
char nfaExecSheng0_testEOD(const struct NFA *nfa, const char *state, char nfaExecSheng_testEOD(const struct NFA *nfa, const char *state,
UNUSED const char *streamState, u64a offset, UNUSED const char *streamState, u64a offset,
NfaCallback cb, void *ctxt) { NfaCallback cb, void *ctxt) {
assert(nfa); assert(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); 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); const struct sheng *sh = (const struct sheng *)getImplNfa(n);
NfaCallback cb = q->cb; NfaCallback cb = q->cb;
void *ctxt = q->context; void *ctxt = q->context;
@ -636,7 +635,7 @@ char nfaExecSheng0_reportCurrent(const struct NFA *n, struct mq *q) {
return 0; return 0;
} }
char nfaExecSheng0_initCompressedState(const struct NFA *nfa, u64a offset, char nfaExecSheng_initCompressedState(const struct NFA *nfa, u64a offset,
void *state, UNUSED u8 key) { void *state, UNUSED u8 key) {
const struct sheng *sh = get_sheng(nfa); const struct sheng *sh = get_sheng(nfa);
u8 *s = (u8 *)state; u8 *s = (u8 *)state;
@ -644,7 +643,7 @@ char nfaExecSheng0_initCompressedState(const struct NFA *nfa, u64a offset,
return !(*s & SHENG_STATE_DEAD); 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); assert(nfa->scratchStateSize == 1);
/* starting in floating state */ /* starting in floating state */
@ -654,7 +653,7 @@ char nfaExecSheng0_queueInitState(const struct NFA *nfa, struct mq *q) {
return 0; return 0;
} }
char nfaExecSheng0_queueCompressState(UNUSED const struct NFA *nfa, char nfaExecSheng_queueCompressState(UNUSED const struct NFA *nfa,
const struct mq *q, UNUSED s64a loc) { const struct mq *q, UNUSED s64a loc) {
void *dest = q->streamState; void *dest = q->streamState;
const void *src = q->state; const void *src = q->state;
@ -664,7 +663,7 @@ char nfaExecSheng0_queueCompressState(UNUSED const struct NFA *nfa,
return 0; return 0;
} }
char nfaExecSheng0_expandState(UNUSED const struct NFA *nfa, void *dest, char nfaExecSheng_expandState(UNUSED const struct NFA *nfa, void *dest,
const void *src, UNUSED u64a offset, const void *src, UNUSED u64a offset,
UNUSED u8 key) { UNUSED u8 key) {
assert(nfa->scratchStateSize == 1); assert(nfa->scratchStateSize == 1);

28
src/nfa/sheng.h
View File

@ -35,27 +35,27 @@
struct mq; struct mq;
struct NFA; struct NFA;
#define nfaExecSheng0_B_Reverse NFA_API_NO_IMPL #define nfaExecSheng_B_Reverse NFA_API_NO_IMPL
#define nfaExecSheng0_zombie_status NFA_API_ZOMBIE_NO_IMPL #define nfaExecSheng_zombie_status NFA_API_ZOMBIE_NO_IMPL
char nfaExecSheng0_Q(const struct NFA *n, struct mq *q, s64a end); char nfaExecSheng_Q(const struct NFA *n, struct mq *q, s64a end);
char nfaExecSheng0_Q2(const struct NFA *n, struct mq *q, s64a end); char nfaExecSheng_Q2(const struct NFA *n, struct mq *q, s64a end);
char nfaExecSheng0_QR(const struct NFA *n, struct mq *q, ReportID report); char nfaExecSheng_QR(const struct NFA *n, struct mq *q, ReportID report);
char nfaExecSheng0_inAccept(const struct NFA *n, ReportID report, struct mq *q); char nfaExecSheng_inAccept(const struct NFA *n, ReportID report, struct mq *q);
char nfaExecSheng0_inAnyAccept(const struct NFA *n, struct mq *q); char nfaExecSheng_inAnyAccept(const struct NFA *n, struct mq *q);
char nfaExecSheng0_queueInitState(const struct NFA *nfa, struct mq *q); char nfaExecSheng_queueInitState(const struct NFA *nfa, struct mq *q);
char nfaExecSheng0_queueCompressState(const struct NFA *nfa, const struct mq *q, char nfaExecSheng_queueCompressState(const struct NFA *nfa, const struct mq *q,
s64a loc); s64a loc);
char nfaExecSheng0_expandState(const struct NFA *nfa, void *dest, char nfaExecSheng_expandState(const struct NFA *nfa, void *dest,
const void *src, u64a offset, u8 key); const void *src, u64a offset, u8 key);
char nfaExecSheng0_initCompressedState(const struct NFA *nfa, u64a offset, char nfaExecSheng_initCompressedState(const struct NFA *nfa, u64a offset,
void *state, u8 key); void *state, u8 key);
char nfaExecSheng0_testEOD(const struct NFA *nfa, const char *state, char nfaExecSheng_testEOD(const struct NFA *nfa, const char *state,
const char *streamState, u64a offset, const char *streamState, u64a offset,
NfaCallback callback, void *context); NfaCallback callback, void *context);
char nfaExecSheng0_reportCurrent(const struct NFA *n, struct mq *q); 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); size_t length, NfaCallback cb, void *context);
#endif /* SHENG_H_ */ #endif /* SHENG_H_ */

2
src/nfa/shengcompile.cpp
View File

@ -358,7 +358,7 @@ void populateBasicInfo(struct NFA *n, dfa_info &info,
n->scratchStateSize = 1; n->scratchStateSize = 1;
n->streamStateSize = 1; n->streamStateSize = 1;
n->nPositions = info.size(); n->nPositions = info.size();
n->type = SHENG_NFA_0; n->type = SHENG_NFA;
n->flags |= info.raw.hasEodReports() ? NFA_ACCEPTS_EOD : 0; n->flags |= info.raw.hasEodReports() ? NFA_ACCEPTS_EOD : 0;
sheng *s = (sheng *)getMutableImplNfa(n); sheng *s = (sheng *)getMutableImplNfa(n);

8
src/nfa/shengdump.cpp
View File

@ -115,8 +115,8 @@ void dumpMasks(FILE *f, const sheng *s) {
} }
} }
void nfaExecSheng0_dumpText(const NFA *nfa, FILE *f) { void nfaExecSheng_dumpText(const NFA *nfa, FILE *f) {
assert(nfa->type == SHENG_NFA_0); assert(nfa->type == SHENG_NFA);
const sheng *s = (const sheng *)getImplNfa(nfa); const sheng *s = (const sheng *)getImplNfa(nfa);
fprintf(f, "sheng DFA\n"); 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; t[TOP] = aux->top & SHENG_STATE_MASK;
} }
void nfaExecSheng0_dumpDot(const NFA *nfa, FILE *f, const string &) { void nfaExecSheng_dumpDot(const NFA *nfa, FILE *f, const string &) {
assert(nfa->type == SHENG_NFA_0); assert(nfa->type == SHENG_NFA);
const sheng *s = (const sheng *)getImplNfa(nfa); const sheng *s = (const sheng *)getImplNfa(nfa);
dumpDotPreambleDfa(f); dumpDotPreambleDfa(f);

4
src/nfa/shengdump.h
View File

@ -38,9 +38,9 @@ struct NFA;
namespace ue2 { namespace ue2 {
void nfaExecSheng0_dumpDot(const struct NFA *nfa, FILE *file, void nfaExecSheng_dumpDot(const struct NFA *nfa, FILE *file,
const std::string &base); const std::string &base);
void nfaExecSheng0_dumpText(const struct NFA *nfa, FILE *file); void nfaExecSheng_dumpText(const struct NFA *nfa, FILE *file);
} // namespace ue2 } // namespace ue2

26
src/nfa/tamarama.c
View File

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

27
src/nfa/tamarama.h
View File

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

4
src/nfa/tamarama_dump.cpp
View File

@ -48,7 +48,7 @@
namespace ue2 { namespace ue2 {
void nfaExecTamarama0_dumpDot(const struct NFA *nfa, UNUSED FILE *f, void nfaExecTamarama_dumpDot(const struct NFA *nfa, UNUSED FILE *f,
const std::string &base) { const std::string &base) {
const Tamarama *t = (const Tamarama *)getImplNfa(nfa); const Tamarama *t = (const Tamarama *)getImplNfa(nfa);
const u32 *subOffset = const u32 *subOffset =
@ -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); const Tamarama *t = (const Tamarama *)getImplNfa(nfa);
fprintf(f, "Tamarama container engine\n"); fprintf(f, "Tamarama container engine\n");

4
src/nfa/tamarama_dump.h
View File

@ -38,9 +38,9 @@ struct NFA;
namespace ue2 { namespace ue2 {
void nfaExecTamarama0_dumpDot(const NFA *nfa, FILE *file, void nfaExecTamarama_dumpDot(const NFA *nfa, FILE *file,
const std::string &base); const std::string &base);
void nfaExecTamarama0_dumpText(const NFA *nfa, FILE *file); void nfaExecTamarama_dumpText(const NFA *nfa, FILE *file);
} // namespace ue2 } // namespace ue2

2
src/nfa/tamaramacompile.cpp
View File

@ -134,7 +134,7 @@ aligned_unique_ptr<NFA> buildTamarama(const TamaInfo &tamaInfo, const u32 queue,
// so add one to subSize here // so add one to subSize here
u32 activeIdxSize = calcPackedBytes(subSize + 1); u32 activeIdxSize = calcPackedBytes(subSize + 1);
aligned_unique_ptr<NFA> nfa = aligned_zmalloc_unique<NFA>(total_size); 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->length = verify_u32(total_size);
nfa->queueIndex = queue; nfa->queueIndex = queue;

17
src/nfagraph/ng_lbr.cpp
View File

@ -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 * Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met: * 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, enum RepeatType rtype = chooseRepeatType(repeatMin, repeatMax, minPeriod,
is_reset); is_reset);
aligned_unique_ptr<NFA> nfa auto nfa = makeLbrNfa<lbr_dot>(LBR_NFA_DOT, rtype, repeatMax);
= makeLbrNfa<lbr_dot>(LBR_NFA_Dot, rtype, repeatMax);
struct lbr_dot *ld = (struct lbr_dot *)getMutableImplNfa(nfa.get()); struct lbr_dot *ld = (struct lbr_dot *)getMutableImplNfa(nfa.get());
fillNfa<lbr_dot>(nfa.get(), &ld->common, report, repeatMin, repeatMax, 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, enum RepeatType rtype = chooseRepeatType(repeatMin, repeatMax, minPeriod,
is_reset); is_reset);
aligned_unique_ptr<NFA> nfa auto nfa = makeLbrNfa<lbr_verm>(LBR_NFA_VERM, rtype, repeatMax);
= makeLbrNfa<lbr_verm>(LBR_NFA_Verm, rtype, repeatMax);
struct lbr_verm *lv = (struct lbr_verm *)getMutableImplNfa(nfa.get()); struct lbr_verm *lv = (struct lbr_verm *)getMutableImplNfa(nfa.get());
lv->c = escapes.find_first(); lv->c = escapes.find_first();
@ -202,8 +200,7 @@ aligned_unique_ptr<NFA> buildLbrNVerm(const CharReach &cr,
enum RepeatType rtype = chooseRepeatType(repeatMin, repeatMax, minPeriod, enum RepeatType rtype = chooseRepeatType(repeatMin, repeatMax, minPeriod,
is_reset); is_reset);
aligned_unique_ptr<NFA> nfa auto nfa = makeLbrNfa<lbr_verm>(LBR_NFA_NVERM, rtype, repeatMax);
= makeLbrNfa<lbr_verm>(LBR_NFA_NVerm, rtype, repeatMax);
struct lbr_verm *lv = (struct lbr_verm *)getMutableImplNfa(nfa.get()); struct lbr_verm *lv = (struct lbr_verm *)getMutableImplNfa(nfa.get());
lv->c = escapes.find_first(); lv->c = escapes.find_first();
@ -221,8 +218,7 @@ aligned_unique_ptr<NFA> buildLbrShuf(const CharReach &cr,
bool is_reset, ReportID report) { bool is_reset, ReportID report) {
enum RepeatType rtype = chooseRepeatType(repeatMin, repeatMax, minPeriod, enum RepeatType rtype = chooseRepeatType(repeatMin, repeatMax, minPeriod,
is_reset); is_reset);
aligned_unique_ptr<NFA> nfa auto nfa = makeLbrNfa<lbr_shuf>(LBR_NFA_SHUF, rtype, repeatMax);
= makeLbrNfa<lbr_shuf>(LBR_NFA_Shuf, rtype, repeatMax);
struct lbr_shuf *ls = (struct lbr_shuf *)getMutableImplNfa(nfa.get()); struct lbr_shuf *ls = (struct lbr_shuf *)getMutableImplNfa(nfa.get());
fillNfa<lbr_shuf>(nfa.get(), &ls->common, report, repeatMin, repeatMax, 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) { bool is_reset, ReportID report) {
enum RepeatType rtype = chooseRepeatType(repeatMin, repeatMax, minPeriod, enum RepeatType rtype = chooseRepeatType(repeatMin, repeatMax, minPeriod,
is_reset); is_reset);
aligned_unique_ptr<NFA> nfa auto nfa = makeLbrNfa<lbr_truf>(LBR_NFA_TRUF, rtype, repeatMax);
= makeLbrNfa<lbr_truf>(LBR_NFA_Truf, rtype, repeatMax);
struct lbr_truf *lc = (struct lbr_truf *)getMutableImplNfa(nfa.get()); struct lbr_truf *lc = (struct lbr_truf *)getMutableImplNfa(nfa.get());
fillNfa<lbr_truf>(nfa.get(), &lc->common, report, repeatMin, repeatMax, fillNfa<lbr_truf>(nfa.get(), &lc->common, report, repeatMin, repeatMax,

4
src/rose/catchup.c
View File

@ -401,7 +401,7 @@ hwlmcb_rv_t roseCatchUpMPV_i(const struct RoseEngine *t, s64a loc,
scratch->tctxt.mpv_inactive = 0; scratch->tctxt.mpv_inactive = 0;
/* we know it is going to be an mpv, skip the indirection */ /* 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); assert(!q->report_current);
if (!next_pos_match_loc) { /* 0 means dead */ 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; const struct RoseContext *tctxt = &scratch->tctxt;
assert(tctxt->curr_qi < rose->queueCount); assert(tctxt->curr_qi < rose->queueCount);
if (tctxt->curr_qi < rose->outfixBeginQueue) { 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 1;
} }
return 0; return 0;

4
src/runtime.c
View File

@ -291,11 +291,11 @@ void runSmallWriteEngine(const struct SmallWriteEngine *smwr,
if (nfa->type == MCCLELLAN_NFA_8) { if (nfa->type == MCCLELLAN_NFA_8) {
nfaExecMcClellan8_B(nfa, smwr->start_offset, local_buffer, nfaExecMcClellan8_B(nfa, smwr->start_offset, local_buffer,
local_alen, roseReportAdaptor, scratch); 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, nfaExecMcClellan16_B(nfa, smwr->start_offset, local_buffer,
local_alen, roseReportAdaptor, scratch); local_alen, roseReportAdaptor, scratch);
} else { } else {
nfaExecSheng0_B(nfa, smwr->start_offset, local_buffer, nfaExecSheng_B(nfa, smwr->start_offset, local_buffer,
local_alen, roseReportAdaptor, scratch); local_alen, roseReportAdaptor, scratch);
} }
} }