EmitMatchCharacterClass()

void System.Text.RegularExpressions.RegexCompiler.EmitMatchCharacterClass ( string charClass, bool caseInsensitive )

inlineprivateinherited

Definition at line 3892 of file RegexCompiler.cs.

    {
        switch (charClass)
        {
        case "\0\u0001\0\0":
            Pop();
            Ldc(1);
            return;
        case "\0\0\u0001\t":
            Call(s_charIsDigitMethod);
            return;
        case "\0\0\u0001\ufff7":
            Call(s_charIsDigitMethod);
            Ldc(0);
            Ceq();
            return;
        case "\0\0\u0001d":
            Call(s_charIsWhiteSpaceMethod);
            return;
        case "\u0001\0\u0001d":
            Call(s_charIsWhiteSpaceMethod);
            Ldc(0);
            Ceq();
            return;
        }
        bool invariant = false;
        if (caseInsensitive)
        {
            invariant = UseToLowerInvariant;
            if (!invariant)
            {
                CallToLower();
            }
        }
        if (!invariant && RegexCharClass.TryGetSingleRange(charClass, out var lowInclusive, out var highInclusive))
        {
            if (lowInclusive == highInclusive)
            {
                Ldc(lowInclusive);
                Ceq();
            }
            else
            {
                Ldc(lowInclusive);
                Sub();
                Ldc(highInclusive - lowInclusive + 1);
                CltUn();
            }
            if (RegexCharClass.IsNegated(charClass))
            {
                Ldc(0);
                Ceq();
            }
            return;
        }
        if (!invariant && RegexCharClass.TryGetSingleUnicodeCategory(charClass, out var category, out var negated))
        {
            Call(s_charGetUnicodeInfo);
            Ldc((int)category);
            Ceq();
            if (negated)
            {
                Ldc(0);
                Ceq();
            }
            return;
        }
        RentedLocalBuilder tempLocal = RentInt32Local();
        RentedLocalBuilder resultLocal;
        try
        {
            Stloc(tempLocal);
            if (!invariant)
            {
                Span<char> chars = stackalloc char[3];
                int setChars = RegexCharClass.GetSetChars(charClass, chars);
                if (setChars > 0 && !RegexCharClass.IsNegated(charClass))
                {
                    Ldloc(tempLocal);
                    Ldc(chars[0]);
                    Ceq();
                    Ldloc(tempLocal);
                    Ldc(chars[1]);
                    Ceq();
                    Or();
                    if (setChars == 3)
                    {
                        Ldloc(tempLocal);
                        Ldc(chars[2]);
                        Ceq();
                        Or();
                    }
                    return;
                }
            }
            resultLocal = RentInt32Local();
            try
            {
                RegexCharClass.CharClassAnalysisResults charClassAnalysisResults = RegexCharClass.Analyze(charClass);
                Label l = DefineLabel();
                Label l2 = DefineLabel();
                if (!invariant)
                {
                    if (charClassAnalysisResults.ContainsNoAscii)
                    {
                        Ldloc(tempLocal);
                        Ldc(128);
                        Blt(l2);
                        EmitCharInClass();
                        Br(l);
                        MarkLabel(l2);
                        Ldc(0);
                        Stloc(resultLocal);
                        MarkLabel(l);
                        Ldloc(resultLocal);
                        return;
                    }
                    if (charClassAnalysisResults.AllAsciiContained)
                    {
                        Ldloc(tempLocal);
                        Ldc(128);
                        Blt(l2);
                        EmitCharInClass();
                        Br(l);
                        MarkLabel(l2);
                        Ldc(1);
                        Stloc(resultLocal);
                        MarkLabel(l);
                        Ldloc(resultLocal);
                        return;
                    }
                }
                string str = string.Create(8, (charClass, invariant), delegate(Span<char> dest, (string charClass, bool invariant) state)
                {
                    for (int i = 0; i < 128; i++)
                    {
                        char c = (char)i;
                        if (state.invariant ? RegexCharClass.CharInClass(char.ToLowerInvariant(c), state.charClass) : RegexCharClass.CharInClass(c, state.charClass))
                        {
                            dest[i >> 4] |= (char)(ushort)(1 << (i & 0xF));
                        }
                    }
                });
                Ldloc(tempLocal);
                Ldc(128);
                Bge(l2);
                Ldstr(str);
                Ldloc(tempLocal);
                Ldc(4);
                Shr();
                Call(s_stringGetCharsMethod);
                Ldc(1);
                Ldloc(tempLocal);
                Ldc(15);
                And();
                Ldc(31);
                And();
                Shl();
                And();
                Ldc(0);
                CgtUn();
                Stloc(resultLocal);
                Br(l);
                MarkLabel(l2);
                if (charClassAnalysisResults.ContainsOnlyAscii)
                {
                    Ldc(0);
                    Stloc(resultLocal);
                }
                else if (charClassAnalysisResults.AllNonAsciiContained)
                {
                    Ldc(1);
                    Stloc(resultLocal);
                }
                else
                {
                    EmitCharInClass();
                }
                MarkLabel(l);
                Ldloc(resultLocal);
            }
            finally
            {
                ((IDisposable)resultLocal).Dispose();
            }
        }
        finally
        {
            ((IDisposable)tempLocal).Dispose();
        }
        void EmitCharInClass()
        {
            Ldloc(tempLocal);
            if (invariant)
            {
                CallToLower();
            }
            Ldstr(charClass);
            Call(s_charInClassMethod);
            Stloc(resultLocal);
        }
    }

