private void State_InSubscript()
        {
            if (IsAtEndOfInput)
            {
                _token = GenericTypeNameScannerToken.ERROR;
                _state = State.START;
                return;
            }

            switch (CurrentChar)
            {
            case Comma:
                AddToMultiCharToken();
                break;

            case CloseBracket:
                AddToMultiCharToken();
                _token = GenericTypeNameScannerToken.SUBSCRIPT;
                _state = State.START;
                break;

            default:
                if (IsWhitespaceChar(CurrentChar))
                {
                    AddToMultiCharToken();
                }
                else
                {
                    _token = GenericTypeNameScannerToken.ERROR;
                }
                break;
            }
            _lastChar = CurrentChar;
            Advance();
        }
Beispiel #2
0
 // Methods
 public GenericTypeNameScanner(string text, GenericTypeNamePartDelimeter customeGenericTypeNamePartDelimeter)
     : base(text)
 {
     this._state            = State.START;
     this._pushedBackSymbol = GenericTypeNameScannerToken.NONE;
     CustomeGenericTypeNamePartDelimeter = customeGenericTypeNamePartDelimeter;
 }
        public void Read()
        {
            if (_pushedBackSymbol != GenericTypeNameScannerToken.NONE)
            {
                _token            = _pushedBackSymbol;
                _pushedBackSymbol = GenericTypeNameScannerToken.NONE;
                return;
            }

            _token     = GenericTypeNameScannerToken.NONE;
            _tokenText = string.Empty;
            _multiCharTokenStartIdx = -1;
            _multiCharTokenLength   = 0;

            while (_token == GenericTypeNameScannerToken.NONE)
            {
                if (IsAtEndOfInput)
                {
                    if (_state == State.INNAME)
                    {
                        _token = GenericTypeNameScannerToken.NAME;
                        _state = State.START;
                    }
                    if (_state == State.INSUBSCRIPT)
                    {
                        _token = GenericTypeNameScannerToken.ERROR;
                        _state = State.START;
                    }
                    break;
                }

                switch (_state)
                {
                case State.START:
                    State_Start();
                    break;

                case State.INNAME:
                    State_InName();
                    break;

                case State.INSUBSCRIPT:
                    State_InSubscript();
                    break;
                }
            }
            if (_token == GenericTypeNameScannerToken.NAME || _token == GenericTypeNameScannerToken.SUBSCRIPT)
            {
                _tokenText = CollectMultiCharToken();
            }
        }
Beispiel #4
0
        private void State_InName( )
        {
            if ((base.IsAtEndOfInput || Sample_StringParserBase.IsWhitespaceChar(base.CurrentChar)) || (base.CurrentChar == '['))
            {
                this._token = GenericTypeNameScannerToken.NAME;
                this._state = State.START;
            }
            else
            {
                switch (base.CurrentChar)
                {
                case '(':
                    this._pushedBackSymbol = GenericTypeNameScannerToken.OPEN;
                    this._token            = GenericTypeNameScannerToken.NAME;
                    this._state            = State.START;
                    break;

                case ')':
                    this._pushedBackSymbol = GenericTypeNameScannerToken.CLOSE;
                    this._token            = GenericTypeNameScannerToken.NAME;
                    this._state            = State.START;
                    break;

                case ',':
                    this._pushedBackSymbol = GenericTypeNameScannerToken.COMMA;
                    this._token            = GenericTypeNameScannerToken.NAME;
                    this._state            = State.START;
                    break;

                case ':':
                    this._pushedBackSymbol = GenericTypeNameScannerToken.COLON;
                    this._token            = GenericTypeNameScannerToken.NAME;
                    this._state            = State.START;
                    break;

                default:
                    if (XamlName.IsValidQualifiedNameCharPlus(base.CurrentChar, CustomeGenericTypeNamePartDelimeter))
                    {
                        this.AddToMultiCharToken();
                    }
                    else
                    {
                        this._token = GenericTypeNameScannerToken.ERROR;
                    }
                    break;
                }
                this._lastChar = base.CurrentChar;
                base.Advance();
            }
        }
