ReduceAlternation()

RegexNode System.Text.RegularExpressions.RegexNode.ReduceAlternation ( )

inlineprivate

Definition at line 401 of file RegexNode.cs.

    {
        switch (ChildCount())
        {
        case 0:
            return new RegexNode(22, Options);
        case 1:
            return Child(0);
        default:
        {
            ReduceSingleLetterAndNestedAlternations();
            RegexNode regexNode = ReplaceNodeIfUnnecessary(22);
            if (regexNode == this)
            {
                return ExtractCommonPrefix();
            }
            return regexNode;
        }
        }
        RegexNode ExtractCommonPrefix()
        {
            List<RegexNode> list = (List<RegexNode>)Children;
            if ((Options & RegexOptions.RightToLeft) != 0)
            {
                return this;
            }
            RegexNode regexNode2 = FindBranchOneMultiStart(list[0]);
            if (regexNode2 == null)
            {
                return this;
            }
            RegexOptions options = regexNode2.Options;
            string str = regexNode2.Str;
            ReadOnlySpan<char> readOnlySpan;
            if (regexNode2.Type == 9)
            {
                Span<char> span = stackalloc char[1] { regexNode2.Ch };
                readOnlySpan = span;
            }
            else
            {
                readOnlySpan = str;
            }
            ReadOnlySpan<char> startingSpan2 = readOnlySpan;
            for (int i = 1; i < list.Count; i++)
            {
                regexNode2 = FindBranchOneMultiStart(list[i]);
                if (regexNode2 == null || regexNode2.Options != options)
                {
                    return this;
                }
                if (regexNode2.Type == 9)
                {
                    if (startingSpan2[0] != regexNode2.Ch)
                    {
                        return this;
                    }
                    if (startingSpan2.Length != 1)
                    {
                        startingSpan2 = startingSpan2.Slice(0, 1);
                    }
                }
                else
                {
                    int num = Math.Min(startingSpan2.Length, regexNode2.Str.Length);
                    int j;
                    for (j = 0; j < num && startingSpan2[j] == regexNode2.Str[j]; j++)
                    {
                    }
                    if (j == 0)
                    {
                        return this;
                    }
                    startingSpan2 = startingSpan2.Slice(0, j);
                }
            }
            for (int k = 0; k < list.Count; k++)
            {
                RegexNode regexNode3 = list[k];
                if (regexNode3.Type == 25)
                {
                    ProcessOneOrMulti(regexNode3.Child(0), startingSpan2);
                    ReplaceChild(k, regexNode3.Reduce());
                }
                else
                {
                    ProcessOneOrMulti(regexNode3, startingSpan2);
                }
            }
            for (int l = 0; l < list.Count; l++)
            {
                if (list[l].Type == 23)
                {
                    int m = l + 1;
                    int num2 = m;
                    for (; m < list.Count; m++)
                    {
                        if (list[m].Type != 23)
                        {
                            if (num2 != m)
                            {
                                list[num2] = list[m];
                            }
                            num2++;
                        }
                    }
                    if (num2 < m)
                    {
                        list.RemoveRange(num2, m - num2);
                    }
                    break;
                }
            }
            RegexNode regexNode4 = new RegexNode(25, Options);
            regexNode4.AddChild((startingSpan2.Length == 1) ? new RegexNode(9, options)
            {
                Ch = startingSpan2[0]
            } : new RegexNode(12, options)
            {
                Str = ((str?.Length == startingSpan2.Length) ? str : startingSpan2.ToString())
            });
            regexNode4.AddChild(this);
            return regexNode4;
        }
        static RegexNode FindBranchOneMultiStart(RegexNode branch)
        {
            if (branch.Type == 25)
            {
                branch = branch.Child(0);
            }
            if (branch.Type != 9 && branch.Type != 12)
            {
                return null;
            }
            return branch;
        }
        static void ProcessOneOrMulti(RegexNode node, ReadOnlySpan<char> startingSpan)
        {
            if (node.Type == 9)
            {
                node.Type = 23;
                node.Ch = '\0';
            }
            else if (node.Str.Length == startingSpan.Length)
            {
                node.Type = 23;
                node.Str = null;
            }
            else if (node.Str.Length - 1 == startingSpan.Length)
            {
                node.Type = 9;
                node.Ch = node.Str[^1];
                node.Str = null;
            }
            else
            {
                node.Str = node.Str.Substring(startingSpan.Length);
            }
        }
        void ReduceSingleLetterAndNestedAlternations()
        {
            bool flag = false;
            bool flag2 = false;
            RegexOptions regexOptions = RegexOptions.None;
            List<RegexNode> list2 = (List<RegexNode>)Children;
            int n = 0;
            int num3;
            for (num3 = 0; n < list2.Count; n++, num3++)
            {
                RegexNode regexNode5 = list2[n];
                if (num3 < n)
                {
                    list2[num3] = regexNode5;
                }
                if (regexNode5.Type == 24)
                {
                    if (regexNode5.Children is List<RegexNode> list3)
                    {
                        for (int num4 = 0; num4 < list3.Count; num4++)
                        {
                            list3[num4].Next = this;
                        }
                        list2.InsertRange(n + 1, list3);
                    }
                    else
                    {
                        RegexNode regexNode6 = (RegexNode)regexNode5.Children;
                        regexNode6.Next = this;
                        list2.Insert(n + 1, regexNode6);
                    }
                    num3--;
                }
                else if (regexNode5.Type == 11 || regexNode5.Type == 9)
                {
                    RegexOptions regexOptions2 = regexNode5.Options & (RegexOptions.IgnoreCase | RegexOptions.RightToLeft);
                    if (regexNode5.Type == 11)
                    {
                        if (!flag || regexOptions != regexOptions2 || flag2 || !RegexCharClass.IsMergeable(regexNode5.Str))
                        {
                            flag = true;
                            flag2 = !RegexCharClass.IsMergeable(regexNode5.Str);
                            regexOptions = regexOptions2;
                            continue;
                        }
                    }
                    else if (!flag || regexOptions != regexOptions2 || flag2)
                    {
                        flag = true;
                        flag2 = false;
                        regexOptions = regexOptions2;
                        continue;
                    }
                    num3--;
                    RegexNode regexNode7 = list2[num3];
                    RegexCharClass regexCharClass;
                    if (regexNode7.Type == 9)
                    {
                        regexCharClass = new RegexCharClass();
                        regexCharClass.AddChar(regexNode7.Ch);
                    }
                    else
                    {
                        regexCharClass = RegexCharClass.Parse(regexNode7.Str);
                    }
                    if (regexNode5.Type == 9)
                    {
                        regexCharClass.AddChar(regexNode5.Ch);
                    }
                    else
                    {
                        RegexCharClass cc = RegexCharClass.Parse(regexNode5.Str);
                        regexCharClass.AddCharClass(cc);
                    }
                    regexNode7.Type = 11;
                    regexNode7.Str = regexCharClass.ToStringClass();
                }
                else if (regexNode5.Type == 22)
                {
                    num3--;
                }
                else
                {
                    flag = false;
                    flag2 = false;
                }
            }
            if (num3 < n)
            {
                list2.RemoveRange(num3, n - num3);
            }
        }
    }

References System.Text.RegularExpressions.RegexNode.RegexNode(), System.Text.RegularExpressions.RegexNode.Ch, System.Text.RegularExpressions.RegexNode.Child(), System.Text.RegularExpressions.RegexNode.ChildCount(), System.Text.RegularExpressions.RegexNode.Children, System.Collections.Generic.Dictionary< TKey, TValue >.Count, System.Text.RegularExpressions.i, System.Text.RegularExpressions.RegexCharClass.IsMergeable(), System.list, System.Math.Min(), System.Text.RegularExpressions.options, System.Text.RegularExpressions.RegexNode.Options, System.Text.RegularExpressions.RegexCharClass.Parse(), System.Text.RegularExpressions.RegexNode.ReplaceChild(), System.Text.RegularExpressions.RegexNode.ReplaceNodeIfUnnecessary(), System.Text.RegularExpressions.str, and System.Text.RegularExpressions.RegexNode.Str.

Referenced by System.Text.RegularExpressions.RegexNode.Reduce().