Rename reduceQueue to reduceInfixQueue

Use rose_inline rather than really_inline

roseTestLeftfix: unify common "nfa is dead" code

Add CATCH_UP to report_block, not "parent" program

Also ensure that exhaustion check happens after catch up, as catch up
may fire reports (which could exhaust).

limex_runtime.h: scratch header no longer needed

Remove more unused structures from unit tests

The NFA, LBR no longer need scratch or the NFAContext structure stored
outside the NFA stack.

NFA API: Remove unused scratch ptr from struct mq

NFA API: Remove nfaBlockExecReverse scratch arg

Scratch is no longer used by this function's implementations.

NFA: Move NFAContext to stack (from scratch)

Rose: allow block-mode merge of small prefixes

Previously, we disallowed the merging of all Rose prefixes in block mode
where the literal sets are not identical.

This change allows merging if the prefix graphs to be merged are very
small, as a small performance improvement for cases with lots of tiny
prefixes.

This check is deliberately conservative: graphs must have some common
vertices, and the result of the merge must not give up any
accelerability.

NFA merging: permit different reports

For cases where the edges from start are not to a mix of accept and
acceptEod, report sets can be combined.

Dump: don't call dumpNfaNotes for SOM reverse NFAs

These NFAs have no queue index.

SET_GROUPS instr: don't generate more than one

dedupeCatchup: only call when necessary at runtime

DEDUPE instr: generate only when necessary

Rose: clean up use of scratch, RoseContext

Rose: pack global state bits into one u8

Eliminate the RoseRuntimeState structure in favour of a single status
byte that is stored in scratch and copied to/from stream state.

Rose: remove alignment req for anchored DFA state

Rose: move more report handling work into program

Move report preconditions (bounds, exhaustion, etc) into program
instructions and use a more direct path to the user match callback than
the adaptor functions.

Report handling has been moved to new file src/report.h. Reporting from
EOD now uses the same instructions as normal report handling, rather
than its own.

Jump target tracking in rose_build_bytecode.cpp has been cleaned up.

ng_filter: Fix bug introduced in 98eff64

If the max width is modified for a region, use the modified version when
checking to see if a self-loop must be added on the last vertex.

RoseRuntimeState no longer needs to be packed

This structure only contains u8 values now. In the future we may wish to
eliminate it entirely and store the few bits we need more directly.

Docs for Rose callback types

Make Rose callback types explicitly take scratch

Remove RoseContext::userCtx

All Rose callbacks receive scratch as their context.

Move cyclic path redundancy into reduce loop

Sometimes cyclic path redundancy can uncover further reduction work that
can be done by the other passes in the reduce loop.

roseEodRunMatcher: correct early return value

nfaCheckFinalState: define return value

Make nfaCheckFinalState return MO_HALT_MATCHING when the user instructs
us (via the callback return value) to halt matching. In the caller,
check this value and stop matching if told.

Don't look for accel friends for multibyte acceleration

scratch: correctly align fatbit arrays

This fixes an assertion failure on 32-bit targets.

Use fatbit for anch log, delay slots in scratch

Since these structures are in scratch, they do not have to be as small
as possible and we can use fatbit instead of multibit to improve
performance.

rose_build_anchored: take ref, not pointer

Account for multi-dfa case with ANCHORED_DELAY

Specifically, we must set build_context::floatingMinLiteralMatchOffset
to 1 when thew anchored table contains multiple DFAs, as they can
produce unordered matches.

This check was already been done, but too late to affect the generation
of ANCHORED_DELAY instructions.

Use correct type for anchored matcher build

Fix release build (unused var)

Remove dupe engine, state ptrs from RoseContext

Remove the RoseEngine and stream state pointers frose RoseContext, as
they are also present in core_info.

Unify stream state handing in Rose to always use a char * (we were often
a u8 * for no particularly good reason) and tidy up.

Coverity: Restore output stream format

Rose: Move all literal operations into program

Replace the RoseLiteral structure with more program instructions; now,
instead of each literal ID leading to a RoseLiteral, it simply has a
program to run (and a delay rebuild program).

This commit also makes some other improvements:

 * CHECK_STATE instruction, for use instead of a sparse iterator over a
   single element.
 * Elide some checks (CHECK_LIT_EARLY, ANCHORED_DELAY, etc) when not
   needed.
 * Flatten PUSH_DELAYED behaviour to one instruction per delayed
   literal, rather than the mask/index-list approach used before.
 * Simple program cache at compile time for deduplication.

squashing: prevent generation of pairs of squash states

alignof() should operate on a type-id

Delete unused build_context::depths

Remove use of depth from Rose entirely

Don't use depth for in-flight check

Remove CHECK_DEPTH instruction

Remove "dot" entries from leftfix lookarounds

Note that we have to be careful to leave the first lookaround entry in
place, if it's a dot. This should eventually be done with a program
instruction.

ComponentRepeat: remove firsts_cache, precalc code

Firsts are easy to compute in ComponentRepeat::first() now.

ComponentRepeat: wire X{0,N} and (X?){N} the same

