static really_inline
void init_stream(struct hs_stream *s, const struct RoseEngine *rose) {
s->rose = rose;
s->offset = 0;
u8 *state = (u8 *)getMultiState(s);
roseInitState(rose, state);
clearEvec((char *)state + rose->stateOffsets.exhausted, rose);
// SOM state multibit structures.
initSomState(rose, state);
}
static really_inline
void init_stream(struct hs_stream *s, const struct RoseEngine *rose) {
char *state = getMultiState(s);
// Make absolutely sure that the 16 bytes leading up to the end of the
// history buffer are initialised, as we rely on this (regardless of the
// actual values used) in FDR.
char *hist_end = state + rose->stateOffsets.history + rose->historyRequired;
assert(hist_end - 16 >= (const char *)s);
unaligned_store_u64a(hist_end - 16, 0xDEADDEADDEADDEADull);
unaligned_store_u64a(hist_end - 8, 0xDEADDEADDEADDEADull);
s->rose = rose;
s->offset = 0;
setStreamStatus(state, 0);
roseInitState(rose, state);
clearEvec(rose, state + rose->stateOffsets.exhausted);
// SOM state multibit structures.
initSomState(rose, state);
}
HS_PUBLIC_API
hs_error_t hs_scan(const hs_database_t *db, const char *data, unsigned length,
unsigned flags, hs_scratch_t *scratch,
match_event_handler onEvent, void *userCtx) {
if (unlikely(!scratch || !data)) {
return HS_INVALID;
}
hs_error_t err = validDatabase(db);
if (unlikely(err != HS_SUCCESS)) {
return err;
}
const struct RoseEngine *rose = hs_get_bytecode(db);
if (unlikely(!ISALIGNED_16(rose))) {
return HS_INVALID;
}
if (unlikely(rose->mode != HS_MODE_BLOCK)) {
return HS_DB_MODE_ERROR;
}
if (unlikely(!validScratch(rose, scratch))) {
return HS_INVALID;
}
if (rose->minWidth > length) {
DEBUG_PRINTF("minwidth=%u > length=%u\n", rose->minWidth, length);
return HS_SUCCESS;
}
prefetch_data(data, length);
/* populate core info in scratch */
populateCoreInfo(scratch, rose, scratch->bstate, onEvent, userCtx, data,
length, NULL, 0, 0, flags);
clearEvec(scratch->core_info.exhaustionVector, rose);
if (!length) {
if (rose->boundary.reportZeroEodOffset) {
processReportList(rose, rose->boundary.reportZeroEodOffset, 0,
scratch);
}
goto set_retval;
}
if (rose->boundary.reportZeroOffset) {
processReportList(rose, rose->boundary.reportZeroOffset, 0, scratch);
}
if (rose->minWidthExcludingBoundaries > length) {
DEBUG_PRINTF("minWidthExcludingBoundaries=%u > length=%u\n",
rose->minWidthExcludingBoundaries, length);
goto done_scan;
}
// Similarly, we may have a maximum width (for engines constructed entirely
// of bi-anchored patterns).
if (rose->maxBiAnchoredWidth != ROSE_BOUND_INF
&& length > rose->maxBiAnchoredWidth) {
DEBUG_PRINTF("block len=%u longer than maxBAWidth=%u\n", length,
rose->maxBiAnchoredWidth);
goto done_scan;
}
// Is this a small write case?
if (rose->smallWriteOffset) {
const struct SmallWriteEngine *smwr = getSmallWrite(rose);
assert(smwr);
// Apply the small write engine if and only if the block (buffer) is
// small enough. Otherwise, we allow rose &co to deal with it.
if (length < smwr->largestBuffer) {
DEBUG_PRINTF("Attempting small write of block %u bytes long.\n",
length);
runSmallWriteEngine(smwr, scratch);
goto done_scan;
}
}
switch (rose->runtimeImpl) {
default:
assert(0);
case ROSE_RUNTIME_FULL_ROSE:
rawBlockExec(rose, scratch);
break;
case ROSE_RUNTIME_PURE_LITERAL:
pureLiteralBlockExec(rose, scratch);
break;
case ROSE_RUNTIME_SINGLE_OUTFIX:
soleOutfixBlockExec(rose, scratch);
break;
}
done_scan:
if (told_to_stop_matching(scratch)) {
return HS_SCAN_TERMINATED;
}
if (rose->hasSom) {
int halt = flushStoredSomMatches(scratch, ~0ULL);
if (halt) {
return HS_SCAN_TERMINATED;
}
}
if (rose->boundary.reportEodOffset) {
processReportList(rose, rose->boundary.reportEodOffset, length, scratch);
}
set_retval:
DEBUG_PRINTF("done. told_to_stop_matching=%d\n",
told_to_stop_matching(scratch));
return told_to_stop_matching(scratch) ? HS_SCAN_TERMINATED : HS_SUCCESS;
}
