EmitFragment()

void System.Text.RegularExpressions.RegexWriter.EmitFragment ( int nodetype, RegexNode node, int curIndex )

inlineprivate

Definition at line 180 of file RegexWriter.cs.

    {
        int num = 0;
        if (node.UseOptionR())
        {
            num |= 0x40;
        }
        if ((node.Options & RegexOptions.IgnoreCase) != 0)
        {
            num |= 0x200;
        }
        switch (nodetype)
        {
        case 88:
            if (curIndex < node.ChildCount() - 1)
            {
                _intStack.Append(_emitted.Length);
                Emit(23, 0);
            }
            break;
        case 152:
            if (curIndex < node.ChildCount() - 1)
            {
                int offset = _intStack.Pop();
                _intStack.Append(_emitted.Length);
                Emit(38, 0);
                PatchJump(offset, _emitted.Length);
            }
            else
            {
                for (int i = 0; i < curIndex; i++)
                {
                    PatchJump(_intStack.Pop(), _emitted.Length);
                }
            }
            break;
        case 97:
            if (curIndex == 0)
            {
                Emit(34);
                _intStack.Append(_emitted.Length);
                Emit(23, 0);
                Emit(37, MapCapnum(node.M));
                Emit(36);
            }
            break;
        case 161:
            switch (curIndex)
            {
            case 0:
            {
                int offset3 = _intStack.Pop();
                _intStack.Append(_emitted.Length);
                Emit(38, 0);
                PatchJump(offset3, _emitted.Length);
                Emit(36);
                if (node.ChildCount() > 1)
                {
                    break;
                }
                goto case 1;
            }
            case 1:
                PatchJump(_intStack.Pop(), _emitted.Length);
                break;
            }
            break;
        case 98:
            if (curIndex == 0)
            {
                Emit(34);
                Emit(31);
                _intStack.Append(_emitted.Length);
                Emit(23, 0);
            }
            break;
        case 162:
            switch (curIndex)
            {
            case 0:
                Emit(33);
                Emit(36);
                break;
            case 1:
            {
                int offset2 = _intStack.Pop();
                _intStack.Append(_emitted.Length);
                Emit(38, 0);
                PatchJump(offset2, _emitted.Length);
                Emit(33);
                Emit(36);
                if (node.ChildCount() > 2)
                {
                    break;
                }
                goto case 2;
            }
            case 2:
                PatchJump(_intStack.Pop(), _emitted.Length);
                break;
            }
            break;
        case 90:
        case 91:
            if (node.N < int.MaxValue || node.M > 1)
            {
                Emit((node.M == 0) ? 26 : 27, (node.M != 0) ? (1 - node.M) : 0);
            }
            else
            {
                Emit((node.M == 0) ? 30 : 31);
            }
            if (node.M == 0)
            {
                _intStack.Append(_emitted.Length);
                Emit(38, 0);
            }
            _intStack.Append(_emitted.Length);
            break;
        case 154:
        case 155:
        {
            int length = _emitted.Length;
            int num2 = nodetype - 154;
            if (node.N < int.MaxValue || node.M > 1)
            {
                Emit(28 + num2, _intStack.Pop(), (node.N == int.MaxValue) ? int.MaxValue : (node.N - node.M));
            }
            else
            {
                Emit(24 + num2, _intStack.Pop());
            }
            if (node.M == 0)
            {
                PatchJump(_intStack.Pop(), length);
            }
            break;
        }
        case 92:
            Emit(31);
            break;
        case 156:
            Emit(32, MapCapnum(node.M), MapCapnum(node.N));
            break;
        case 94:
            Emit(34);
            Emit(31);
            break;
        case 158:
            Emit(33);
            Emit(36);
            break;
        case 95:
            Emit(34);
            _intStack.Append(_emitted.Length);
            Emit(23, 0);
            break;
        case 159:
            Emit(35);
            PatchJump(_intStack.Pop(), _emitted.Length);
            Emit(36);
            break;
        case 96:
            Emit(34);
            break;
        case 160:
            Emit(36);
            break;
        case 9:
        case 10:
            Emit(node.Type | num, node.Ch);
            break;
        case 3:
        case 4:
        case 6:
        case 7:
        case 43:
        case 44:
            if (node.M > 0)
            {
                Emit(((node.Type != 3 && node.Type != 43 && node.Type != 6) ? 1 : 0) | num, node.Ch, node.M);
            }
            if (node.N > node.M)
            {
                Emit(node.Type | num, node.Ch, (node.N == int.MaxValue) ? int.MaxValue : (node.N - node.M));
            }
            break;
        case 5:
        case 8:
        case 45:
        {
            int opd = StringCode(node.Str);
            if (node.M > 0)
            {
                Emit(2 | num, opd, node.M);
            }
            if (node.N > node.M)
            {
                Emit(node.Type | num, opd, (node.N == int.MaxValue) ? int.MaxValue : (node.N - node.M));
            }
            break;
        }
        case 12:
            Emit(node.Type | num, StringCode(node.Str));
            break;
        case 11:
            Emit(node.Type | num, StringCode(node.Str));
            break;
        case 13:
            Emit(node.Type | num, MapCapnum(node.M));
            break;
        case 14:
        case 15:
        case 16:
        case 17:
        case 18:
        case 19:
        case 20:
        case 21:
        case 22:
        case 41:
        case 42:
        case 46:
            Emit(node.Type);
            break;
        default:
            throw new ArgumentException(System.SR.Format(System.SR.UnexpectedOpcode, nodetype.ToString()));
        case 23:
        case 89:
        case 93:
        case 153:
        case 157:
            break;
        }
    }

References System.Text.RegularExpressions.RegexWriter._emitted, System.Text.RegularExpressions.RegexWriter._intStack, System.Text.RegularExpressions.RegexWriter.Emit(), System.SR.Format(), System.Text.RegularExpressions.i, System.Text.RegularExpressions.length, System.Text.RegularExpressions.RegexWriter.MapCapnum(), System.offset, System.Text.RegularExpressions.RegexWriter.PatchJump(), System.Text.RegularExpressions.RegexWriter.StringCode(), and System.SR.UnexpectedOpcode.

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