Beispiel #5
0
        public void Read( )
        {
            if (this._pushedBackSymbol != GenericTypeNameScannerToken.NONE)
            {
                this._token            = this._pushedBackSymbol;
                this._pushedBackSymbol = GenericTypeNameScannerToken.NONE;
            }
            else
            {
                this._token     = GenericTypeNameScannerToken.NONE;
                this._tokenText = string.Empty;
                this._multiCharTokenStartIdx = -1;
                this._multiCharTokenLength   = 0;
                while (this._token == GenericTypeNameScannerToken.NONE)
                {
                    if (base.IsAtEndOfInput)
                    {
                        if (this._state == State.INNAME)
                        {
                            this._token = GenericTypeNameScannerToken.NAME;
                            this._state = State.START;
                        }
                        if (this._state == State.INSUBSCRIPT)
                        {
                            this._token = GenericTypeNameScannerToken.ERROR;
                            this._state = State.START;
                        }
                        break;
                    }
                    switch (this._state)
                    {
                    case State.START:
                        this.State_Start();
                        break;

                    case State.INNAME:
                        this.State_InName();
                        break;

                    case State.INSUBSCRIPT:
                        this.State_InSubscript();
                        break;
                    }
                }
                if ((this._token == GenericTypeNameScannerToken.NAME) || (this._token == GenericTypeNameScannerToken.SUBSCRIPT))
                {
                    this._tokenText = this.CollectMultiCharToken();
                }
            }
        }
        private void State_InName()
        {
            if (IsAtEndOfInput || IsWhitespaceChar(CurrentChar) || CurrentChar == OpenBracket)
            {
                _token = GenericTypeNameScannerToken.NAME;
                _state = State.START;
                return;
            }

            switch (CurrentChar)
            {
            case OpenParen:
                _pushedBackSymbol = GenericTypeNameScannerToken.OPEN;
                _token            = GenericTypeNameScannerToken.NAME;
                _state            = State.START;
                break;

            case CloseParen:
                _pushedBackSymbol = GenericTypeNameScannerToken.CLOSE;
                _token            = GenericTypeNameScannerToken.NAME;
                _state            = State.START;
                break;

            case Comma:
                _pushedBackSymbol = GenericTypeNameScannerToken.COMMA;
                _token            = GenericTypeNameScannerToken.NAME;
                _state            = State.START;
                break;

            case Colon:
                _pushedBackSymbol = GenericTypeNameScannerToken.COLON;
                _token            = GenericTypeNameScannerToken.NAME;
                _state            = State.START;
                break;

            default:
                if (XamlName.IsValidQualifiedNameChar(CurrentChar))
                {
                    AddToMultiCharToken();
                    // No _token set so continue to scan.
                }
                else
                {
                    _token = GenericTypeNameScannerToken.ERROR;
                }
                break;
            }
            _lastChar = CurrentChar;
            Advance();
        }
        private void State_Start()
        {
            AdvanceOverWhitespace();
            if (IsAtEndOfInput)
            {
                _token = GenericTypeNameScannerToken.NONE;
                return;
            }

            switch (CurrentChar)
            {
            case OpenParen:
                _token = GenericTypeNameScannerToken.OPEN;
                break;

            case CloseParen:
                _token = GenericTypeNameScannerToken.CLOSE;
                break;

            case Comma:
                _token = GenericTypeNameScannerToken.COMMA;
                break;

            case Colon:
                _token = GenericTypeNameScannerToken.COLON;
                break;

            case OpenBracket:
                StartMultiCharToken();
                _state = State.INSUBSCRIPT;
                // No _token set so continue to scan.
                break;

            default:
                if (XamlName.IsValidNameStartChar(CurrentChar))
                {
                    StartMultiCharToken();
                    _state = State.INNAME;
                    // No _token set so continue to scan.
                }
                else
                {
                    _token = GenericTypeNameScannerToken.ERROR;
                }
                break;
            }
            _lastChar = CurrentChar;
            Advance();
        }
Beispiel #8
0
        private void State_Start( )
        {
            base.AdvanceOverWhitespace();
            if (base.IsAtEndOfInput)
            {
                this._token = GenericTypeNameScannerToken.NONE;
            }
            else
            {
                switch (base.CurrentChar)
                {
                case '(':
                    this._token = GenericTypeNameScannerToken.OPEN;
                    break;

                case ')':
                    this._token = GenericTypeNameScannerToken.CLOSE;
                    break;

                case ',':
                    this._token = GenericTypeNameScannerToken.COMMA;
                    break;

                case ':':
                    this._token = GenericTypeNameScannerToken.COLON;
                    break;

                case '[':
                    this.StartMultiCharToken();
                    this._state = State.INSUBSCRIPT;
                    break;

                default:
                    if (XamlName.IsValidNameStartChar(base.CurrentChar))
                    {
                        this.StartMultiCharToken();
                        this._state = State.INNAME;
                    }
                    else
                    {
                        this._token = GenericTypeNameScannerToken.ERROR;
                    }
                    break;
                }
                this._lastChar = base.CurrentChar;
                base.Advance();
            }
        }
        public void Read ()
        {
            if (this._pushedBackSymbol != GenericTypeNameScannerToken.NONE) {
                this._token = this._pushedBackSymbol;
                this._pushedBackSymbol = GenericTypeNameScannerToken.NONE;
            }
            else {
                this._token = GenericTypeNameScannerToken.NONE;
                this._tokenText = string.Empty;
                this._multiCharTokenStartIdx = -1;
                this._multiCharTokenLength = 0;
                while (this._token == GenericTypeNameScannerToken.NONE) {
                    if (base.IsAtEndOfInput) {
                        if (this._state == State.INNAME) {
                            this._token = GenericTypeNameScannerToken.NAME;
                            this._state = State.START;
                        }
                        if (this._state == State.INSUBSCRIPT) {
                            this._token = GenericTypeNameScannerToken.ERROR;
                            this._state = State.START;
                        }
                        break;
                    }
                    switch (this._state) {
                        case State.START:
                            this.State_Start();
                            break;

                        case State.INNAME:
                            this.State_InName();
                            break;

                        case State.INSUBSCRIPT:
                            this.State_InSubscript();
                            break;
                    }
                }
                if ((this._token == GenericTypeNameScannerToken.NAME) || (this._token == GenericTypeNameScannerToken.SUBSCRIPT)) {
                    this._tokenText = this.CollectMultiCharToken();
                }
            }
        }
