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

13internal MatchingState(SymbolicRegexNode<TSet> node, uint prevCharKind) 20internal SymbolicRegexNode<TSet> Node { get; } 52/// fixed length, <see cref="SymbolicRegexNode{TSet}.ResolveFixedLength(uint)"/>. The context is defined 73internal SymbolicRegexNode<TSet> Next(SymbolicRegexBuilder<TSet> builder, TSet minterm, uint nextCharKind) 89internal List<(SymbolicRegexNode<TSet> Node, DerivativeEffect[] Effects)> NfaNextWithEffects(SymbolicRegexBuilder<TSet> builder, TSet minterm, uint nextCharKind)

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>

26/// <see cref="SymbolicRegexNode{TSet}"/> and the kind of the previous character. 28private readonly Dictionary<(SymbolicRegexNode<TSet> Node, uint PrevCharKind), MatchingState<TSet>> _stateCache = new(); 149private MatchingState<TSet> GetOrCreateState(SymbolicRegexNode<TSet> node, uint prevCharKind) 162private MatchingState<TSet> GetOrCreateState_NoLock(SymbolicRegexNode<TSet> node, uint prevCharKind, bool isInitialState = false) 164SymbolicRegexNode<TSet> prunedNode = node.PruneAnchors(_builder, prevCharKind); 165(SymbolicRegexNode<TSet> Node, uint PrevCharKind) key = (prunedNode, prevCharKind); 191/// <see cref="MatchingState{TSet}"/> allocated with <see cref="GetOrCreateState(SymbolicRegexNode{TSet}, uint)"/>, 203private int? CreateNfaState(SymbolicRegexNode<TSet> node, uint prevCharKind) 315SymbolicRegexNode<TSet>? targetNode = coreTargetId > 0 ? 344List<(SymbolicRegexNode<TSet> Node, DerivativeEffect[] Effects)>? transition = coreState.NfaNextWithEffects(_builder, minterm, nextCharKind); 347foreach ((SymbolicRegexNode<TSet> Node, DerivativeEffect[] Effects) entry in transition) 362/// Iterates through the alternation branches <see cref="SymbolicRegexNode{TSet}.EnumerateAlternationBranches(SymbolicRegexBuilder{TSet})"/> 364/// include dead ends as <see cref="CreateNfaState(SymbolicRegexNode{TSet}, uint)"/> will filter those out. 372private void ForEachNfaState<T>(SymbolicRegexNode<TSet> node, uint prevCharKind, T arg, Action<int, T> action) 376foreach (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; 133SymbolicRegexBuilder<BDD> bddBuilder, SymbolicRegexNode<BDD> rootBddNode, ISolver<TSet> solver, 147SymbolicRegexNode<TSet> rootNode = bddBuilder.Transform(rootBddNode, builder, (builder, bdd) => builder._solver.ConvertFromBDD(bdd, charSetSolver)); 152private 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) 188list ??= new List<SymbolicRegexNode<TSet>>(); 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) 404internal static SymbolicRegexNode<TSet> CreateSingleton(SymbolicRegexBuilder<TSet> builder, TSet set) => 407internal static SymbolicRegexNode<TSet> CreateLoop(SymbolicRegexBuilder<TSet> builder, SymbolicRegexNode<TSet> body, int lower, int upper, bool isLazy) 420internal static SymbolicRegexNode<TSet> CreateEffect(SymbolicRegexBuilder<TSet> builder, SymbolicRegexNode<TSet> node, SymbolicRegexNode<TSet> effectNode) 437internal static SymbolicRegexNode<TSet> CreateCaptureStart(SymbolicRegexBuilder<TSet> builder, int captureNum) => 440internal static SymbolicRegexNode<TSet> CreateCaptureEnd(SymbolicRegexBuilder<TSet> builder, int captureNum) => 443internal static SymbolicRegexNode<TSet> CreateDisableBacktrackingSimulation(SymbolicRegexBuilder<TSet> builder, SymbolicRegexNode<TSet> child) => 447internal static SymbolicRegexNode<TSet> CreateConcat(SymbolicRegexBuilder<TSet> builder, SymbolicRegexNode<TSet> left, SymbolicRegexNode<TSet> right) 486internal static SymbolicRegexNode<TSet> CreateAlternate(SymbolicRegexBuilder<TSet> builder, SymbolicRegexNode<TSet> left, SymbolicRegexNode<TSet> right, bool deduplicated = false, bool hintRightLikelySubsumes = false) 495SymbolicRegexNode<TSet> head = right._kind == SymbolicRegexNodeKind.Alternate ? right._left! : right; 496SymbolicRegexNode<TSet> tail = right._kind == SymbolicRegexNodeKind.Alternate ? right._right! : builder._nothing; 504if (head.Subsumes(builder, left) && TryFoldAlternation(builder, left, head, out SymbolicRegexNode<TSet>? result)) 514SymbolicRegexNode<TSet> current = right; 538List<SymbolicRegexNode<TSet>> elems = left.ToList(listKind: SymbolicRegexNodeKind.Alternate); 543HashSet<SymbolicRegexNode<TSet>> seenElems = new(); 563SymbolicRegexNode<TSet> or = builder._nothing; 572SymbolicRegexNode<TSet> or = right; 609internal bool Subsumes(SymbolicRegexBuilder<TSet> builder, SymbolicRegexNode<TSet> other, int depth = 0) 645static bool? ApplySubsumptionRules(SymbolicRegexBuilder<TSet> builder, SymbolicRegexNode<TSet> left, SymbolicRegexNode<TSet> right, int depth) 668SymbolicRegexNode<TSet> rl = right._left; 672if (TrySkipPrefix(left, rl._left, out SymbolicRegexNode<TSet>? tail)) 682SymbolicRegexNode<TSet> ll = left._left; 686if (TrySkipPrefix(right, ll._left, out SymbolicRegexNode<TSet>? tail)) 707static bool TrySkipPrefix(SymbolicRegexNode<TSet> node, SymbolicRegexNode<TSet> prefix, [NotNullWhen(true)] out SymbolicRegexNode<TSet>? tail) 745private SymbolicRegexNode<TSet> UnwrapEffects() 747SymbolicRegexNode<TSet> current = this; 769private static bool TryFoldAlternation(SymbolicRegexBuilder<TSet> builder, SymbolicRegexNode<TSet> left, SymbolicRegexNode<TSet> right, [NotNullWhen(true)] out SymbolicRegexNode<TSet>? result, 770SymbolicRegexNode<TSet>? rightEffects = null) 801if (TryFoldAlternation(builder, left._left, right, out SymbolicRegexNode<TSet>? innerResult, rightEffects)) 822if (right._left.IsNullable && TrySplitConcatSubsumption(builder, left, right, out SymbolicRegexNode<TSet>? prefix)) 835static bool TrySplitConcatSubsumption(SymbolicRegexBuilder<TSet> builder, SymbolicRegexNode<TSet> left, SymbolicRegexNode<TSet> right, 836[NotNullWhen(true)] out SymbolicRegexNode<TSet>? prefix) 838List<SymbolicRegexNode<TSet>> prefixElements = new(); 839SymbolicRegexNode<TSet> suffix = right; 978public SymbolicRegexNode<TSet> AddFixedLengthMarkers(SymbolicRegexBuilder<TSet> builder, int lengthSoFar = 0) 1033internal SymbolicRegexNode<TSet> CreateDerivativeWithoutEffects(SymbolicRegexBuilder<TSet> builder, TSet elem, uint context) => CreateDerivativeWrapper(builder, elem, context).StripEffects(builder); 1052internal List<(SymbolicRegexNode<TSet>, DerivativeEffect[])> CreateNfaDerivativeWithEffects(SymbolicRegexBuilder<TSet> builder, TSet elem, uint context) 1054List<(SymbolicRegexNode<TSet>, DerivativeEffect[])> transitions = new(); 1062private SymbolicRegexNode<TSet> CreateDerivativeWrapper(SymbolicRegexBuilder<TSet> builder, TSet elem, uint context) 1068SymbolicRegexNode<TSet> derivative = _left.CreateDerivative(builder, elem, context); 1075SymbolicRegexNode<TSet> node = PruneLowerPriorityThanNullability(builder, context); 1081private SymbolicRegexNode<TSet> PruneLowerPriorityThanNullability(SymbolicRegexBuilder<TSet> builder, uint context) 1087SymbolicRegexNode<TSet>? prunedNode; 1088(SymbolicRegexNode<TSet>, uint) key = (this, context); 1157static SymbolicRegexNode<TSet> PruneLoop(SymbolicRegexBuilder<TSet> builder, uint context, SymbolicRegexNode<TSet> loop, SymbolicRegexNode<TSet> tail) 1189SymbolicRegexNode<TSet> skipLoopCase = CreateConcat(builder, loop._left.PruneLowerPriorityThanNullability(builder, context), 1211private SymbolicRegexNode<TSet> CreateLoopContinuation(SymbolicRegexBuilder<TSet> builder) 1249private SymbolicRegexNode<TSet> CreateDerivative(SymbolicRegexBuilder<TSet> builder, TSet elem, uint context) 1256SymbolicRegexNode<TSet>? derivative; 1257(SymbolicRegexNode<TSet>, TSet, uint) key = (this, elem, context); 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, 1768static void ToStringGrouped(SymbolicRegexNode<TSet> node, StringBuilder sb) 1871SymbolicRegexNode<TSet> conc = this; 1908public SymbolicRegexNode<TSet> Reverse(SymbolicRegexBuilder<TSet> builder) 1924SymbolicRegexNode<TSet> rev = _left.Reverse(builder); 1925SymbolicRegexNode<TSet> rest = _right; 1929SymbolicRegexNode<TSet> rev1 = rest._left.Reverse(builder); 1933SymbolicRegexNode<TSet> restr = rest.Reverse(builder); 2012private static TSet ComputeStartSet(SymbolicRegexBuilder<TSet> builder, SymbolicRegexNodeKind kind, SymbolicRegexNode<TSet>? left, SymbolicRegexNode<TSet>? right) 2069internal SymbolicRegexNode<TSet> PruneAnchors(SymbolicRegexBuilder<TSet> builder, uint prevKind) 2083private SymbolicRegexNode<TSet> PruneAnchorsImpl(SymbolicRegexBuilder<TSet> builder, uint prevKind, bool contWithWL, bool contWithNWL) 2122SymbolicRegexNode<TSet> body = _left.PruneAnchorsImpl(builder, prevKind, contWithWL, contWithNWL); 2130SymbolicRegexNode<TSet> left1 = _left.PruneAnchorsImpl(builder, prevKind, contWithWL, contWithNWL); 2131SymbolicRegexNode<TSet> right1 = _left.IsNullable ? _right.PruneAnchorsImpl(builder, prevKind, contWithWL, contWithNWL) : _right; 2142SymbolicRegexNode<TSet> left1 = _left.PruneAnchorsImpl(builder, prevKind, contWithWL, contWithNWL); 2143SymbolicRegexNode<TSet> right1 = _right.PruneAnchorsImpl(builder, prevKind, contWithWL, contWithNWL); 2154SymbolicRegexNode<TSet> left1 = _left.PruneAnchorsImpl(builder, prevKind, contWithWL, contWithNWL); 2162SymbolicRegexNode<TSet> child = _left.PruneAnchorsImpl(builder, prevKind, contWithWL, contWithNWL); 2222internal IEnumerable<SymbolicRegexNode<TSet>> EnumerateAlternationBranches(SymbolicRegexBuilder<TSet> builder) 2230foreach (SymbolicRegexNode<TSet> element in _left.EnumerateAlternationBranches(builder)) 2238SymbolicRegexNode<TSet> current = this;

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

29/// Default maximum estimated safe expansion size of a <see cref="SymbolicRegexNode{TSet}"/> AST