Ejemplo n.º 1
0
        public SyntaxToken Lex()
        {
            _start = _position;
            _kind  = SyntaxKind.BadToken;
            _value = null;

            switch (Current)
            {
            case '\0':
                _kind = SyntaxKind.EndOfFileToken;
                break;

            case '+':
                _kind = SyntaxKind.PlusToken;
                _position++;
                break;

            case '-':
                _kind = SyntaxKind.MinusToken;
                _position++;
                break;

            case '*':
                _position++;
                if (Current != '*')
                {
                    _kind = SyntaxKind.StarToken;
                }
                else
                {
                    _position++;
                    _kind = SyntaxKind.StarStarToken;
                }
                break;

            case '/':
                _kind = SyntaxKind.SlashToken;
                _position++;
                break;

            case '%':
                _kind = SyntaxKind.RemainderToken;
                _position++;
                break;

            case ':':
                _kind = SyntaxKind.ColonToken;
                _position++;
                break;

            case '<':
                _position++;
                if (Current != '=')
                {
                    _kind = SyntaxKind.LessThanToken;
                }
                else
                {
                    _position++;
                    _kind = SyntaxKind.LessOrEqualToken;
                }
                break;

            case '>':
                _position++;
                if (Current != '=')
                {
                    _kind = SyntaxKind.GreaterThanToken;
                }
                else
                {
                    _position++;
                    _kind = SyntaxKind.GreaterOrEqualToken;
                }
                break;

            case '(':
                _kind = SyntaxKind.OpenParenthesisToken;
                _position++;
                break;

            case ')':
                _kind = SyntaxKind.CloseParenthesisToken;
                _position++;
                break;

            case ',':
                _kind = SyntaxKind.CommaToken;
                _position++;
                break;

            case '~':
                _kind = SyntaxKind.TildToken;
                _position++;
                break;

            case '^':
                _kind = SyntaxKind.HatToken;
                _position++;
                break;

            case '{':
                _kind = SyntaxKind.OpenBraceToken;
                _position++;
                break;

            case '}':
                _kind = SyntaxKind.CloseBraceToken;
                _position++;
                break;

            case '&':
                _position++;
                if (Current != '&')
                {
                    _kind = SyntaxKind.AmpersandToken;
                }
                else
                {
                    _position++;
                    _kind = SyntaxKind.AmpersandAmpersandToken;
                }
                break;

            case '|':
                _position++;
                if (Current != '|')
                {
                    _kind = SyntaxKind.PipeToken;
                }
                else
                {
                    _position++;
                    _kind = SyntaxKind.PipePieToken;
                }
                break;

            case '=':
                _position++;
                if (Current != '=')
                {
                    _kind = SyntaxKind.EaqlesToken;
                }
                else
                {
                    _position++;
                    _kind = SyntaxKind.EaqulesEaqlesToken;
                }
                break;

            case '!':
                _position++;
                if (Current != '=')
                {
                    _kind = SyntaxKind.BangToken;
                }
                else
                {
                    _kind = SyntaxKind.BangEaqlesToken;
                    _position++;
                }
                break;

            case '\"':
                ReadString();
                break;

            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                ReadNumberToken();
                break;

            case ' ':
            case '\t':
            case '\n':
            case '\r':
                ReadWhiteSpace();
                break;

            default:
                if (char.IsLetter(Current))
                {
                    ReadIdentifierOrKeyword();
                }
                else if (char.IsWhiteSpace(Current))
                {
                    ReadWhiteSpace();
                }
                else
                {
                    _diagnostics.ReportBadCharactor(_position, Current);
                    _position++;
                }
                break;
            }

            var length = _position - _start;
            var text   = SyntaxFacts.GetText(_kind);

            if (text == null)
            {
                text = _text.ToString(_start, length);
            }

            return(new SyntaxToken(_kind, _start, text, _value));
        }
Ejemplo n.º 2
0
        public SyntaxToken Lex()
        {
            if (_position >= _text.Length)
            {
                return(new SyntaxToken(SyntaxKind.EndOfFileToken, _position, "\0", null));
            }

            var start = _position;

            // number
            if (char.IsDigit(Current))
            {
                while (char.IsDigit(Current))
                {
                    Next();
                }

                var length = _position - start;
                var text   = _text.Substring(start, length);
                if (!int.TryParse(text, out var value))
                {
                    _diagnostics.ReportInvalidNumber(new TextSpan(start, length), _text, typeof(int));
                }

                return(new SyntaxToken(SyntaxKind.NumberToken, start, text, value));
            }

            // whitespace
            if (char.IsWhiteSpace(Current))
            {
                while (char.IsWhiteSpace(Current))
                {
                    Next();
                }

                var length = _position - start;
                var text   = _text.Substring(start, length);

                return(new SyntaxToken(SyntaxKind.WhitespaceToken, start, text, null));
            }

            if (char.IsLetter(Current))
            {
                while (char.IsLetter(Current))
                {
                    Next();
                }

                var length = _position - start;
                var text   = _text.Substring(start, length);
                var kind   = SyntaxFacts.GetKeywordKind(text);

                return(new SyntaxToken(kind, start, text, null));
            }

            // operator
            switch (Current)
            {
            case '+':
                return(new SyntaxToken(SyntaxKind.PlusToken, _position++, "+", null));

            case '-':
                return(new SyntaxToken(SyntaxKind.MinusToken, _position++, "-", null));

            case '*':
                return(new SyntaxToken(SyntaxKind.StarToken, _position++, "*", null));

            case '/':
                return(new SyntaxToken(SyntaxKind.SlashToken, _position++, "/", null));

            case '(':
                return(new SyntaxToken(SyntaxKind.OpenParenthesisToken, _position++, "(", null));

            case ')':
                return(new SyntaxToken(SyntaxKind.CloseParenthesisToken, _position++, ")", null));

            case '&':
                if (Lookahead == '&')
                {
                    _position += 2;
                    return(new SyntaxToken(SyntaxKind.AmpersandAmpersandToken, start, "&&", null));
                }
                break;

            case '|':
                if (Lookahead == '|')
                {
                    _position += 2;
                    return(new SyntaxToken(SyntaxKind.PipePipeToken, start, "||", null));
                }
                break;

            case '=':
                if (Lookahead == '=')
                {
                    _position += 2;
                    return(new SyntaxToken(SyntaxKind.EqualsEqualsToken, start, "==", null));
                }
                break;

            case '!':
                if (Lookahead == '=')
                {
                    _position += 2;
                    return(new SyntaxToken(SyntaxKind.BangEqualsToken, start, "!=", null));
                }
                else
                {
                    _position += 1;
                    return(new SyntaxToken(SyntaxKind.BangToken, start, "!", null));
                }
            }

            _diagnostics.ReportBadCharactor(_position, Current);

            return(new SyntaxToken(SyntaxKind.BadToken, _position++, _text.Substring(_position - 1, 1), null));
        }