Restoring authorship annotation for Ivan Blinkov <ivan@blinkov.ru>. Commit 1 of 2.

1 files changed, 230 insertions, 230 deletions

diff --git a/contrib/libs/hyperscan/src/rose/block.c b/contrib/libs/hyperscan/src/rose/block.c
index b3f424cb73..9148ecb8ff 100644
--- a/contrib/libs/hyperscan/src/rose/block.c
+++ b/contrib/libs/hyperscan/src/rose/block.c
@@ -29,9 +29,9 @@
 #include "catchup.h"
 #include "init.h"
 #include "match.h"
-#include "program_runtime.h"
-#include "rose.h"
-#include "rose_common.h"
+#include "program_runtime.h" 
+#include "rose.h" 
+#include "rose_common.h" 
 #include "nfa/nfa_api.h"
 #include "nfa/nfa_internal.h"
 #include "nfa/nfa_rev_api.h"
@@ -62,11 +62,11 @@ void runAnchoredTableBlock(const struct RoseEngine *t, const void *atable,
             if (nfa->type == MCCLELLAN_NFA_8) {
                 nfaExecMcClellan8_B(nfa, curr->anchoredMinDistance,
                                     local_buffer, local_alen,
-                                    roseAnchoredCallback, scratch);
+                                    roseAnchoredCallback, scratch); 
             } else {
                 nfaExecMcClellan16_B(nfa, curr->anchoredMinDistance,
                                      local_buffer, local_alen,
-                                     roseAnchoredCallback, scratch);
+                                     roseAnchoredCallback, scratch); 
             }
         }
 
@@ -79,12 +79,12 @@ void runAnchoredTableBlock(const struct RoseEngine *t, const void *atable,
 }
 
 static really_inline