ComponentRepeat: wire R{0,N} as (R{1,N})?

Change the way that we wire up the edges in a bounded repeat to avoid
large fan-out from predecessors.

ng_prefilter: turn large max bound into inf

During prefilter region replacement, turn regions with very large max
bounds into repeats with inf max bound. This improves compile time and
the likelihood that we will actually be able to build an implementation
for such patterns.

Multibyte matcher unit-tests

Bitmatcher unit-tests

Multibyte acceleration compile side

Multibyte truffle runtime

Multibyte shufti runtime

Multibyte vermicelli runtime

Adding bitmatchers

Adding AVX2 version of truffle

scratch: remove sparse iter state (now unused)

roseRunProgram: iter state on stack

roseCatchUpLeftfixes: iter state on stack

roseBlockHasEodWork: iter state on stack

roseFlushLastByteHistory: iter state on stack

roseCheckNfaEod: use sparse iterator for EOD

Rather than checking all active outfix/suffix engines, use a sparse
iterator to check only those engines that accept at EOD.

runtime: hoist broken check in streaming mode

Build the tools dir only if the cmake file exists

writeEodProgram: avoid make_move_iterator warning

Avoid an ambiguity between std:: and boost::make_move_iterator on builds
against libc++.

rose: Extend program to handle literals, iterators

- cleanups
- add sparse iter instructions
- merge "root" and "sparse iter" programs together
- move program execution to new file program_runtime.h
- simplify EOD execution

make_disjoint: Remove dead code

convertAnchPrefixToBounds: check size of delay_adj

Avoid subtracting delay_adj from a smaller max bound.

Perform an early removeRedundancy call on graph

This allows sibling character classes to be merged together before graph
component splitting is done by calcComponents().

In particular, this transforms (A|a)(B|b)(C|c) into [Aa][Bb][Cc]
earlier.

Remove dead code: EdgeSourceStateCompare

rose: Extend the interpreter to handle more work

- Use program for EOD sparse iterator
- Use program for literal sparse iterator
- Eliminate RoseRole, RosePred, RoseVertexProps::role
- Small performance optimizations

rose: Use an interpreter for role runtime

Replace much of the RoseRole structure with an interpreted program,
simplifying the Rose runtime and making it much more flexible.

detach the sidecar

make nfaExecCastle0_QR() more efficent

1. Reverse scan for the last escape and only process later events.
2. Only scheck subcastles which may expire for staleness

Rework literal overlap checks for merging engines

Also increase the size of chunks we consider merging for castles.

Introduce REPEAT_ALWAYS model for {0,} castle repeats
As Castle guards the repeats, no more state is needed for these repeats

Allow lag on castle infixes to be reduced
Reducing lag allows for castles to be merged more effectively

Use add_edge_if_not_present in somMayGoBackwards()

As somMayGoBackwards() operates on a copy of the graph where virtual
starts have been collapsed on to startDs, we need to be careful not to
create parallel edges.

Merge branch develop into master

Bump version number

Small updates to documentation for 4.1

Add ChangeLog

simplify max clique analysis

Add per-top findMinWidth etc for NFA graphs

CastleProto: track next top explicitly

Repeats may be removed (e.g. by pruning in role aliasing passes)
leaving "holes" in the top map. Track the next top to use explicitly,
rather than using repeats.size().

CastleProto: track mapping of reports to tops

This allows us to speed up report-based queries, like dedupe checking.

assignDkeys: use flat_set<ReportID>, not set

findMinWidth, findMaxWidth: width for a given top

Currently only implemented for Castle suffixes.

RoseDedupeAuxImpl: collect unique suffixes first

role aliasing: simplify hashRightRoleProperties

Using the full report set for a suffix as an input to this hash was very
slow at scale.

castle: simplify find_next_top

Tops are no longer sparse in CastleProto, so the linear scan for holes
isn't necessary.

Make key 64 bits where large shifts may be used.

This fixes a long-standing issue with large multibit structures.

PCRE includes U+180E in /[:print:]/8W

Update defn of class [:punct:] for PCRE 8.38

Unify handling of caseless flag in class parser

Apply caselessness to each element added to a class, rather than all at
finalize time (which required separated ucp dnf and-ucp working data).

Unifies the behaviour of AsciiComponentClass and Utf8ComponentClass in
this respect.

Fix defn of POSIX graph, print, punct classes

The POSIX classes [:graph:], [:print:] and [:punct:] are handled
specially in UCP mode by PCRE. This change matches that behaviour.

FDR runtime simplification

Removed static specialisation of domains.

ng_execute: update interface to use flat_set

This changes all the execute_graph() interfaces so that instead of
mutating a std::set of vertices, they accept an initial flat_set of
states and return a resultant flat_set of states after execution.

(Note that internally execute_graph() still uses bitsets)

This is both faster and more flexible.

Restore \Q..\E support in character classes

Introduce copy_bytes for writing into bytecode

Protects memcpy from nullptr sources, which triggers failures in GCC's
UB sanitizer.