Beispiel #10
0
        private void State_InSubscript( )
        {
            if (base.IsAtEndOfInput)
            {
                this._token = GenericTypeNameScannerToken.ERROR;
                this._state = State.START;
            }
            else
            {
                switch (base.CurrentChar)
                {
                case ',':
                    this.AddToMultiCharToken();
                    break;

                case ']':
                    this.AddToMultiCharToken();
                    this._token = GenericTypeNameScannerToken.SUBSCRIPT;
                    this._state = State.START;
                    break;

                default:
                    if (Sample_StringParserBase.IsWhitespaceChar(base.CurrentChar))
                    {
                        this.AddToMultiCharToken();
                    }
                    else
                    {
                        this._token = GenericTypeNameScannerToken.ERROR;
                    }
                    break;
                }
                this._lastChar = base.CurrentChar;
                base.Advance();
            }
        }
        private void State_Start()
        {
            base.AdvanceOverWhitespace();
            if (base.IsAtEndOfInput)
            {
                this._token = GenericTypeNameScannerToken.NONE;
            }
            else
            {
                switch (base.CurrentChar)
                {
                    case '(':
                        this._token = GenericTypeNameScannerToken.OPEN;
                        break;

                    case ')':
                        this._token = GenericTypeNameScannerToken.CLOSE;
                        break;

                    case ',':
                        this._token = GenericTypeNameScannerToken.COMMA;
                        break;

                    case ':':
                        this._token = GenericTypeNameScannerToken.COLON;
                        break;

                    case '[':
                        this.StartMultiCharToken();
                        this._state = State.INSUBSCRIPT;
                        break;

                    default:
                        if (XamlName.IsValidNameStartChar(base.CurrentChar))
                        {
                            this.StartMultiCharToken();
                            this._state = State.INNAME;
                        }
                        else
                        {
                            this._token = GenericTypeNameScannerToken.ERROR;
                        }
                        break;
                }
                this._lastChar = base.CurrentChar;
                base.Advance();
            }
        }
 public GenericTypeNameScanner(string text) : base(text)
 {
     this._state = State.START;
     this._pushedBackSymbol = GenericTypeNameScannerToken.NONE;
 }
        private void State_InSubscript()
        {
            if (base.IsAtEndOfInput)
            {
                this._token = GenericTypeNameScannerToken.ERROR;
                this._state = State.START;
            }
            else
            {
                switch (base.CurrentChar)
                {
                    case ',':
                        this.AddToMultiCharToken();
                        break;

                    case ']':
                        this.AddToMultiCharToken();
                        this._token = GenericTypeNameScannerToken.SUBSCRIPT;
                        this._state = State.START;
                        break;

                    default:
                        if (Sample_StringParserBase.IsWhitespaceChar(base.CurrentChar))
                        {
                            this.AddToMultiCharToken();
                        }
                        else
                        {
                            this._token = GenericTypeNameScannerToken.ERROR;
                        }
                        break;
                }
                this._lastChar = base.CurrentChar;
                base.Advance();
            }
        }
        private void State_InName()
        {
            if ((base.IsAtEndOfInput || Sample_StringParserBase.IsWhitespaceChar(base.CurrentChar)) || (base.CurrentChar == '['))
            {
                this._token = GenericTypeNameScannerToken.NAME;
                this._state = State.START;
            }
            else
            {
                switch (base.CurrentChar)
                {
                    case '(':
                        this._pushedBackSymbol = GenericTypeNameScannerToken.OPEN;
                        this._token = GenericTypeNameScannerToken.NAME;
                        this._state = State.START;
                        break;

                    case ')':
                        this._pushedBackSymbol = GenericTypeNameScannerToken.CLOSE;
                        this._token = GenericTypeNameScannerToken.NAME;
                        this._state = State.START;
                        break;

                    case ',':
                        this._pushedBackSymbol = GenericTypeNameScannerToken.COMMA;
                        this._token = GenericTypeNameScannerToken.NAME;
                        this._state = State.START;
                        break;

                    case ':':
                        this._pushedBackSymbol = GenericTypeNameScannerToken.COLON;
                        this._token = GenericTypeNameScannerToken.NAME;
                        this._state = State.START;
                        break;

                    default:
                        if (XamlName.IsValidQualifiedNameChar(base.CurrentChar))
                        {
                            this.AddToMultiCharToken();
                        }
                        else
                        {
                            this._token = GenericTypeNameScannerToken.ERROR;
                        }
                        break;
                }
                this._lastChar = base.CurrentChar;
                base.Advance();
            }
        }
 public GenericTypeNameScanner(string text)
     : base(text)
 {
     _state            = State.START;
     _pushedBackSymbol = GenericTypeNameScannerToken.NONE;
 }