References System.Text.RegularExpressions.RegexCharClass.Analyze(), System.Text.RegularExpressions.RegexCompiler.And(), System.Reflection.Emit.Bge, System.Reflection.Emit.Blt, System.Reflection.Emit.Br, System.Reflection.Emit.Call, System.Text.RegularExpressions.RegexCompiler.CallToLower(), System.Text.RegularExpressions.RegexCompiler.Ceq(), System.Text.RegularExpressions.RegexCompiler.CgtUn(), System.Text.RegularExpressions.RegexCharClass.CharInClass(), System.chars, System.Text.RegularExpressions.RegexCompiler.CltUn(), System.Text.RegularExpressions.RegexCompiler.DefineLabel(), System.Text.RegularExpressions.RegexCharClass.GetSetChars(), System.Text.RegularExpressions.i, System.Text.RegularExpressions.RegexCharClass.IsNegated(), System.Text.RegularExpressions.RegexCompiler.Ldc(), System.Reflection.Emit.Ldloc, System.Reflection.Emit.Ldstr, System.Text.RegularExpressions.RegexCompiler.MarkLabel(), System.Text.RegularExpressions.RegexCompiler.Or(), System.Text.RegularExpressions.RegexCompiler.Pop(), System.Text.RegularExpressions.RegexCompiler.RentInt32Local(), System.Text.RegularExpressions.RegexCompiler.s_charGetUnicodeInfo, System.Text.RegularExpressions.RegexCompiler.s_charInClassMethod, System.Text.RegularExpressions.RegexCompiler.s_charIsDigitMethod, System.Text.RegularExpressions.RegexCompiler.s_charIsWhiteSpaceMethod, System.Text.RegularExpressions.RegexCompiler.s_stringGetCharsMethod, System.Text.RegularExpressions.RegexCompiler.Shl(), System.Text.RegularExpressions.RegexCompiler.Shr(), System.state, System.Reflection.Emit.Stloc, System.Text.RegularExpressions.str, System.Text.RegularExpressions.RegexCompiler.Sub(), System.Text.RegularExpressions.RegexCharClass.TryGetSingleRange(), System.Text.RegularExpressions.RegexCharClass.TryGetSingleUnicodeCategory(), and System.Text.RegularExpressions.RegexCompiler.UseToLowerInvariant.

Referenced by System.Text.RegularExpressions.RegexCompiler.GenerateFindFirstChar(), System.Text.RegularExpressions.RegexCompiler.GenerateOneCode(), and System.Text.RegularExpressions.RegexCompiler.TryGenerateNonBacktrackingGo().