private void ReadNumber()
{
if (Current == '0' && Peek(1) == 'x')
{
_position += 2; ReadNumberHex(); return;
}
if (Current == '0' && Peek(1) == 'b')
{
_position += 2; ReadNumberBinary(); return;
}
bool isFloat = false;
while (char.IsDigit(Current) || Current == '.')
{
_position++;
if (Current == '.')
{
isFloat = true;
}
}
var length = _position - _start;
var text = _text.ToString(_start, length);
object value = null;
if (isFloat)
{
if (!float.TryParse(text, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out float v))
{
var span = new TextSpan(_start, length);
var location = new TextLocation(_text, span);
_diagnostics.ReportInvalidNumber(location, text, TypeSymbol.Float);
}
value = v;
}
else
{
if (!int.TryParse(text, out var v))
{
var span = new TextSpan(_start, length);
var location = new TextLocation(_text, span);
_diagnostics.ReportInvalidNumber(location, text, TypeSymbol.Int);
}
value = v;
}
_value = value;
_kind = SyntaxKind.NumberToken;
}
private void ReadNumberToken()
{
while (char.IsDigit(Current))
{
Next();
}
var length = _position - _start;
var text = _text.ToString(_start, length);
if (!int.TryParse(text, out int value))
{
_diagnostics.ReportInvalidNumber(new TextSpan(_start, length), text, typeof(int));
}
_kind = SyntaxKind.LiteralToken;
_value = value;
}
private void ReadNumber()
{
do
{
_position++;
} while (Char.IsDigit(Current));
var textValue = _text.ToString(_start, _position - _start);
if (!Int32.TryParse(textValue, out var value))
{
_diagnostics.ReportInvalidNumber(new TextSpan(_start, _position - _start), textValue, TypeSymbol.Int);
}
_kind = SyntaxKind.NumberToken;
_value = value;
}
private void ReadNumber()
{
while (char.IsDigit(Current))
{
position++;
}
int length = position - start;
string txt = text.ToString(start, length);
if (!int.TryParse(txt, out int val))
{
diagnostics.ReportInvalidNumber(new TextSpan(start, length), txt, typeof(int));
}
value = val;
kind = NodeKind.NumberToken;
}
private void ReadNumberToken()
{
while (char.IsDigit(Current))
{
_position++;
}
var length = _position - _start;
var text = _text.ToString(_start, length);
if (!int.TryParse(text, out var value))
{
_diagnostics.ReportInvalidNumber(new TextSpan(_start, length), text, TypeSymbol.Int);
}
_value = value;
_kind = SyntaxKind.NumberToken;
}
private void ReadNumberToken()
{
while (char.IsDigit(Current))
{
Next();
}
int length = position - start;
string tokenText = text.ToString(start, length);
if (!int.TryParse(tokenText, out var tokenValue))
{
diagnostics.ReportInvalidNumber(new TextSpan(start, length), tokenText, TypeSymbol.Int);
}
value = tokenValue;
kind = SyntaxKind.NumberToken;
}
private void ReadNumberToken()
{
while (char.IsDigit(Current))
{
position++;
}
var length = position - start;
var t = text.ToString(start, length);
if (!int.TryParse(t, out int value))
{
diagnostics.ReportInvalidNumber(new TextSpan(position, length), t, typeof(int));
}
this.value = value;
kind = SyntaxKind.NumberToken;
}
//Break input into corresponding lexemes
public SyntaxToken Lex()
{
//End of File
if (_position >= _text.Length)
{
return(new SyntaxToken(TokenType.EndOfFile, _position, "\0", null));
}
var start = _position;
//Integer
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(TokenType.Number, 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(TokenType.Whitespace, start, text, null));
}
//True-False and catch-all identifiers
if (char.IsLetter(Current))
{
while (char.IsLetter(Current))
{
Next();
}
var length = _position - start;
var text = _text.Substring(start, length);
var kind = ParserRules.GetKeywordKind(text);
return(new SyntaxToken(kind, start, text, null));
}
//TODO refactor this for readability & scalability
//Operators - Arithmetic & Binary
switch (Current)
{
//Arithmetic Operators
case '+':
return(new SyntaxToken(TokenType.Plus, _position++, "+", null));
case '-':
return(new SyntaxToken(TokenType.Minus, _position++, "-", null));
case '*':
return(new SyntaxToken(TokenType.Star, _position++, "*", null));
case '/':
return(new SyntaxToken(TokenType.Slash, _position++, "/", null));
case '\\':
return(new SyntaxToken(TokenType.ReverseSlash, _position++, "/", null));
case '%':
return(new SyntaxToken(TokenType.Modulo, _position++, "%", null));
case '^':
return(new SyntaxToken(TokenType.BitwiseXor, _position++, "^", null));
case '#':
return(new SyntaxToken(TokenType.Power, _position++, "^", null));
//Boolean Operators
case '!':
{
switch (Ahead)
{
case '=':
_position += 2;
return(new SyntaxToken(TokenType.Negation, start, "!=", null));
default:
return(new SyntaxToken(TokenType.Negation, start, "!", null));
}
}
case '&':
{
switch (Ahead)
{
case '&':
_position += 2;
return(new SyntaxToken(TokenType.LogicalAnd, start, "&&", null));
default:
return(new SyntaxToken(TokenType.BitwiseAnd, _position++, "&", null));
}
}
case '|':
{
switch (Ahead)
{
case '|':
_position += 2;
return(new SyntaxToken(TokenType.LogicalOr, start, "||", null));
default:
return(new SyntaxToken(TokenType.BitwiseOr, _position++, "&", null));
}
}
case '=':
{
switch (Ahead)
{
//We haven't implemented the assignment operator
case '=':
_position += 2;
return(new SyntaxToken(TokenType.Equality, start, "==", null));
default:
return(new SyntaxToken(TokenType.Assign, _position++, "=", null));
}
}
case '>':
{
switch (Ahead)
{
case '=':
_position += 2;
return(new SyntaxToken(TokenType.GreaterThanEquals, start, ">=", null));
case '>':
_position += 2;
return(new SyntaxToken(TokenType.RightShift, start, ">>", null));
default:
return(new SyntaxToken(TokenType.GreaterThan, _position++, ">", null));
}
}
case '<':
{
switch (Ahead)
{
case '=':
_position += 2;
return(new SyntaxToken(TokenType.LessThanEquals, start, "<=", null));
case '<':
_position += 2;
return(new SyntaxToken(TokenType.LeftShift, start, "<<", null));
default:
return(new SyntaxToken(TokenType.LessThan, _position++, "<", null));
}
}
case '~':
return(new SyntaxToken(TokenType.BitwiseNegation, _position++, "~", null));
case '(':
return(new SyntaxToken(TokenType.OpenParenthesis, _position++, "(", null));
case ')':
return(new SyntaxToken(TokenType.CloseParenthesis, _position++, ")", null));
}
_diagnostics.ReportBadCharacter(_position, Current);
return(new SyntaxToken(TokenType.Bad, _position++, _text.Substring(_position - 1, 1), null));
}
public SyntaxToken Lex()
{
// numbers
// + - * / ()
//whitespace
if (_position >= _text.Length)
{
return(new SyntaxToken(SyntaxKind.EndOfFileToken, _position, "\0", null));
}
var start = _position;
//keep reading numbers, create word that represents the 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));
}
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));
}
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));
}
else
{
_position += 1;
return(new SyntaxToken(SyntaxKind.EqualsToken, 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.ReportBadCharacter(_position, Current);
return(new SyntaxToken(SyntaxKind.BadToken, _position++, _text.Substring(_position - 1, 1), null));
}
public SyntaxToken Lex()
{
if (_position >= _text.Length)
{
return(new SyntaxToken(SyntaxKind.EndOfFileToken, _position, "\0", null));
}
if (char.IsDigit(Current))
{
var start = _position;
var isHex = false;
while (char.IsDigit(Current))
{
Next();
}
if (char.IsUpper(Current))
{
isHex = true;
while (char.IsUpper(Current))
{
Next();
}
}
var length = _position - start;
var text = _text.Substring(start, length);
if (isHex == false)
{
if (!int.TryParse(text, out var value))
{
_diagnostics.ReportInvalidNumber(text, typeof(int));
}
}
return(isHex ||
text.Contains("8") ||
text.Contains("9")?
new SyntaxToken(SyntaxKind.HexToken, start, text, text)
:
new SyntaxToken(SyntaxKind.OctToken, start, text, text));
}
if (char.IsLetter(Current))
{
var start = _position;
if (char.IsUpper(Current))
{
while (char.IsUpper(Current))
{
Next();
}
if (char.IsDigit(Current))
{
while (char.IsDigit(Current))
{
Next();
}
}
var length = _position - start;
var text = _text.Substring(start, length);
// var kind = SyntaxFacts.GetKeywordKind(text);
return(new SyntaxToken(SyntaxKind.HexToken, start, text, text));
}
}
if (char.IsWhiteSpace(Current))
{
var start = _position;
while (char.IsWhiteSpace(Current))
{
Next();
}
var length = _position - start;
var text = _text.Substring(start, length);
return(new SyntaxToken(SyntaxKind.WhiteSpaceToken, start, text, null));
}
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 == '=') return new SyntaxToken(SyntaxKind.BangEqualsToken, _position +=2, "!=", null);
// else return new SyntaxToken(SyntaxKind.BangToken, _position++, "!", null);
// case '&':
// if (LookAhead == '&') return new SyntaxToken(SyntaxKind.AmpersandAmpersandToken, _position +=2, "&&", null);
// break;
// case '|':
// if (LookAhead == '|') return new SyntaxToken(SyntaxKind.PipePipeToken, _position +=2, "||", null);
// break;
// case '=':
// if (LookAhead == '=') return new SyntaxToken(SyntaxKind.EqualsEqualsToken, _position +=2, "==", null);
// break;
}
_diagnostics.ReportBadCharacter(_position, Current);
return(new SyntaxToken(SyntaxKind.BadToken, _position++, _text.Substring(_position - 1, 1), null));
}
public SyntaxToken Lex()
{
// <numbers>
// + - * / ()
// <whitespaces>
if (_position >= _text.Length)
{
return(new SyntaxToken(SyntaxKind.EndOfFileToken, _position, "\0", null));
}
var start = _position;
if (char.IsDigit(CurrentChar))
{
//var start = _position;
while (char.IsDigit(CurrentChar))
{
NextChar();
}
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));
//_diagnostics.Add($"The number {_text} is NOT a valid Int32.");
//var textHint = "[Hint]: (Int32 is an immutable value type that represents signed 32-bit integers with values that range from negative 2,147,483,648 through positive 2,147,483,647.)";
//_diagnostics.Add(textHint);
Console.WriteLine();
Console.WriteLine("[Hint]: (Int32 is an immutable value type that represents signed 32-bit integers with values that range from negative 2,147,483,648 through positive 2,147,483,647.)");
}
return(new SyntaxToken(SyntaxKind.NumberToken, start, text, value));
}
if (char.IsWhiteSpace(CurrentChar))
{
while (char.IsWhiteSpace(CurrentChar))
{
NextChar();
}
var length = _position - start;
var text = _text.Substring(start, length);
//int.TryParse(text, out var value);
return(new SyntaxToken(SyntaxKind.WhitespaceToken, start, text, null));
}
// True
// False
if (char.IsLetter(CurrentChar))
{
while (char.IsLetter(CurrentChar))
{
NextChar();
}
var length = _position - start;
var text = _text.Substring(start, length);
var kind = SyntaxFacts.GetKeywordKind(text);
//int.TryParse(text, out var value);
return(new SyntaxToken(kind, start, text, null));
}
switch (CurrentChar)
{
case '+':
{
return(new SyntaxToken(SyntaxKind.PlusToken, _position++, "+", null));
}
case '-':
{
return(new SyntaxToken(SyntaxKind.MinusToken, _position++, "-", null));
}
case '*':
{
return(new SyntaxToken(SyntaxKind.MultiplyToken, _position++, "*", null));
}
case '/':
{
return(new SyntaxToken(SyntaxKind.DivideToken, _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));
}
else
{
_position += 1;
return(new SyntaxToken(SyntaxKind.EqualsToken, start, "=", null));
}
}
case '!':
{
if (LookAhead == '=')
{
_position += 2;
return(new SyntaxToken(SyntaxKind.ExclamationEqualsToken, start, "!=", null));
}
else
{
_position += 1;
return(new SyntaxToken(SyntaxKind.ExclamationToken, start, "!", null));
}
}
}
_diagnostics.ReportBadCharacter(_position, CurrentChar);
return(new SyntaxToken(SyntaxKind.BadToken, _position++, _text.Substring(_position - 1, 1), null));
}
private void ReadNumberToken()
{
var decimalPointFound = false;
while (char.IsDigit(Current) || (Current == '.' && !decimalPointFound))
{
if (Current == '.')
{
decimalPointFound = true;
}
_position++;
}
var length = _position - _start;
var text = _text.ToString(_start, length);
var type = '\0';
if (Current is 'l' or 'f' or 'm')
{
type = Current;
_position++;
}
_type = TypeSymbol.Int;
switch (type)
{
case '\0':
if (int.TryParse(text, out var intValue))
{
_value = intValue;
_type = TypeSymbol.Int;
}
else if (double.TryParse(text, out var doubleValue))
{
_value = doubleValue;
_type = TypeSymbol.Double;
}
else
{
var span = new TextSpan(_start, length);
var location = new TextLocation(_text, span);
_diagnostics.ReportInvalidNumber(location, text, decimalPointFound ? TypeSymbol.Double : TypeSymbol.Int);
}
break;
case 'l':
if (decimalPointFound)
{
throw new Exception($"Invalid type specifier {type} for fixed point number");
}
if (long.TryParse(text, out var longValue))
{
_value = longValue;
_type = TypeSymbol.Long;
}
else
{
var span = new TextSpan(_start, length);
var location = new TextLocation(_text, span);
_diagnostics.ReportInvalidNumber(location, text, TypeSymbol.Long);
}
break;
case 'f':
if (!decimalPointFound)
{
throw new Exception($"Invalid type specifier {type} for floating point number");
}
if (float.TryParse(text, out var floatValue))
{
_value = floatValue;
_type = TypeSymbol.Float;
}
else
{
var span = new TextSpan(_start, length);
var location = new TextLocation(_text, span);
_diagnostics.ReportInvalidNumber(location, text, TypeSymbol.Float);
}
break;
case 'm':
if (decimal.TryParse(text, out var decimalValue))
{
_value = decimalValue;
_type = TypeSymbol.Decimal;
}
else
{
var span = new TextSpan(_start, length);
var location = new TextLocation(_text, span);
_diagnostics.ReportInvalidNumber(location, text, TypeSymbol.Decimal);
}
break;
default:
throw new Exception($"Unknown type specifier {type}");
}
_kind = SyntaxKind.NumberToken;
}
private void ReadNumber(bool startsWithNumber = false)
{
var isDouble = false;
var endsWithNumber = false;
while (true)
{
if (char.IsDigit(Current))
{
if (_position == _start)
{
startsWithNumber = true;
}
endsWithNumber = true;
_position++;
continue;
}
if (Current == '.')
{
endsWithNumber = false;
if (isDouble)
{
_position++;
break;
}
isDouble = true;
_position++;
continue;
}
break;
}
var length = _position - _start;
var text = _text.ToString(_start, length);
if (!endsWithNumber)
{
var span = new TextSpan(_start, length);
var location = new TextLocation(_text, span);
_diagnostics.ReportInvalidExpressionTerm(location, text);
_value = 0;
_kind = SyntaxKind.NumberToken;
}
if (isDouble)
{
if (!double.TryParse(text, out var doubleValue))
{
var span = new TextSpan(_start, length);
var location = new TextLocation(_text, span);
_diagnostics.ReportInvalidNumber(location, text, TypeSymbol.Double);
}
_value = doubleValue;
_kind = SyntaxKind.NumberToken;
}
else
{
if (!int.TryParse(text, out var intValue))
{
var span = new TextSpan(_start, length);
var location = new TextLocation(_text, span);
_diagnostics.ReportInvalidNumber(location, text, TypeSymbol.Int);
}
_value = intValue;
_kind = SyntaxKind.NumberToken;
}
}
internal SyntaxToken Lex()
{
_start = _position;
_kind = SyntaxKind.BadToken;
_value = null;
switch (Current)
{
case '\0':
{
_kind = SyntaxKind.EndOfFileToken;
break;
}
case '+':
{
MoveNext();
_kind = SyntaxKind.PlusToken;
break;
}
case '-':
{
MoveNext();
_kind = SyntaxKind.MinusToken;
break;
}
case '*':
{
MoveNext();
_kind = SyntaxKind.StarToken;
break;
}
case '/':
{
MoveNext();
_kind = SyntaxKind.ForwardSlashToken;
break;
}
case '(':
{
MoveNext();
_kind = SyntaxKind.OpenParenthesisToken;
break;
}
case ')':
{
MoveNext();
_kind = SyntaxKind.CloseParenthesisToken;
break;
}
case '{':
{
MoveNext();
_kind = SyntaxKind.OpenBraceToken;
break;
}
case '}':
{
MoveNext();
_kind = SyntaxKind.CloseBraceToken;
break;
}
case '~':
{
MoveNext();
_kind = SyntaxKind.TildeToken;
break;
}
case '^':
{
MoveNext();
_kind = SyntaxKind.HatToken;
break;
}
case '!':
{
if (LookAhead == '=')
{
MoveNext(2);
_kind = SyntaxKind.BangEqualsToken;
}
else
{
MoveNext();
_kind = SyntaxKind.BangToken;
}
break;
}
case '&':
{
if (LookAhead == '&')
{
MoveNext(2);
_kind = SyntaxKind.AndAndToken;
}
else
{
MoveNext();
_kind = SyntaxKind.AndToken;
}
break;
}
case '|':
{
if (LookAhead == '|')
{
MoveNext(2);
_kind = SyntaxKind.PipePipeToken;
}
else
{
MoveNext();
_kind = SyntaxKind.PipeToken;
}
break;
}
case '=':
{
if (LookAhead == '=')
{
MoveNext(2);
_kind = SyntaxKind.EqualsEqualsToken;
}
else
{
MoveNext();
_kind = SyntaxKind.EqualsToken;
}
break;
}
case '<':
{
if (LookAhead == '=')
{
MoveNext(2);
_kind = SyntaxKind.LessOrEqualsToken;
}
else
{
MoveNext();
_kind = SyntaxKind.LessToken;
}
break;
}
case '>':
{
if (LookAhead == '=')
{
MoveNext(2);
_kind = SyntaxKind.GreaterOrEqualsToken;
}
else
{
MoveNext();
_kind = SyntaxKind.GreaterToken;
}
break;
}
case '"':
{
ReadString();
break;
}
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
ReadNumbersToken();
break;
}
case ' ':
case '\t':
{
ReadWhitespaceTokens();
break;
}
default:
{
if (char.IsLetter(Current))
{
ReadLettersToken();
}
else if (char.IsWhiteSpace(Current))
{
ReadWhitespaceTokens();
}
else
{
_diagnostics.ReportBadCharacter(_position, Current);
MoveNext();
}
break;
}
}
{
var text = SyntaxFacts.GetText(_kind);
var length = _position - _start;
if (text is null)
{
text = _text.ToString(_start, length);
}
return(new SyntaxToken(_kind, _start, text, _value));
}
void ReadNumbersToken()
{
do
{
MoveNext();
}while (char.IsDigit(Current));
var length = _position - _start;
var text = _text.ToString(_start, length);
if (!int.TryParse(text, out var value))
{
_diagnostics.ReportInvalidNumber(new TextSpan(_start, length), text, TypeSymbol.Int);
}
_kind = SyntaxKind.NumberToken;
_value = value;
}
void ReadLettersToken()
{
do
{
MoveNext();
}while (char.IsLetter(Current));
var text = _text.ToString(_start, _position - _start);
_kind = SyntaxFacts.GetKeywordKind(text);
}
void ReadWhitespaceTokens()
{
do
{
MoveNext();
}while (char.IsWhiteSpace(Current));
_kind = SyntaxKind.WhiteSpaceToken;
}
void ReadString()
{
MoveNext();
var done = false;
var builder = new StringBuilder();
while (!done)
{
switch (Current)
{
case '\0':
case '\r':
case '\n':
var span = new TextSpan(_start, 1);
Diagnostics.ReportUnterminatedString(span);
done = true;
break;
case '\\':
{
if (LookAhead == '"')
{
MoveNext();
}
builder.Append(Current);
MoveNext();
break;
}
case '"':
{
done = true;
MoveNext();
break;
}
default:
{
builder.Append(Current);
MoveNext();
break;
}
}
}
_kind = SyntaxKind.StringToken;
_value = builder.ToString();
}
}