85node = new SymbolicRegexNode<TSet>(builder, kind, left, right, lower, upper, setOrStartSet, info);

13internal MatchingState(SymbolicRegexNode<TSet> node, uint prevCharKind) 21internal SymbolicRegexNode<TSet> Node { get; } 53/// fixed length, <see cref="SymbolicRegexNode{TSet}.ResolveFixedLength(uint)"/>. The context is defined 74internal SymbolicRegexNode<TSet> Next(SymbolicRegexBuilder<TSet> builder, TSet minterm, uint nextCharKind) 90internal List<(SymbolicRegexNode<TSet> Node, DerivativeEffect[] Effects)> NfaNextWithEffects(SymbolicRegexBuilder<TSet> builder, TSet minterm, uint nextCharKind) 101/// This is functionally equivalent to <see cref="SymbolicRegexNode{TSet}.IsNullableFor(uint)"/>, but using cached

13/// <summary>Provides functionality to convert <see cref="RegexNode"/>s to corresponding <see cref="SymbolicRegexNode{S}"/>s.</summary> 19/// <summary>The builder to use to create the <see cref="SymbolicRegexNode{S}"/> nodes.</summary> 26/// <summary>Converts the root <see cref="RegexNode"/> into its corresponding <see cref="SymbolicRegexNode{S}"/>.</summary> 28/// <returns>The generated <see cref="SymbolicRegexNode{S}"/> that corresponds to the supplied <paramref name="root"/>.</returns> 29internal SymbolicRegexNode<BDD> ConvertToSymbolicRegexNode(RegexNode root) 34DoublyLinkedList<SymbolicRegexNode<BDD>> rootResult = new(); 37Stack<(RegexNode Node, DoublyLinkedList<SymbolicRegexNode<BDD>> Result, DoublyLinkedList<SymbolicRegexNode<BDD>>[]? ChildResults)> stack = new(); 42while (stack.TryPop(out (RegexNode Node, DoublyLinkedList<SymbolicRegexNode<BDD>> Result, DoublyLinkedList<SymbolicRegexNode<BDD>>[]? ChildResults) popped)) 45DoublyLinkedList<SymbolicRegexNode<BDD>> result = popped.Result; 46DoublyLinkedList<SymbolicRegexNode<BDD>>[]? childResults = popped.ChildResults; 98childResults[i] = new DoublyLinkedList<SymbolicRegexNode<BDD>>(); 214foreach (DoublyLinkedList<SymbolicRegexNode<BDD>> childResult in childResults) 226SymbolicRegexNode<BDD> or = _builder._nothing; 231DoublyLinkedList<SymbolicRegexNode<BDD>> childResult = childResults[i]; 234SymbolicRegexNode<BDD> elem = childResult.Count == 1 ? 244SymbolicRegexNode<BDD>.CreateAlternate(_builder, elem, or); 254DoublyLinkedList<SymbolicRegexNode<BDD>> childResult = childResults[0]; 257SymbolicRegexNode<BDD> body = childResult.Count == 1 ? 270DoublyLinkedList<SymbolicRegexNode<BDD>> childResult = childResults[0]; 310SymbolicRegexNode<BDD> ConvertSet(RegexNode node) 320DoublyLinkedList<SymbolicRegexNode<BDD>>[]? CreateChildResultArray(int k) => k == 0 ? null : new DoublyLinkedList<SymbolicRegexNode<BDD>>[k];

