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

55
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
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);

34
src/nfa/castle.h
View File

@ -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
}

6
src/nfa/castle_dump.cpp
View File

@ -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");

5
src/nfa/castle_dump.h
View File

@ -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

2
src/nfa/castlecompile.cpp
View File

@ -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;

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 *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) {

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) {
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);

28
src/nfa/mpv.c
View File

@ -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);

34
src/nfa/mpv.h
View File

@ -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

6
src/nfa/mpv_dump.cpp
View File

@ -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");

6
src/nfa/mpv_dump.h
View File

@ -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

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->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;

52
src/nfa/nfa_api_dispatch.c
View File

@ -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,

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";
#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

54
src/nfa/nfa_dump_dispatch.cpp
View File

@ -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,

30
src/nfa/nfa_internal.h
View File

@ -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; \
})

43
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,
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;

38
src/nfa/sheng.h
View File

@ -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_ */

2
src/nfa/shengcompile.cpp
View File

@ -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);

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) {
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);

6
src/nfa/shengdump.h
View File

@ -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

36
src/nfa/tamarama.c
View File

@ -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;

39
src/nfa/tamarama.h
View File

@ -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
}

6
src/nfa/tamarama_dump.cpp
View File

@ -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");

6
src/nfa/tamarama_dump.h
View File

@ -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

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
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;

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
* 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,

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;
/* 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;

6
src/runtime.c
View File

@ -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);
}
}