-void init_state_for_block(const struct RoseEngine *t, char *state) {
+void init_state_for_block(const struct RoseEngine *t, char *state) { 
     assert(t);
     assert(state);
 
-    DEBUG_PRINTF("init for Rose %p with %u state indices\n", t,
-                 t->rolesWithStateCount);
+    DEBUG_PRINTF("init for Rose %p with %u state indices\n", t, 
+                 t->rolesWithStateCount); 
 
     // Rose is guaranteed 8-aligned state
     assert(ISALIGNED_N(state, 8));
@@ -94,7 +94,7 @@ void init_state_for_block(const struct RoseEngine *t, char *state) {
 
 static really_inline
 void init_outfixes_for_block(const struct RoseEngine *t,
-                             struct hs_scratch *scratch, char *state,
+                             struct hs_scratch *scratch, char *state, 
                              char is_small_block) {
     /* active leaf array has been cleared by the init scatter */
 
@@ -114,7 +114,7 @@ void init_outfixes_for_block(const struct RoseEngine *t,
             fatbit_set(scratch->aqa, qCount, 0);
 
             struct mq *q = scratch->queues;
-            initQueue(q, 0, t, scratch);
+            initQueue(q, 0, t, scratch); 
             q->length = len; /* adjust for rev_accel */
             nfaQueueInitState(nfa, q);
             pushQueueAt(q, 0, MQE_START, 0);
@@ -134,7 +134,7 @@ void init_outfixes_for_block(const struct RoseEngine *t,
 
 static really_inline
 void init_for_block(const struct RoseEngine *t, struct hs_scratch *scratch,
-                    char *state, char is_small_block) {
+                    char *state, char is_small_block) { 
     init_state_for_block(t, state);
 
     struct RoseContext *tctxt = &scratch->tctxt;
@@ -159,211 +159,211 @@ void init_for_block(const struct RoseEngine *t, struct hs_scratch *scratch,
     init_outfixes_for_block(t, scratch, state, is_small_block);
 }
 
-static rose_inline
-void roseBlockEodExec(const struct RoseEngine *t, u64a offset,
-                      struct hs_scratch *scratch) {
-    assert(t->requiresEodCheck);
-    assert(t->maxBiAnchoredWidth == ROSE_BOUND_INF
-           || offset <= t->maxBiAnchoredWidth);
-
-    assert(!can_stop_matching(scratch));
-    assert(t->eodProgramOffset);
-
-    // Ensure that history is correct before we look for EOD matches.
-    roseFlushLastByteHistory(t, scratch, offset);
-    scratch->tctxt.lastEndOffset = offset;
-
-    DEBUG_PRINTF("running eod program at %u\n", t->eodProgramOffset);
-
-    // There should be no pending delayed literals.
-    assert(!scratch->tctxt.filledDelayedSlots);
-
-    const u64a som = 0;
-    const u8 flags = ROSE_PROG_FLAG_SKIP_MPV_CATCHUP;
-
-    // Note: we ignore the result, as this is the last thing to ever happen on
-    // a scan.
-    roseRunProgram(t, scratch, t->eodProgramOffset, som, offset, flags);
-}
-
-/**
- * \brief Run the anchored matcher, if any. Returns non-zero if matching should
- * halt.
- */
-static rose_inline
-int roseBlockAnchored(const struct RoseEngine *t, struct hs_scratch *scratch) {
-    const void *atable = getALiteralMatcher(t);
-    if (!atable) {
-        DEBUG_PRINTF("no anchored table\n");
-        return 0;
-    }
-
-    const size_t length = scratch->core_info.len;
-
-    if (t->amatcherMaxBiAnchoredWidth != ROSE_BOUND_INF &&
-        length > t->amatcherMaxBiAnchoredWidth) {
-        return 0;
-    }
-
-    if (length < t->amatcherMinWidth) {
-        return 0;
-    }
-
-    runAnchoredTableBlock(t, atable, scratch);
-
-    return can_stop_matching(scratch);
-}
-
-/**
- * \brief Run the floating matcher, if any. Returns non-zero if matching should
- * halt.
- */
-static rose_inline
-int roseBlockFloating(const struct RoseEngine *t, struct hs_scratch *scratch) {
-    const struct HWLM *ftable = getFLiteralMatcher(t);
-    if (!ftable) {
-        return 0;
-    }
-
-    const size_t length = scratch->core_info.len;
-    char *state = scratch->core_info.state;
-    struct RoseContext *tctxt = &scratch->tctxt;
-
-    DEBUG_PRINTF("ftable fd=%u fmd %u\n", t->floatingDistance,
-                 t->floatingMinDistance);
-    if (t->noFloatingRoots && !roseHasInFlightMatches(t, state, scratch)) {
-        DEBUG_PRINTF("skip FLOATING: no inflight matches\n");
-        return 0;
-    }
-
-    if (t->fmatcherMaxBiAnchoredWidth != ROSE_BOUND_INF &&
-        length > t->fmatcherMaxBiAnchoredWidth) {
-        return 0;
-    }
-
-    if (length < t->fmatcherMinWidth) {
-        return 0;
-    }
-
-    const u8 *buffer = scratch->core_info.buf;
-    size_t flen = length;
-    if (t->floatingDistance != ROSE_BOUND_INF) {
-        flen = MIN(t->floatingDistance, length);
-    }
-    if (flen <= t->floatingMinDistance) {
-        return 0;
-    }
-
-    DEBUG_PRINTF("BEGIN FLOATING (over %zu/%zu)\n", flen, length);
-    DEBUG_PRINTF("-- %016llx\n", tctxt->groups);
-    hwlmExec(ftable, buffer, flen, t->floatingMinDistance, roseFloatingCallback,
-             scratch, tctxt->groups & t->floating_group_mask);
-
-    return can_stop_matching(scratch);
-}
-
-static rose_inline
-void runEagerPrefixesBlock(const struct RoseEngine *t,
-                           struct hs_scratch *scratch) {
-    if (!t->eagerIterOffset) {
-        return;
-    }
-
-    char *state = scratch->core_info.state;
-    u8 *ara = getActiveLeftArray(t, state); /* indexed by offsets into
-                                             * left_table */
-    const u32 arCount = t->activeLeftCount;
-    const u32 qCount = t->queueCount;
-    const struct LeftNfaInfo *left_table = getLeftTable(t);
-    const struct mmbit_sparse_iter *it = getByOffset(t, t->eagerIterOffset);
-
-    struct mmbit_sparse_state si_state[MAX_SPARSE_ITER_STATES];
-
-    u32 idx = 0;
-    u32 ri = mmbit_sparse_iter_begin(ara, arCount, &idx, it, si_state);
-    for (; ri != MMB_INVALID;
-           ri = mmbit_sparse_iter_next(ara, arCount, ri, &idx, it, si_state)) {
-        const struct LeftNfaInfo *left = left_table + ri;
-        u32 qi = ri + t->leftfixBeginQueue;
-        DEBUG_PRINTF("leftfix %u/%u, maxLag=%u\n", ri, arCount, left->maxLag);
-
-        assert(!fatbit_isset(scratch->aqa, qCount, qi));
-        assert(left->eager);
-        assert(!left->infix);
-
-        struct mq *q = scratch->queues + qi;
-        const struct NFA *nfa = getNfaByQueue(t, qi);
-
-        if (scratch->core_info.len < nfa->minWidth) {
-            /* we know that there is not enough data for this to ever match, so
-             * we can immediately squash/ */
-            mmbit_unset(ara, arCount, ri);
-            scratch->tctxt.groups &= left->squash_mask;
-        }
-
-        s64a loc = MIN(scratch->core_info.len, EAGER_STOP_OFFSET);
-
-        fatbit_set(scratch->aqa, qCount, qi);
-        initRoseQueue(t, qi, left, scratch);
-
-        pushQueueAt(q, 0, MQE_START, 0);
-        pushQueueAt(q, 1, MQE_TOP, 0);
-        pushQueueAt(q, 2, MQE_END, loc);
-        nfaQueueInitState(nfa, q);
-
-        char alive = nfaQueueExecToMatch(q->nfa, q, loc);
-
-        if (!alive) {
-            DEBUG_PRINTF("queue %u dead, squashing\n", qi);
-            mmbit_unset(ara, arCount, ri);
-            fatbit_unset(scratch->aqa, qCount, qi);
-            scratch->tctxt.groups &= left->squash_mask;
-        } else if (q->cur == q->end) {
-            assert(alive != MO_MATCHES_PENDING);
-            if (loc == (s64a)scratch->core_info.len) {
-                /* We know that the prefix does not match in the block so we
-                 * can squash the groups anyway even though it did not die */
-                /* TODO: if we knew the minimum lag the leftfix is checked at we
-                 * could make this check tighter */
-                DEBUG_PRINTF("queue %u has no match in block, squashing\n", qi);
-                mmbit_unset(ara, arCount, ri);
-                fatbit_unset(scratch->aqa, qCount, qi);
-                scratch->tctxt.groups &= left->squash_mask;
-            } else {
-                DEBUG_PRINTF("queue %u finished, nfa lives\n", qi);
-                q->cur = q->end = 0;
-                pushQueueAt(q, 0, MQE_START, loc);
-            }
-        } else {
-            assert(alive == MO_MATCHES_PENDING);
-            DEBUG_PRINTF("queue %u unfinished, nfa lives\n", qi);
-            q->end--; /* remove end item */
-        }
-    }
-}
-
-void roseBlockExec(const struct RoseEngine *t, struct hs_scratch *scratch) {
+static rose_inline 
+void roseBlockEodExec(const struct RoseEngine *t, u64a offset, 
+                      struct hs_scratch *scratch) { 
+    assert(t->requiresEodCheck); 
+    assert(t->maxBiAnchoredWidth == ROSE_BOUND_INF 
+           || offset <= t->maxBiAnchoredWidth); 
+ 
+    assert(!can_stop_matching(scratch)); 
+    assert(t->eodProgramOffset); 
+ 
+    // Ensure that history is correct before we look for EOD matches. 
+    roseFlushLastByteHistory(t, scratch, offset); 
+    scratch->tctxt.lastEndOffset = offset; 
+ 
+    DEBUG_PRINTF("running eod program at %u\n", t->eodProgramOffset); 
+ 
+    // There should be no pending delayed literals. 
+    assert(!scratch->tctxt.filledDelayedSlots); 
+ 
+    const u64a som = 0; 
+    const u8 flags = ROSE_PROG_FLAG_SKIP_MPV_CATCHUP; 
+ 
+    // Note: we ignore the result, as this is the last thing to ever happen on 
+    // a scan. 
+    roseRunProgram(t, scratch, t->eodProgramOffset, som, offset, flags); 
+} 
+ 
+/** 
+ * \brief Run the anchored matcher, if any. Returns non-zero if matching should 
+ * halt. 
+ */ 
+static rose_inline 
+int roseBlockAnchored(const struct RoseEngine *t, struct hs_scratch *scratch) { 
+    const void *atable = getALiteralMatcher(t); 
+    if (!atable) { 
+        DEBUG_PRINTF("no anchored table\n"); 
+        return 0; 
+    } 
+ 
+    const size_t length = scratch->core_info.len; 
+ 
+    if (t->amatcherMaxBiAnchoredWidth != ROSE_BOUND_INF && 
+        length > t->amatcherMaxBiAnchoredWidth) { 
+        return 0; 
+    } 
+ 
+    if (length < t->amatcherMinWidth) { 
+        return 0; 
+    } 
+ 
+    runAnchoredTableBlock(t, atable, scratch); 
+ 
+    return can_stop_matching(scratch); 
+} 
+ 
+/** 
+ * \brief Run the floating matcher, if any. Returns non-zero if matching should 
+ * halt. 
+ */ 
+static rose_inline 
+int roseBlockFloating(const struct RoseEngine *t, struct hs_scratch *scratch) { 
+    const struct HWLM *ftable = getFLiteralMatcher(t); 
+    if (!ftable) { 
+        return 0; 
+    } 
+ 
+    const size_t length = scratch->core_info.len; 
+    char *state = scratch->core_info.state; 
+    struct RoseContext *tctxt = &scratch->tctxt; 
+ 
+    DEBUG_PRINTF("ftable fd=%u fmd %u\n", t->floatingDistance, 
+                 t->floatingMinDistance); 
+    if (t->noFloatingRoots && !roseHasInFlightMatches(t, state, scratch)) { 
+        DEBUG_PRINTF("skip FLOATING: no inflight matches\n"); 
+        return 0; 
+    } 
+ 
+    if (t->fmatcherMaxBiAnchoredWidth != ROSE_BOUND_INF && 
+        length > t->fmatcherMaxBiAnchoredWidth) { 
+        return 0; 
+    } 
+ 
+    if (length < t->fmatcherMinWidth) { 
+        return 0; 
+    } 
+ 
+    const u8 *buffer = scratch->core_info.buf; 
+    size_t flen = length; 
+    if (t->floatingDistance != ROSE_BOUND_INF) { 
+        flen = MIN(t->floatingDistance, length); 
+    } 
+    if (flen <= t->floatingMinDistance) { 
+        return 0; 
+    } 
+ 
+    DEBUG_PRINTF("BEGIN FLOATING (over %zu/%zu)\n", flen, length); 
+    DEBUG_PRINTF("-- %016llx\n", tctxt->groups); 
+    hwlmExec(ftable, buffer, flen, t->floatingMinDistance, roseFloatingCallback, 
+             scratch, tctxt->groups & t->floating_group_mask); 
+ 
+    return can_stop_matching(scratch); 
+} 
+ 
+static rose_inline 
+void runEagerPrefixesBlock(const struct RoseEngine *t, 
+                           struct hs_scratch *scratch) { 
+    if (!t->eagerIterOffset) { 
+        return; 
+    } 
+ 
+    char *state = scratch->core_info.state; 
+    u8 *ara = getActiveLeftArray(t, state); /* indexed by offsets into 
+                                             * left_table */ 
+    const u32 arCount = t->activeLeftCount; 
+    const u32 qCount = t->queueCount; 
+    const struct LeftNfaInfo *left_table = getLeftTable(t); 
+    const struct mmbit_sparse_iter *it = getByOffset(t, t->eagerIterOffset); 
+ 
+    struct mmbit_sparse_state si_state[MAX_SPARSE_ITER_STATES]; 
+ 
+    u32 idx = 0; 
+    u32 ri = mmbit_sparse_iter_begin(ara, arCount, &idx, it, si_state); 
+    for (; ri != MMB_INVALID; 
+           ri = mmbit_sparse_iter_next(ara, arCount, ri, &idx, it, si_state)) { 
+        const struct LeftNfaInfo *left = left_table + ri; 
+        u32 qi = ri + t->leftfixBeginQueue; 
+        DEBUG_PRINTF("leftfix %u/%u, maxLag=%u\n", ri, arCount, left->maxLag); 
+ 
+        assert(!fatbit_isset(scratch->aqa, qCount, qi)); 
+        assert(left->eager); 
+        assert(!left->infix); 
+ 
+        struct mq *q = scratch->queues + qi; 
+        const struct NFA *nfa = getNfaByQueue(t, qi); 
+ 
+        if (scratch->core_info.len < nfa->minWidth) { 
+            /* we know that there is not enough data for this to ever match, so 
+             * we can immediately squash/ */ 
+            mmbit_unset(ara, arCount, ri); 
+            scratch->tctxt.groups &= left->squash_mask; 
+        } 
+ 
+        s64a loc = MIN(scratch->core_info.len, EAGER_STOP_OFFSET); 
+ 
+        fatbit_set(scratch->aqa, qCount, qi); 
+        initRoseQueue(t, qi, left, scratch); 
+ 
+        pushQueueAt(q, 0, MQE_START, 0); 
+        pushQueueAt(q, 1, MQE_TOP, 0); 
+        pushQueueAt(q, 2, MQE_END, loc); 
+        nfaQueueInitState(nfa, q); 
+ 
+        char alive = nfaQueueExecToMatch(q->nfa, q, loc); 
+ 
+        if (!alive) { 
+            DEBUG_PRINTF("queue %u dead, squashing\n", qi); 
+            mmbit_unset(ara, arCount, ri); 
+            fatbit_unset(scratch->aqa, qCount, qi); 
+            scratch->tctxt.groups &= left->squash_mask; 
+        } else if (q->cur == q->end) { 
+            assert(alive != MO_MATCHES_PENDING); 
+            if (loc == (s64a)scratch->core_info.len) { 
+                /* We know that the prefix does not match in the block so we 
+                 * can squash the groups anyway even though it did not die */ 
+                /* TODO: if we knew the minimum lag the leftfix is checked at we 
+                 * could make this check tighter */ 
+                DEBUG_PRINTF("queue %u has no match in block, squashing\n", qi); 
+                mmbit_unset(ara, arCount, ri); 
+                fatbit_unset(scratch->aqa, qCount, qi); 
+                scratch->tctxt.groups &= left->squash_mask; 
+            } else { 
+                DEBUG_PRINTF("queue %u finished, nfa lives\n", qi); 
+                q->cur = q->end = 0; 
+                pushQueueAt(q, 0, MQE_START, loc); 
+            } 
+        } else { 
+            assert(alive == MO_MATCHES_PENDING); 
+            DEBUG_PRINTF("queue %u unfinished, nfa lives\n", qi); 
+            q->end--; /* remove end item */ 
+        } 
+    } 
+} 
+ 
+void roseBlockExec(const struct RoseEngine *t, struct hs_scratch *scratch) { 
     assert(t);
     assert(scratch);
     assert(scratch->core_info.buf);
     assert(mmbit_sparse_iter_state_size(t->rolesWithStateCount)
            < MAX_SPARSE_ITER_STATES);
 
-    // We should not have been called if we've already been told to terminate
-    // matching.
-    assert(!told_to_stop_matching(scratch));
-
-    // If this block is shorter than our minimum width, then no pattern in this
-    // RoseEngine could match.
-    /* minWidth checks should have already been performed by the caller */
-    assert(scratch->core_info.len >= t->minWidth);
-
-    // Similarly, we may have a maximum width (for engines constructed entirely
-    // of bi-anchored patterns).
-    /* This check is now handled by the interpreter */
-    assert(t->maxBiAnchoredWidth == ROSE_BOUND_INF
-           || scratch->core_info.len <= t->maxBiAnchoredWidth);
-
+    // We should not have been called if we've already been told to terminate 
+    // matching. 
+    assert(!told_to_stop_matching(scratch)); 
+ 
+    // If this block is shorter than our minimum width, then no pattern in this 
+    // RoseEngine could match. 
+    /* minWidth checks should have already been performed by the caller */ 
+    assert(scratch->core_info.len >= t->minWidth); 
+ 
+    // Similarly, we may have a maximum width (for engines constructed entirely 
+    // of bi-anchored patterns). 
+    /* This check is now handled by the interpreter */ 
+    assert(t->maxBiAnchoredWidth == ROSE_BOUND_INF 
+           || scratch->core_info.len <= t->maxBiAnchoredWidth); 
+ 
     const size_t length = scratch->core_info.len;
 
     // We have optimizations for small block scans: we run a single coalesced
@@ -373,9 +373,9 @@ void roseBlockExec(const struct RoseEngine *t, struct hs_scratch *scratch) {
     const char is_small_block =
         (length < ROSE_SMALL_BLOCK_LEN && t->sbmatcherOffset);
 
-    char *state = scratch->core_info.state;
+    char *state = scratch->core_info.state; 
 
-    init_for_block(t, scratch, state, is_small_block);
+    init_for_block(t, scratch, state, is_small_block); 
 
     struct RoseContext *tctxt = &scratch->tctxt;
 
@@ -388,35 +388,35 @@ void roseBlockExec(const struct RoseEngine *t, struct hs_scratch *scratch) {
         DEBUG_PRINTF("BEGIN SMALL BLOCK (over %zu/%zu)\n", sblen, length);
         DEBUG_PRINTF("-- %016llx\n", tctxt->groups);
         hwlmExec(sbtable, scratch->core_info.buf, sblen, 0, roseCallback,
-                 scratch, tctxt->groups);
-    } else {
-        runEagerPrefixesBlock(t, scratch);
+                 scratch, tctxt->groups); 
+    } else { 
+        runEagerPrefixesBlock(t, scratch); 
 
-        if (roseBlockAnchored(t, scratch)) {
-            return;
+        if (roseBlockAnchored(t, scratch)) { 
+            return; 
         }
-        if (roseBlockFloating(t, scratch)) {
-            return;
+        if (roseBlockFloating(t, scratch)) { 
+            return; 
         }
-    }
+    } 
 
-    if (cleanUpDelayed(t, scratch, length, 0) == HWLM_TERMINATE_MATCHING) {
-        return;
+    if (cleanUpDelayed(t, scratch, length, 0) == HWLM_TERMINATE_MATCHING) { 
+        return; 
     }
 
-    assert(!can_stop_matching(scratch));
+    assert(!can_stop_matching(scratch)); 
 
-    roseCatchUpTo(t, scratch, length);
+    roseCatchUpTo(t, scratch, length); 
 
-    if (!t->requiresEodCheck || !t->eodProgramOffset) {
-        DEBUG_PRINTF("no eod check required\n");
-        return;
+    if (!t->requiresEodCheck || !t->eodProgramOffset) { 
+        DEBUG_PRINTF("no eod check required\n"); 
+        return; 
     }
 
-    if (can_stop_matching(scratch)) {
-        DEBUG_PRINTF("bailing, already halted\n");
+    if (can_stop_matching(scratch)) { 
+        DEBUG_PRINTF("bailing, already halted\n"); 
         return;
     }
 
-    roseBlockEodExec(t, length, scratch);
+    roseBlockEodExec(t, length, scratch); 
 }