internal BVAlgebraBase(MintermClassifier classifier, ulong[] cardinalities, BDD[]?partition)
{
_classifier = classifier;
_cardinalities = cardinalities;
_bits = cardinalities.Length;
_partition = partition;
}
public UInt64Solver(BDD[] minterms, CharSetSolver solver)
{
Debug.Assert(minterms.Length <= 64);
_minterms = minterms;
_classifier = new MintermClassifier(minterms, solver);
Full = minterms.Length == 64 ? ulong.MaxValue : ulong.MaxValue >> (64 - minterms.Length);
}
public BitVector64Algebra(CharSetSolver solver, BDD[] minterms)
{
Debug.Assert(minterms.Length <= 64);
_minterms = minterms;
_mintermGenerator = new MintermGenerator <ulong>(this);
_classifier = new MintermClassifier(solver, minterms);
True = minterms.Length == 64 ? ulong.MaxValue : ulong.MaxValue >> (64 - minterms.Length);
}
public UInt64Algebra(BDD[] minterms)
{
Debug.Assert(minterms.Length <= 64);
_minterms = minterms;
_mintermGenerator = new MintermGenerator <ulong>(this);
_classifier = new MintermClassifier(minterms);
True = minterms.Length == 64 ? ulong.MaxValue : ulong.MaxValue >> (64 - minterms.Length);
}
public BitVectorSolver(BDD[] minterms, CharSetSolver solver)
{
_minterms = minterms;
_classifier = new MintermClassifier(minterms, solver);
var singleBitVectors = new BitVector[minterms.Length];
for (int i = 0; i < singleBitVectors.Length; i++)
{
singleBitVectors[i] = BitVector.CreateSingleBit(minterms.Length, i);
}
_mintermVectors = singleBitVectors;
Empty = BitVector.CreateFalse(minterms.Length);
Full = BitVector.CreateTrue(minterms.Length);
}
public BitVectorAlgebra(CharSetSolver solver, BDD[] minterms)
{
_minterms = minterms;
_classifier = new MintermClassifier(solver, minterms);
_mintermGenerator = new MintermGenerator <BitVector>(this);
var singleBitVectors = new BitVector[minterms.Length];
for (int i = 0; i < singleBitVectors.Length; i++)
{
singleBitVectors[i] = BitVector.CreateSingleBit(minterms.Length, i);
}
_mintermVectors = singleBitVectors;
False = BitVector.CreateFalse(minterms.Length);
True = BitVector.CreateTrue(minterms.Length);
}
/// <summary>Constructs matcher for given symbolic regex.</summary>
internal SymbolicRegexMatcher(SymbolicRegexNode <TSetType> sr, RegexCode code, CharSetSolver css, BDD[] minterms, TimeSpan matchTimeout, CultureInfo culture)
{
Debug.Assert(sr._builder._solver is BV64Algebra or BVAlgebra or CharSetSolver, $"Unsupported algebra: {sr._builder._solver}");
_pattern = sr;
_builder = sr._builder;
_checkTimeout = Regex.InfiniteMatchTimeout != matchTimeout;
_timeout = (int)(matchTimeout.TotalMilliseconds + 0.5); // Round up, so it will be at least 1ms
_partitions = _builder._solver switch
{
BV64Algebra bv64 => bv64._classifier,
BVAlgebra bv => bv._classifier,
_ => new MintermClassifier((CharSetSolver)(object)_builder._solver, minterms),
};
if (code.FindOptimizations.FindMode != FindNextStartingPositionMode.NoSearch &&
code.FindOptimizations.LeadingAnchor == 0) // If there are any anchors, we're better off letting the DFA quickly do its job of determining whether there's a match.
{
_findOpts = code.FindOptimizations;
}
// Determine the number of initial states. If there's no anchor, only the default previous
// character kind 0 is ever going to be used for all initial states.
int statesCount = _pattern._info.ContainsSomeAnchor ? CharKind.CharKindCount : 1;
// Create the initial states for the original pattern.
var initialStates = new DfaMatchingState <TSetType> [statesCount];
for (uint i = 0; i < initialStates.Length; i++)
{
initialStates[i] = _builder.MkState(_pattern, i);
}
_initialStates = initialStates;
// Create the dot-star pattern (a concatenation of any* with the original pattern)
// and all of its initial states.
_dotStarredPattern = _builder.MkConcat(_builder._anyStar, _pattern);
var dotstarredInitialStates = new DfaMatchingState <TSetType> [statesCount];
for (uint i = 0; i < dotstarredInitialStates.Length; i++)
{
// Used to detect if initial state was reentered,
// but observe that the behavior from the state may ultimately depend on the previous
// input char e.g. possibly causing nullability of \b or \B or of a start-of-line anchor,
// in that sense there can be several "versions" (not more than StateCount) of the initial state.
DfaMatchingState <TSetType> state = _builder.MkState(_dotStarredPattern, i);
state.IsInitialState = true;
dotstarredInitialStates[i] = state;
}
_dotstarredInitialStates = dotstarredInitialStates;
// Create the reverse pattern (the original pattern in reverse order) and all of its
// initial states.
_reversePattern = _pattern.Reverse();
var reverseInitialStates = new DfaMatchingState <TSetType> [statesCount];
for (uint i = 0; i < reverseInitialStates.Length; i++)
{
reverseInitialStates[i] = _builder.MkState(_reversePattern, i);
}
_reverseInitialStates = reverseInitialStates;
// Initialize our fast-lookup for determining the character kind of ASCII characters.
// This is only required when the pattern contains anchors, as otherwise there's only
// ever a single kind used.
if (_pattern._info.ContainsSomeAnchor)
{
var asciiCharKinds = new uint[128];
for (int i = 0; i < asciiCharKinds.Length; i++)
{
TSetType predicate2;
uint charKind;
if (i == '\n')
{
predicate2 = _builder._newLinePredicate;
charKind = CharKind.Newline;
}
else
{
predicate2 = _builder._wordLetterPredicateForAnchors;
charKind = CharKind.WordLetter;
}
asciiCharKinds[i] = _builder._solver.And(GetMinterm(i), predicate2).Equals(_builder._solver.False) ? 0 : charKind;
}
_asciiCharKinds = asciiCharKinds;
}
}