22internal readonly SymbolicRegexNode<TSet> _nothing; 23internal readonly SymbolicRegexNode<TSet> _anyChar; 24internal readonly SymbolicRegexNode<TSet> _anyStar; 25internal readonly SymbolicRegexNode<TSet> _anyStarLazy; 27private SymbolicRegexNode<TSet>? _epsilon; 28internal SymbolicRegexNode<TSet> Epsilon => _epsilon ??= SymbolicRegexNode<TSet>.CreateEpsilon(this); 30private SymbolicRegexNode<TSet>? _beginningAnchor; 31internal SymbolicRegexNode<TSet> BeginningAnchor => _beginningAnchor ??= SymbolicRegexNode<TSet>.CreateAnchor(this, SymbolicRegexNodeKind.BeginningAnchor); 33private SymbolicRegexNode<TSet>? _endAnchor; 34internal SymbolicRegexNode<TSet> EndAnchor => _endAnchor ??= SymbolicRegexNode<TSet>.CreateAnchor(this, SymbolicRegexNodeKind.EndAnchor); 36private SymbolicRegexNode<TSet>? _endAnchorZ; 37internal SymbolicRegexNode<TSet> EndAnchorZ => _endAnchorZ ??= SymbolicRegexNode<TSet>.CreateAnchor(this, SymbolicRegexNodeKind.EndAnchorZ); 39private SymbolicRegexNode<TSet>? _endAnchorZReverse; 40internal SymbolicRegexNode<TSet> EndAnchorZReverse => _endAnchorZReverse ??= SymbolicRegexNode<TSet>.CreateAnchor(this, SymbolicRegexNodeKind.EndAnchorZReverse); 42private SymbolicRegexNode<TSet>? _bolAnchor; 43internal SymbolicRegexNode<TSet> BolAnchor => _bolAnchor ??= SymbolicRegexNode<TSet>.CreateAnchor(this, SymbolicRegexNodeKind.BOLAnchor); 45private SymbolicRegexNode<TSet>? _eolAnchor; 46internal SymbolicRegexNode<TSet> EolAnchor => _eolAnchor ??= SymbolicRegexNode<TSet>.CreateAnchor(this, SymbolicRegexNodeKind.EOLAnchor); 48private SymbolicRegexNode<TSet>? _wbAnchor; 49internal SymbolicRegexNode<TSet> BoundaryAnchor => _wbAnchor ??= SymbolicRegexNode<TSet>.CreateAnchor(this, SymbolicRegexNodeKind.BoundaryAnchor); 51private SymbolicRegexNode<TSet>? _nwbAnchor; 52internal SymbolicRegexNode<TSet> NonBoundaryAnchor => _nwbAnchor ??= SymbolicRegexNode<TSet>.CreateAnchor(this, SymbolicRegexNodeKind.NonBoundaryAnchor); 57private readonly Dictionary<TSet, SymbolicRegexNode<TSet>> _singletonCache = new(); 60/// This cache is used in <see cref="SymbolicRegexNode{TSet}.Create"/> to keep all nodes associated with this builder 64internal readonly Dictionary<NodeCacheKey, SymbolicRegexNode<TSet>> _nodeCache = new(); 72SymbolicRegexNodeKind kind, SymbolicRegexNode<TSet>? left, SymbolicRegexNode<TSet>? right, 77public readonly SymbolicRegexNode<TSet>? Left = left; 78public readonly SymbolicRegexNode<TSet>? Right = right; 106/// Cache for <see cref="SymbolicRegexNode{TSet}.CreateDerivative(SymbolicRegexBuilder{TSet}, TSet, uint)"/> keyed by: 112internal readonly Dictionary<(SymbolicRegexNode<TSet>, TSet elem, uint context), SymbolicRegexNode<TSet>> _derivativeCache = new(); 115/// Cache for <see cref="SymbolicRegexNode{TSet}.PruneLowerPriorityThanNullability(SymbolicRegexBuilder{TSet}, uint)"/> keyed by: 120internal readonly Dictionary<(SymbolicRegexNode<TSet>, uint), SymbolicRegexNode<TSet>> _pruneLowerPriorityThanNullabilityCache = new(); 123/// Cache for <see cref="SymbolicRegexNode{TSet}.Subsumes(SymbolicRegexBuilder{TSet}, SymbolicRegexNode{TSet}, int)"/> keyed by: 128internal readonly Dictionary<(SymbolicRegexNode<TSet>, SymbolicRegexNode<TSet>), bool> _subsumptionCache = new(); 146_nothing = SymbolicRegexNode<TSet>.CreateFalse(this); 147_anyChar = SymbolicRegexNode<TSet>.CreateTrue(this); 148_anyStar = SymbolicRegexNode<TSet>.CreateLoop(this, _anyChar, 0, int.MaxValue, isLazy: false); 149_anyStarLazy = SymbolicRegexNode<TSet>.CreateLoop(this, _anyChar, 0, int.MaxValue, isLazy: true); 159internal SymbolicRegexNode<TSet> Alternate(List<SymbolicRegexNode<TSet>> nodes) 161HashSet<SymbolicRegexNode<TSet>> seenElems = new(); 178SymbolicRegexNode<TSet> or = _nothing; 181or = SymbolicRegexNode<TSet>.CreateAlternate(this, nodes[i], or, deduplicated: true); 192internal SymbolicRegexNode<TSet> CreateConcatAlreadyReversed(IEnumerable<SymbolicRegexNode<TSet>> nodes) 194SymbolicRegexNode<TSet> result = Epsilon; 198foreach (SymbolicRegexNode<TSet> node in nodes) 206result = SymbolicRegexNode<TSet>.CreateConcat(this, node, result); 212internal SymbolicRegexNode<TSet> CreateConcat(SymbolicRegexNode<TSet> left, SymbolicRegexNode<TSet> right) => SymbolicRegexNode<TSet>.CreateConcat(this, left, right); 217internal SymbolicRegexNode<TSet> CreateLoop(SymbolicRegexNode<TSet> node, bool isLazy, int lower = 0, int upper = int.MaxValue) 248return SymbolicRegexNode<TSet>.CreateLoop(this, node._left, 0, 1, isLazy); 255return SymbolicRegexNode<TSet>.CreateLoop(this, node, lower, upper, isLazy); 259internal SymbolicRegexNode<TSet> CreateSingleton(TSet set) 263ref SymbolicRegexNode<TSet>? result = ref CollectionsMarshal.GetValueRefOrAddDefault(_singletonCache, set, out _); 264return result ??= SymbolicRegexNode<TSet>.CreateSingleton(this, set); 268internal SymbolicRegexNode<TSet> CreateFixedLengthMarker(int length) => SymbolicRegexNode<TSet>.CreateFixedLengthMarker(this, length); 270internal SymbolicRegexNode<TSet> CreateEffect(SymbolicRegexNode<TSet> node, SymbolicRegexNode<TSet> effectNode) => SymbolicRegexNode<TSet>.CreateEffect(this, node, effectNode); 272internal SymbolicRegexNode<TSet> CreateCapture(SymbolicRegexNode<TSet> child, int captureNum) => CreateConcat(CreateCaptureStart(captureNum), CreateConcat(child, CreateCaptureEnd(captureNum))); 274internal SymbolicRegexNode<TSet> CreateCaptureStart(int captureNum) => SymbolicRegexNode<TSet>.CreateCaptureStart(this, captureNum); 276internal SymbolicRegexNode<TSet> CreateCaptureEnd(int captureNum) => SymbolicRegexNode<TSet>.CreateCaptureEnd(this, captureNum); 278internal SymbolicRegexNode<TSet> CreateDisableBacktrackingSimulation(SymbolicRegexNode<TSet> child) 280return child == _nothing ? _nothing : SymbolicRegexNode<TSet>.CreateDisableBacktrackingSimulation(this, child); 283internal SymbolicRegexNode<TNewSet> Transform<TNewSet>(SymbolicRegexNode<TSet> node, SymbolicRegexBuilder<TNewSet> builder, Func<SymbolicRegexBuilder<TNewSet>, TSet, TNewSet> setTransformer) 333return SymbolicRegexNode<TNewSet>.CreateAlternate(builder, 346List<SymbolicRegexNode<TSet>> concatElements = node.ToList(); 347SymbolicRegexNode<TNewSet>[] reverseTransformed = new SymbolicRegexNode<TNewSet>[concatElements.Count];

