ReduceConcatenationWithAdjacentLoops()

void System.Text.RegularExpressions.RegexNode.ReduceConcatenationWithAdjacentLoops ( )

inlineprivate

Definition at line 748 of file RegexNode.cs.

    {
        List<RegexNode> list = (List<RegexNode>)Children;
        int index = 0;
        int num = 1;
        int num2 = 1;
        while (num < list.Count)
        {
            RegexNode regexNode = list[index];
            RegexNode regexNode2 = list[num];
            if (regexNode.Options == regexNode2.Options)
            {
                switch (regexNode.Type)
                {
                case 3:
                    if (regexNode2.Type == 3 && regexNode.Ch == regexNode2.Ch)
                    {
                        goto IL_01de;
                    }
                    if (regexNode2.Type != 9 || regexNode.Ch != regexNode2.Ch)
                    {
                        break;
                    }
                    goto IL_03b2;
                case 43:
                    if (regexNode2.Type == 43 && regexNode.Ch == regexNode2.Ch)
                    {
                        goto IL_01de;
                    }
                    if (regexNode2.Type != 9 || regexNode.Ch != regexNode2.Ch)
                    {
                        break;
                    }
                    goto IL_03b2;
                case 6:
                    if (regexNode2.Type == 6 && regexNode.Ch == regexNode2.Ch)
                    {
                        goto IL_01de;
                    }
                    if (regexNode2.Type != 9 || regexNode.Ch != regexNode2.Ch)
                    {
                        break;
                    }
                    goto IL_03b2;
                case 4:
                    if (regexNode2.Type == 4 && regexNode.Ch == regexNode2.Ch)
                    {
                        goto IL_01de;
                    }
                    if (regexNode2.Type != 10 || regexNode.Ch != regexNode2.Ch)
                    {
                        break;
                    }
                    goto IL_03b2;
                case 44:
                    if (regexNode2.Type == 44 && regexNode.Ch == regexNode2.Ch)
                    {
                        goto IL_01de;
                    }
                    if (regexNode2.Type != 10 || regexNode.Ch != regexNode2.Ch)
                    {
                        break;
                    }
                    goto IL_03b2;
                case 7:
                    if (regexNode2.Type == 7 && regexNode.Ch == regexNode2.Ch)
                    {
                        goto IL_01de;
                    }
                    if (regexNode2.Type != 10 || regexNode.Ch != regexNode2.Ch)
                    {
                        break;
                    }
                    goto IL_03b2;
                case 5:
                    if (regexNode2.Type == 5 && regexNode.Str == regexNode2.Str)
                    {
                        goto IL_01de;
                    }
                    if (regexNode2.Type != 11 || !(regexNode.Str == regexNode2.Str))
                    {
                        break;
                    }
                    goto IL_03b2;
                case 45:
                    if (regexNode2.Type == 45 && regexNode.Str == regexNode2.Str)
                    {
                        goto IL_01de;
                    }
                    if (regexNode2.Type != 11 || !(regexNode.Str == regexNode2.Str))
                    {
                        break;
                    }
                    goto IL_03b2;
                case 8:
                    if (regexNode2.Type == 8 && regexNode.Str == regexNode2.Str)
                    {
                        goto IL_01de;
                    }
                    if (regexNode2.Type != 11 || !(regexNode.Str == regexNode2.Str))
                    {
                        break;
                    }
                    goto IL_03b2;
                case 9:
                    if ((regexNode2.Type == 3 || regexNode2.Type == 43 || regexNode2.Type == 6) && regexNode.Ch == regexNode2.Ch)
                    {
                        goto IL_04b1;
                    }
                    if (regexNode2.Type != 9 || regexNode.Ch != regexNode2.Ch)
                    {
                        break;
                    }
                    goto IL_0571;
                case 10:
                    if ((regexNode2.Type == 4 || regexNode2.Type == 44 || regexNode2.Type == 7) && regexNode.Ch == regexNode2.Ch)
                    {
                        goto IL_04b1;
                    }
                    if (regexNode2.Type != 10 || regexNode.Ch != regexNode2.Ch)
                    {
                        break;
                    }
                    goto IL_0571;
                case 11:
                    {
                        if ((regexNode2.Type == 5 || regexNode2.Type == 45 || regexNode2.Type == 8) && regexNode.Str == regexNode2.Str)
                        {
                            goto IL_04b1;
                        }
                        if (regexNode2.Type != 11 || !(regexNode.Str == regexNode2.Str))
                        {
                            break;
                        }
                        goto IL_0571;
                    }
                    IL_0571:
                    regexNode.MakeRep(3, 2, 2);
                    num++;
                    continue;
                    IL_04b1:
                    if (CanCombineCounts(1, 1, regexNode2.M, regexNode2.N))
                    {
                        regexNode.Type = regexNode2.Type;
                        regexNode.M = regexNode2.M + 1;
                        regexNode.N = ((regexNode2.N == int.MaxValue) ? int.MaxValue : (regexNode2.N + 1));
                        num++;
                        continue;
                    }
                    break;
                    IL_03b2:
                    if (CanCombineCounts(regexNode.M, regexNode.N, 1, 1))
                    {
                        regexNode.M++;
                        if (regexNode.N != int.MaxValue)
                        {
                            regexNode.N++;
                        }
                        num++;
                        continue;
                    }
                    break;
                    IL_01de:
                    if (CanCombineCounts(regexNode.M, regexNode.N, regexNode2.M, regexNode2.N))
                    {
                        regexNode.M += regexNode2.M;
                        if (regexNode.N != int.MaxValue)
                        {
                            regexNode.N = ((regexNode2.N == int.MaxValue) ? int.MaxValue : (regexNode.N + regexNode2.N));
                        }
                        num++;
                        continue;
                    }
                    break;
                }
            }
            list[num2++] = list[num];
            index = num;
            num++;
        }
        if (num2 < list.Count)
        {
            list.RemoveRange(num2, list.Count - num2);
        }
        static bool CanCombineCounts(int nodeMin, int nodeMax, int nextMin, int nextMax)
        {
            if (nodeMin == int.MaxValue || nextMin == int.MaxValue || (uint)(nodeMin + nextMin) >= 2147483647u)
            {
                return false;
            }
            if (nodeMax != int.MaxValue && nextMax != int.MaxValue && (uint)(nodeMax + nextMax) >= 2147483647u)
            {
                return false;
            }
            return true;
        }
    }

References System.Text.RegularExpressions.RegexNode.Children, System.Collections.Generic.Dictionary< TKey, TValue >.Count, System.index, and System.list.

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