ComputeMultipleCharClasses()

static string bool CaseInsensitive[] System.Text.RegularExpressions.RegexPrefixAnalyzer.ComputeMultipleCharClasses ( RegexTree tree, int maxChars )

inlinestatic

Definition at line 101 of file RegexPrefixAnalyzer.cs.

    {
        if ((tree.Options & RegexOptions.RightToLeft) != 0)
        {
            return null;
        }
        maxChars = Math.Min(tree.MinRequiredLength, maxChars);
        if (maxChars <= 1)
        {
            return null;
        }
        RegexNode regexNode = tree.Root;
        while (regexNode.Type != 24)
        {
            int type = regexNode.Type;
            if (type == 25 || type == 28 || type == 32)
            {
                regexNode = regexNode.Child(0);
                continue;
            }
            return null;
        }
        RegexCharClass[] array = new RegexCharClass[maxChars];
        bool flag = false;
        int num = regexNode.ChildCount();
        for (int i = 0; i < num; i++)
        {
            RegexNode regexNode2 = regexNode.Child(i);
            flag |= (regexNode2.Options & RegexOptions.IgnoreCase) != 0;
            switch (regexNode2.Type)
            {
            case 12:
            {
                maxChars = Math.Min(maxChars, regexNode2.Str.Length);
                for (int l = 0; l < maxChars; l++)
                {
                    ref RegexCharClass reference = ref array[l];
                    (reference ?? (reference = new RegexCharClass())).AddChar(regexNode2.Str[l]);
                }
                break;
            }
            case 25:
            {
                int num2 = 0;
                int num3 = regexNode2.ChildCount();
                for (int j = 0; j < num3; j++)
                {
                    if (num2 >= array.Length)
                    {
                        break;
                    }
                    RegexNode regexNode3 = regexNode2.Child(j);
                    flag |= (regexNode3.Options & RegexOptions.IgnoreCase) != 0;
                    switch (regexNode3.Type)
                    {
                    case 9:
                    {
                        ref RegexCharClass reference = ref array[num2++];
                        (reference ?? (reference = new RegexCharClass())).AddChar(regexNode3.Ch);
                        break;
                    }
                    case 11:
                    {
                        ref RegexCharClass reference = ref array[num2++];
                        if (!(reference ?? (reference = new RegexCharClass())).TryAddCharClass(RegexCharClass.Parse(regexNode3.Str)))
                        {
                            return null;
                        }
                        break;
                    }
                    case 12:
                    {
                        for (int k = 0; k < regexNode3.Str.Length; k++)
                        {
                            if (num2 >= array.Length)
                            {
                                break;
                            }
                            ref RegexCharClass reference = ref array[num2++];
                            (reference ?? (reference = new RegexCharClass())).AddChar(regexNode3.Str[k]);
                        }
                        break;
                    }
                    default:
                        j = num3;
                        break;
                    }
                }
                maxChars = Math.Min(maxChars, num2);
                break;
            }
            default:
                return null;
            }
        }
        for (int m = 0; m < maxChars; m++)
        {
            if (array[m] == null)
            {
                maxChars = m;
                break;
            }
        }
        if (maxChars == 0)
        {
            return null;
        }
        (string, bool)[] array2 = new(string, bool)[maxChars];
        CultureInfo culture = null;
        if (flag)
        {
            culture = (((tree.Options & RegexOptions.CultureInvariant) != 0) ? CultureInfo.InvariantCulture : CultureInfo.CurrentCulture);
        }
        for (int n = 0; n < array2.Length; n++)
        {
            if (flag)
            {
                array[n].AddLowercase(culture);
            }
            array2[n] = (array[n].ToStringClass(), flag);
        }
        return array2;
    }

References System.Text.RegularExpressions.array, System.culture, System.Globalization.CultureInfo.CurrentCulture, System.Text.RegularExpressions.i, System.Math.Min(), System.Text.RegularExpressions.RegexCharClass.Parse(), and System.type.

Referenced by System.Text.RegularExpressions.RegexWriter.RegexCodeFromRegexTree().