8/// <summary>Misc information of structural properties of a <see cref="SymbolicRegexNode{S}"/> that is computed bottom up.</summary>

6/// <summary>Kinds of <see cref="SymbolicRegexNode{S}"/>.</summary> 39/// <see cref="SymbolicRegexNode{S}._lower"/> stores the fixed length. This node is used to avoid the second phase 51/// Effect nodes are created in the rule for concatenation in <see cref="SymbolicRegexNode{TSet}.CreateDerivative(SymbolicRegexBuilder{TSet}, TSet, uint)"/>, 65/// <see cref="SymbolicRegexNode{TSet}.ApplyEffects"/> finds which effects would be encountered by the backtracking 70/// <remarks><see cref="SymbolicRegexNode{S}._lower"/> stores the associated capture number.</remarks> 73/// <remarks><see cref="SymbolicRegexNode{S}._lower"/> stores the associated capture number.</remarks>

27/// <see cref="SymbolicRegexNode{TSet}"/> and the kind of the previous character. 29private readonly Dictionary<(SymbolicRegexNode<TSet> Node, uint PrevCharKind), MatchingState<TSet>> _stateCache = []; 165private MatchingState<TSet> GetOrCreateState(SymbolicRegexNode<TSet> node, uint prevCharKind) 182private MatchReversalInfo<TSet> CreateOptimizedReversal(SymbolicRegexNode<TSet> node) 205SymbolicRegexNode<TSet>? left = node._left; 250private MatchingState<TSet> GetOrCreateState_NoLock(SymbolicRegexNode<TSet> node, uint prevCharKind, bool isInitialState = false) 252SymbolicRegexNode<TSet> prunedNode = node.PruneAnchors(_builder, prevCharKind); 253(SymbolicRegexNode<TSet> Node, uint PrevCharKind) key = (prunedNode, prevCharKind); 281/// <see cref="MatchingState{TSet}"/> allocated with <see cref="GetOrCreateState(SymbolicRegexNode{TSet}, uint)"/>, 293private int? CreateNfaState(SymbolicRegexNode<TSet> node, uint prevCharKind) 404SymbolicRegexNode<TSet> targetNode = coreTargetId > 0 ? 433List<(SymbolicRegexNode<TSet> Node, DerivativeEffect[] Effects)>? transition = coreState.NfaNextWithEffects(_builder, minterm, nextCharKind); 437foreach ((SymbolicRegexNode<TSet> Node, DerivativeEffect[] Effects) entry in transition) 452/// Iterates through the alternation branches <see cref="SymbolicRegexNode{TSet}.EnumerateAlternationBranches(SymbolicRegexBuilder{TSet})"/> 454/// include dead ends as <see cref="CreateNfaState(SymbolicRegexNode{TSet}, uint)"/> will filter those out. 462private void ForEachNfaState<T>(SymbolicRegexNode<TSet> node, uint prevCharKind, T arg, Action<int, T> action) 466foreach (SymbolicRegexNode<TSet> nfaNode in node.EnumerateAlternationBranches(_builder))

