Exemplo n.º 1
0
        public string GetFirstChars(CultureInfo culture)
        {
            if (CaseInsensitive)
            {
                _cc.AddLowercase(culture);
            }

            return(_cc.ToStringClass());
        }
Exemplo n.º 2
0
        /*
         * Scans chars following a '\' (not counting the '\'), and returns
         * a RegexNode for the type of atom scanned.
         */
        internal RegexNode ScanBackslash()
        {
            char ch;
            RegexCharClass cc;

            if (CharsRight() == 0)
                throw MakeException(SR.IllegalEndEscape);

            switch (ch = RightChar())
            {
                case 'b':
                case 'B':
                case 'A':
                case 'G':
                case 'Z':
                case 'z':
                    MoveRight();
                    return new RegexNode(TypeFromCode(ch), _options);

                case 'w':
                    MoveRight();
                    if (UseOptionE())
                        return new RegexNode(RegexNode.Set, _options, RegexCharClass.ECMAWordClass);
                    return new RegexNode(RegexNode.Set, _options, RegexCharClass.WordClass);

                case 'W':
                    MoveRight();
                    if (UseOptionE())
                        return new RegexNode(RegexNode.Set, _options, RegexCharClass.NotECMAWordClass);
                    return new RegexNode(RegexNode.Set, _options, RegexCharClass.NotWordClass);

                case 's':
                    MoveRight();
                    if (UseOptionE())
                        return new RegexNode(RegexNode.Set, _options, RegexCharClass.ECMASpaceClass);
                    return new RegexNode(RegexNode.Set, _options, RegexCharClass.SpaceClass);

                case 'S':
                    MoveRight();
                    if (UseOptionE())
                        return new RegexNode(RegexNode.Set, _options, RegexCharClass.NotECMASpaceClass);
                    return new RegexNode(RegexNode.Set, _options, RegexCharClass.NotSpaceClass);

                case 'd':
                    MoveRight();
                    if (UseOptionE())
                        return new RegexNode(RegexNode.Set, _options, RegexCharClass.ECMADigitClass);
                    return new RegexNode(RegexNode.Set, _options, RegexCharClass.DigitClass);

                case 'D':
                    MoveRight();
                    if (UseOptionE())
                        return new RegexNode(RegexNode.Set, _options, RegexCharClass.NotECMADigitClass);
                    return new RegexNode(RegexNode.Set, _options, RegexCharClass.NotDigitClass);

                case 'p':
                case 'P':
                    MoveRight();
                    cc = new RegexCharClass();
                    cc.AddCategoryFromName(ParseProperty(), (ch != 'p'), UseOptionI(), _pattern);
                    if (UseOptionI())
                        cc.AddLowercase(_culture);

                    return new RegexNode(RegexNode.Set, _options, cc.ToStringClass());

                default:
                    return ScanBasicBackslash();
            }
        }
Exemplo n.º 3
0
    /*
     * Scans chars following a '\' (not counting the '\'), and returns
     * a RegexNode for the type of atom scanned.
     */
    private RegexNode ScanBackslash()
    {
        char           ch;
        RegexCharClass cc;

        if (CharsRight() == 0)
        {
            throw MakeException(Strings.IllegalEndEscape);
        }

        switch (ch = RightChar())
        {
        case 'b':
        case 'B':
        case 'A':
        case 'G':
        case 'Z':
        case 'z':
            MoveRight();
            return(new RegexNode(TypeFromCode(ch), _options));

        case 'w':
            MoveRight();
            if (UseOptionE())
            {
                return(new RegexNode(RegexNode.Set, _options, RegexCharClass.ECMAWordClass));
            }
            return(new RegexNode(RegexNode.Set, _options, RegexCharClass.WordClass));

        case 'W':
            MoveRight();
            if (UseOptionE())
            {
                return(new RegexNode(RegexNode.Set, _options, RegexCharClass.NotECMAWordClass));
            }
            return(new RegexNode(RegexNode.Set, _options, RegexCharClass.NotWordClass));

        case 's':
            MoveRight();
            if (UseOptionE())
            {
                return(new RegexNode(RegexNode.Set, _options, RegexCharClass.ECMASpaceClass));
            }
            return(new RegexNode(RegexNode.Set, _options, RegexCharClass.SpaceClass));

        case 'S':
            MoveRight();
            if (UseOptionE())
            {
                return(new RegexNode(RegexNode.Set, _options, RegexCharClass.NotECMASpaceClass));
            }
            return(new RegexNode(RegexNode.Set, _options, RegexCharClass.NotSpaceClass));

        case 'd':
            MoveRight();
            if (UseOptionE())
            {
                return(new RegexNode(RegexNode.Set, _options, RegexCharClass.ECMADigitClass));
            }
            return(new RegexNode(RegexNode.Set, _options, RegexCharClass.DigitClass));

        case 'D':
            MoveRight();
            if (UseOptionE())
            {
                return(new RegexNode(RegexNode.Set, _options, RegexCharClass.NotECMADigitClass));
            }
            return(new RegexNode(RegexNode.Set, _options, RegexCharClass.NotDigitClass));

        case 'p':
        case 'P':
            MoveRight();
            cc = new RegexCharClass();
            cc.AddCategoryFromName(ParseProperty(), ch != 'p', UseOptionI(), _pattern);
            if (UseOptionI())
            {
                cc.AddLowercase(_culture);
            }

            return(new RegexNode(RegexNode.Set, _options, cc.ToStringClass()));

        default:
            return(ScanBasicBackslash());
        }
    }