35/// <summary>Builder used to create <see cref="SymbolicRegexNode{S}"/>s while matching.</summary> 38/// produce new <see cref="SymbolicRegexNode{S}"/>s as we match. Once in NFA mode, we also use 61internal readonly SymbolicRegexNode<TSet> _dotStarredPattern; 64internal readonly SymbolicRegexNode<TSet> _pattern; 73internal readonly SymbolicRegexNode<TSet> _reversePattern; 150SymbolicRegexBuilder<BDD> bddBuilder, SymbolicRegexNode<BDD> rootBddNode, ISolver<TSet> solver, 164SymbolicRegexNode<TSet> rootNode = bddBuilder.Transform(rootBddNode, builder, (builder, bdd) => builder._solver.ConvertFromBDD(bdd, charSetSolver)); 169private SymbolicRegexMatcher(SymbolicRegexBuilder<TSet> builder, SymbolicRegexNode<TSet> rootNode, int captureCount, RegexFindOptimizations findOptimizations, TimeSpan matchTimeout)

39internal readonly SymbolicRegexNode<TSet>? _left; 40internal readonly SymbolicRegexNode<TSet>? _right; 62private SymbolicRegexNode(SymbolicRegexBuilder<TSet> builder, SymbolicRegexNodeKind kind, SymbolicRegexNode<TSet>? left, SymbolicRegexNode<TSet>? right, int lower, int upper, TSet set, SymbolicRegexInfo info) 78private static SymbolicRegexNode<TSet> Create(SymbolicRegexBuilder<TSet> builder, SymbolicRegexNodeKind kind, SymbolicRegexNode<TSet>? left, SymbolicRegexNode<TSet>? right, int lower, int upper, TSet? set, SymbolicRegexInfo info) 83if (!builder._nodeCache.TryGetValue(key, out SymbolicRegexNode<TSet>? node)) 101private static bool IsHighPriorityNullableFor(SymbolicRegexNode<TSet> node, uint context) 185public List<SymbolicRegexNode<TSet>> ToList(List<SymbolicRegexNode<TSet>>? list = null, SymbolicRegexNodeKind listKind = SymbolicRegexNodeKind.Concat) 192static void AppendToList(SymbolicRegexNode<TSet> concat, List<SymbolicRegexNode<TSet>> list, SymbolicRegexNodeKind listKind) 200SymbolicRegexNode<TSet> node = concat; 378internal static SymbolicRegexNode<TSet> CreateFalse(SymbolicRegexBuilder<TSet> builder) => 381internal static SymbolicRegexNode<TSet> CreateTrue(SymbolicRegexBuilder<TSet> builder) => 384internal static SymbolicRegexNode<TSet> CreateFixedLengthMarker(SymbolicRegexBuilder<TSet> builder, int length) => 387internal static SymbolicRegexNode<TSet> CreateEpsilon(SymbolicRegexBuilder<TSet> builder) => 390internal static SymbolicRegexNode<TSet> CreateAnchor(SymbolicRegexBuilder<TSet> builder, SymbolicRegexNodeKind kind) 406internal static SymbolicRegexNode<TSet> CreateSingleton(SymbolicRegexBuilder<TSet> builder, TSet set) => 409internal static SymbolicRegexNode<TSet> CreateLoop(SymbolicRegexBuilder<TSet> builder, SymbolicRegexNode<TSet> body, int lower, int upper, bool isLazy) 422internal static SymbolicRegexNode<TSet> CreateEffect(SymbolicRegexBuilder<TSet> builder, SymbolicRegexNode<TSet> node, SymbolicRegexNode<TSet> effectNode) 439internal static SymbolicRegexNode<TSet> CreateCaptureStart(SymbolicRegexBuilder<TSet> builder, int captureNum) => 442internal static SymbolicRegexNode<TSet> CreateCaptureEnd(SymbolicRegexBuilder<TSet> builder, int captureNum) => 445internal static SymbolicRegexNode<TSet> CreateDisableBacktrackingSimulation(SymbolicRegexBuilder<TSet> builder, SymbolicRegexNode<TSet> child) => 449internal static SymbolicRegexNode<TSet> CreateConcat(SymbolicRegexBuilder<TSet> builder, SymbolicRegexNode<TSet> left, SymbolicRegexNode<TSet> right) 488internal static SymbolicRegexNode<TSet> CreateAlternate(SymbolicRegexBuilder<TSet> builder, SymbolicRegexNode<TSet> left, SymbolicRegexNode<TSet> right, bool deduplicated = false, bool hintRightLikelySubsumes = false) 497SymbolicRegexNode<TSet> head = right._kind == SymbolicRegexNodeKind.Alternate ? right._left! : right; 498SymbolicRegexNode<TSet> tail = right._kind == SymbolicRegexNodeKind.Alternate ? right._right! : builder._nothing; 506if (head.Subsumes(builder, left) && TryFoldAlternation(builder, left, head, out SymbolicRegexNode<TSet>? result)) 516SymbolicRegexNode<TSet> current = right; 540List<SymbolicRegexNode<TSet>> elems = left.ToList(listKind: SymbolicRegexNodeKind.Alternate); 546HashSet<SymbolicRegexNode<TSet>> seenElems = []; 565SymbolicRegexNode<TSet> or = builder._nothing; 574SymbolicRegexNode<TSet> or = right; 611internal bool Subsumes(SymbolicRegexBuilder<TSet> builder, SymbolicRegexNode<TSet> other, int depth = 0) 647static bool? ApplySubsumptionRules(SymbolicRegexBuilder<TSet> builder, SymbolicRegexNode<TSet> left, SymbolicRegexNode<TSet> right, int depth) 670SymbolicRegexNode<TSet> rl = right._left; 674if (TrySkipPrefix(left, rl._left, out SymbolicRegexNode<TSet>? tail)) 684SymbolicRegexNode<TSet> ll = left._left; 688if (TrySkipPrefix(right, ll._left, out SymbolicRegexNode<TSet>? tail)) 709static bool TrySkipPrefix(SymbolicRegexNode<TSet> node, SymbolicRegexNode<TSet> prefix, [NotNullWhen(true)] out SymbolicRegexNode<TSet>? tail) 747private SymbolicRegexNode<TSet> UnwrapEffects() 749SymbolicRegexNode<TSet> current = this; 771private static bool TryFoldAlternation(SymbolicRegexBuilder<TSet> builder, SymbolicRegexNode<TSet> left, SymbolicRegexNode<TSet> right, [NotNullWhen(true)] out SymbolicRegexNode<TSet>? result, 772SymbolicRegexNode<TSet>? rightEffects = null) 803if (TryFoldAlternation(builder, left._left, right, out SymbolicRegexNode<TSet>? innerResult, rightEffects)) 824if (right._left.IsNullable && TrySplitConcatSubsumption(builder, left, right, out SymbolicRegexNode<TSet>? prefix)) 837static bool TrySplitConcatSubsumption(SymbolicRegexBuilder<TSet> builder, SymbolicRegexNode<TSet> left, SymbolicRegexNode<TSet> right, 838[NotNullWhen(true)] out SymbolicRegexNode<TSet>? prefix) 840List<SymbolicRegexNode<TSet>> prefixElements = []; 841SymbolicRegexNode<TSet> suffix = right; 980public SymbolicRegexNode<TSet> AddFixedLengthMarkers(SymbolicRegexBuilder<TSet> builder, int lengthSoFar = 0) 1035internal SymbolicRegexNode<TSet> CreateDerivativeWithoutEffects(SymbolicRegexBuilder<TSet> builder, TSet elem, uint context) => CreateDerivativeWrapper(builder, elem, context).StripEffects(builder); 1054internal List<(SymbolicRegexNode<TSet>, DerivativeEffect[])> CreateNfaDerivativeWithEffects(SymbolicRegexBuilder<TSet> builder, TSet elem, uint context) 1056List<(SymbolicRegexNode<TSet>, DerivativeEffect[])> transitions = []; 1064private SymbolicRegexNode<TSet> CreateDerivativeWrapper(SymbolicRegexBuilder<TSet> builder, TSet elem, uint context) 1070SymbolicRegexNode<TSet> derivative = _left.CreateDerivative(builder, elem, context); 1077SymbolicRegexNode<TSet> node = PruneLowerPriorityThanNullability(builder, context); 1083private SymbolicRegexNode<TSet> PruneLowerPriorityThanNullability(SymbolicRegexBuilder<TSet> builder, uint context) 1089(SymbolicRegexNode<TSet>, uint) key = (this, context); 1090if (builder._pruneLowerPriorityThanNullabilityCache.TryGetValue(key, out SymbolicRegexNode<TSet>? prunedNode)) 1158static SymbolicRegexNode<TSet> PruneLoop(SymbolicRegexBuilder<TSet> builder, uint context, SymbolicRegexNode<TSet> loop, SymbolicRegexNode<TSet> tail) 1190SymbolicRegexNode<TSet> skipLoopCase = CreateConcat(builder, loop._left.PruneLowerPriorityThanNullability(builder, context), 1212private SymbolicRegexNode<TSet> CreateLoopContinuation(SymbolicRegexBuilder<TSet> builder) 1250private SymbolicRegexNode<TSet> CreateDerivative(SymbolicRegexBuilder<TSet> builder, TSet elem, uint context) 1257(SymbolicRegexNode<TSet>, TSet, uint) key = (this, elem, context); 1258if (builder._derivativeCache.TryGetValue(key, out SymbolicRegexNode<TSet>? derivative)) 1295SymbolicRegexNode<TSet> leftDerivative = builder.CreateConcat(_left.CreateDerivative(builder, elem, context), _right); 1296SymbolicRegexNode<TSet> rightDerivative = builder.CreateEffect(_right.CreateDerivative(builder, elem, context), _left); 1364internal SymbolicRegexNode<TSet> StripEffects(SymbolicRegexBuilder<TSet> builder) 1392List<SymbolicRegexNode<TSet>> elems = ToList(listKind: SymbolicRegexNodeKind.Alternate); 1427internal void StripAndMapEffects(SymbolicRegexBuilder<TSet> builder, uint context, List<(SymbolicRegexNode<TSet>, DerivativeEffect[])> alternativesAndEffects, 1471(SymbolicRegexNode<TSet> node, DerivativeEffect[] effects) = alternativesAndEffects[i]; 1509(SymbolicRegexNode<TSet> node, DerivativeEffect[] effects) = alternativesAndEffects[i]; 1768static void ToStringGrouped(SymbolicRegexNode<TSet> node, StringBuilder sb) 1871SymbolicRegexNode<TSet> conc = this; 1904public SymbolicRegexNode<TSet> Reverse(SymbolicRegexBuilder<TSet> builder) 1920SymbolicRegexNode<TSet> rev = _left.Reverse(builder); 1921SymbolicRegexNode<TSet> rest = _right; 1925SymbolicRegexNode<TSet> rev1 = rest._left.Reverse(builder); 1929SymbolicRegexNode<TSet> restr = rest.Reverse(builder); 2008private static TSet ComputeStartSet(SymbolicRegexBuilder<TSet> builder, SymbolicRegexNodeKind kind, SymbolicRegexNode<TSet>? left, SymbolicRegexNode<TSet>? right) 2065internal SymbolicRegexNode<TSet> PruneAnchors(SymbolicRegexBuilder<TSet> builder, uint prevKind) 2079private SymbolicRegexNode<TSet> PruneAnchorsImpl(SymbolicRegexBuilder<TSet> builder, uint prevKind, bool contWithWL, bool contWithNWL) 2118SymbolicRegexNode<TSet> body = _left.PruneAnchorsImpl(builder, prevKind, contWithWL, contWithNWL); 2126SymbolicRegexNode<TSet> left1 = _left.PruneAnchorsImpl(builder, prevKind, contWithWL, contWithNWL); 2127SymbolicRegexNode<TSet> right1 = _left.IsNullable ? _right.PruneAnchorsImpl(builder, prevKind, contWithWL, contWithNWL) : _right; 2138SymbolicRegexNode<TSet> left1 = _left.PruneAnchorsImpl(builder, prevKind, contWithWL, contWithNWL); 2139SymbolicRegexNode<TSet> right1 = _right.PruneAnchorsImpl(builder, prevKind, contWithWL, contWithNWL); 2150SymbolicRegexNode<TSet> left1 = _left.PruneAnchorsImpl(builder, prevKind, contWithWL, contWithNWL); 2158SymbolicRegexNode<TSet> child = _left.PruneAnchorsImpl(builder, prevKind, contWithWL, contWithNWL); 2218internal IEnumerable<SymbolicRegexNode<TSet>> EnumerateAlternationBranches(SymbolicRegexBuilder<TSet> builder) 2226foreach (SymbolicRegexNode<TSet> element in _left.EnumerateAlternationBranches(builder)) 2234SymbolicRegexNode<TSet> current = this;

23SymbolicRegexNode<BDD> rootNode = converter.ConvertToSymbolicRegexNode(regexTree.Root);

11/// <summary>Maximum number of <see cref="SymbolicRegexNode{TSet}"/> instances before switching over to NFA mode.</summary> 27/// Default maximum estimated safe expansion size of a <see cref="SymbolicRegexNode{TSet}"/> AST