private bool ParseText(ITextChars tc, ref CharPos pos)
{
while (!tc.EndOfLine)
{
// multi-line comment
if (tc.Char() == '/' && tc.NChar() == '*')
{
this.status = stMultiLineComment;
tc.Skip(2);
this.ParseMultiLineComment(tc);
}
else if (tc.Char() == '/' && tc.NChar() == '/')
{
tc.SkipRemainder();
}
else if (tc.Char() == '@' && tc.NChar() == '"')
{
this.status = stMultiLineString;
tc.Skip(2);
this.ParseMultiLineString(tc);
}
else if (tc.Char() == '$' && tc.NChar() == '"')
{
// Roslyn interpolated string
this.parsingExpression = false;
this.status = stIString;
tc.Skip(2);
return(this.ParseInterpolatedString(tc, ref pos));
}
else if (tc.Char() == '$' && tc.NChar() == '@' && tc.NNChar() == '"')
{
this.status = stMultiLineString;
tc.Skip(3);
this.ParseMultiLineString(tc);
}
else if (tc.Char() == '"')
{
this.status = stString;
tc.Next();
this.ParseString(tc);
}
else if (tc.Char() == '\'')
{
this.status = stString;
tc.Next();
this.ParseCharLiteral(tc);
}
else if (this.BraceList.IndexOf(tc.Char()) >= 0)
{
pos = new CharPos(tc.Char(), tc.AbsolutePosition, EncodedState());
tc.Next();
return(true);
}
else
{
tc.Next();
}
}
return(false);
}
public string Parse(ITextChars tc)
{
while (!tc.EndOfLine && Char.IsWhiteSpace(tc.Char()))
{
tc.Next();
}
if (tc.EndOfLine)
{
return(null);
}
if (tc.Char() == '/' && tc.NChar() == '*')
{
tc.Skip(2);
// multiline comment
StringBuilder sb = new StringBuilder();
while (!tc.EndOfLine && tc.Char() != '*' && tc.NChar() != '/')
{
sb.Append(tc.Char());
tc.Next();
}
return(sb.ToString());
}
else if (tc.Char() == '-' && tc.NChar() == '-')
{
tc.Skip(2);
// single line comment
return(tc.GetRemainder());
}
return(null);
}
private bool ParseText(ITextChars tc, ref CharPos pos)
{
while (!tc.EndOfLine)
{
// multi-line comment
if (tc.Char() == '<' && tc.NChar() == '#')
{
this.status = stMultiLineComment;
tc.Skip(2);
this.ParseMultiLineComment(tc);
}
else if (tc.Char() == '#')
{
tc.SkipRemainder();
}
else if (tc.Char() == '@' && tc.NChar() == '\'')
{
this.status = stHereString;
tc.Skip(2);
this.ParseHereString(tc);
}
else if (tc.Char() == '@' && tc.NChar() == '"')
{
this.status = stHereExpandableString;
tc.Skip(2);
this.ParseHereExpandableString(tc);
}
else if (tc.Char() == '"')
{
this.status = stString;
tc.Next();
this.ParseExpandableString(tc);
}
else if (tc.Char() == '\'')
{
this.status = stString;
tc.Next();
this.ParseString(tc);
}
else if (this.BraceList.IndexOf(tc.Char()) >= 0)
{
pos = new CharPos(tc.Char(), tc.AbsolutePosition);
tc.Next();
return(true);
}
else
{
tc.Next();
}
}
return(false);
}
private IEnumerable <CharPos> ParseText(ITextChars tc)
{
while (!tc.EndOfLine)
{
// multi-line comment
if (tc.Char() == '<' && tc.NChar() == '#')
{
this.status = stMultiLineComment;
tc.Skip(2);
this.ParseMultiLineComment(tc);
}
else if (tc.Char() == '#')
{
tc.SkipRemainder();
}
else if (tc.Char() == '@' && tc.NChar() == '\'')
{
this.status = stHereString;
tc.Skip(2);
this.ParseHereString(tc);
}
else if (tc.Char() == '@' && tc.NChar() == '"')
{
this.status = stHereExpandableString;
tc.Skip(2);
this.ParseHereExpandableString(tc);
}
else if (tc.Char() == '"')
{
this.status = stString;
tc.Next();
this.ParseExpandableString(tc);
}
else if (tc.Char() == '\'')
{
this.status = stString;
tc.Next();
this.ParseString(tc);
}
else if (lang.BraceList.IndexOf(tc.Char()) >= 0)
{
yield return(new CharPos(tc.Char(), tc.AbsolutePosition));
tc.Next();
}
else
{
tc.Next();
}
}
}
private void ParseHereExpandableString(ITextChars tc)
{
while ( !tc.EndOfLine ) {
if ( tc.Char() == '`' ) {
// skip over escape sequences
tc.Skip(2);
} else if ( tc.Char() == '"' && tc.NChar() == '@' ) {
tc.Skip(2);
break;
} else {
tc.Next();
}
}
this.status = stText;
}
private IEnumerable <CharPos> ParseText(ITextChars tc)
{
while (!tc.EndOfLine)
{
if (tc.Char() == '#')
{
tc.SkipRemainder();
}
else if ((tc.Char() == '"' && tc.NChar() == '"' && tc.NNChar() == '"') ||
(tc.Char() == '\'' && tc.NChar() == '\'' && tc.NNChar() == '\''))
{
this.status = stMultiLineString;
this.quoteChar = tc.Char();
tc.Skip(3);
this.ParseMultiLineString(tc);
}
else if (tc.Char() == '\'' || tc.Char() == '"')
{
this.status = stString;
this.quoteChar = tc.Char();
tc.Next();
this.ParseString(tc);
}
else if (lang.BraceList.IndexOf(tc.Char()) >= 0)
{
yield return(new CharPos(tc.Char(), tc.AbsolutePosition));
tc.Next();
}
else
{
tc.Next();
}
}
}
private void ParseCharLiteral(ITextChars tc)
{
// valid:
// - 'a'
// - '\b'
// - '\uaaaa'
// - '()
// not valid:
// - 'a,
// - 'a
// - 'a)
// mark is just after the opening '
if ( tc.Char() == '\\' ) {
// skip until next quote
tc.Skip(2);
while ( !tc.EndOfLine && tc.Char() != '\'' ) {
tc.Next();
}
tc.Next();
} else {
// skip the first char, as it's going to be a literal
// however, if the next char isn't a ', assume
// this is a generic declaration
tc.Next();
if ( tc.Char() == '\'' ) {
tc.Next();
}
}
this.status = stText;
}
private void ParseCharLiteral(ITextChars tc)
{
// valid:
// - 'a'
// - '\b'
// - '\uaaaa'
// - '()
// not valid:
// - 'a,
// - 'a
// - 'a)
// mark is just after the opening '
if (tc.Char() == '\\')
{
// skip until next quote
tc.Skip(2);
while (!tc.AtEnd && tc.Char() != '\'')
{
tc.Next();
}
tc.Next();
}
else
{
// skip the first char, as it's going to be a literal
// however, if the next char isn't a ', assume
// this is a generic declaration
tc.Next();
if (tc.Char() == '\'')
{
tc.Next();
}
}
this.status = stText;
}
public StringPart?Next()
{
while (!text.EndOfLine)
{
if (text.Char() == '\\')
{
return(BasicCStringScanner.ParseEscapeSequence(text));
}
else if (text.Char() == '%')
{
// skip %%
if (text.NChar() == '%')
{
text.Skip(2);
continue;
}
StringPart part = new StringPart();
if (ParseFormatSpecifier(ref part))
{
return(part);
}
}
text.Next();
}
return(null);
}
private bool ParseText(ITextChars tc, ref CharPos pos)
{
while (!tc.EndOfLine)
{
// multi-line comment
if (tc.Char() == '/' && tc.NChar() == '*')
{
this.status = stMultiLineComment;
tc.Skip(2);
this.ParseMultiLineComment(tc);
}
else if (tc.Char() == '/' && tc.NChar() == '/')
{
tc.SkipRemainder();
}
else if (tc.Char() == '"')
{
this.status = stString;
tc.Next();
this.ParseString(tc);
}
else if (Char.IsDigit(tc.Char()) && tc.NChar() == '\'')
{
// this is a C++ 14 digit separator, such as 1'000'000
tc.Skip(2);
}
else if (tc.Char() == '\'')
{
this.status = stString;
tc.Next();
this.ParseCharLiteral(tc);
}
else if (this.BraceList.IndexOf(tc.Char()) >= 0)
{
pos = new CharPos(tc.Char(), tc.AbsolutePosition);
tc.Next();
return(true);
}
else
{
tc.Next();
}
}
return(false);
}
private bool TryParseEscapeSequence(ref StringPart part)
{
int start = this.text.Position;
text.Next();
if (escapeChar.IndexOf(text.Char()) >= 0)
{
text.Next();
part = new StringPart(new Span(text.Position - 2, 2));
return(true);
}
if (Char.IsDigit(text.Char()) && Char.IsDigit(text.NChar()) && Char.IsDigit(text.NNChar()))
{
// a trigraph
text.Skip(3);
part = new StringPart(new Span(text.Position - 4, 4));
return(true);
}
if (text.Char() == '0' && !Char.IsDigit(text.NChar()))
{
// \0
text.Next();
part = new StringPart(new Span(text.Position - 2, 2));
return(true);
}
if (text.Char() == 'u')
{
text.Next();
text.Mark();
Span?span = TryParseShortUnicode();
if (span.HasValue)
{
part = new StringPart(span.Value);
return(true);
}
text.BackToMark();
}
if (text.Char() == 'U')
{
text.Next();
text.Mark();
Span?span = TryParseLongUnicode();
if (span.HasValue)
{
part = new StringPart(span.Value);
return(true);
}
text.BackToMark();
}
// unrecognized sequence, return it as error
text.Next();
int length = text.Position - start;
part = new StringPart(new Span(start, length), StringPartType.EscapeSequenceError);
return(true);
}
private void ParseComment(ITextChars tc)
{
while ( !tc.EndOfLine ) {
if ( tc.Char() == '*' && tc.NChar() == '/' ) {
tc.Skip(2);
this.state = stText;
return;
}
tc.Next();
}
}
private void ParseMultiLineComment(ITextChars tc) {
while ( !tc.AtEnd ) {
if ( tc.Char() == '*' && tc.NChar() == '/' ) {
tc.Skip(2);
this.status = stText;
return;
} else {
tc.Next();
}
}
}
public Span?Next()
{
while (!text.EndOfLine)
{
if (text.Char() == '\\')
{
text.Next();
if (escapeChar.IndexOf(text.Char()) >= 0)
{
text.Next();
return(new Span(text.Position - 2, 2));
}
if (Char.IsDigit(text.Char()) && Char.IsDigit(text.NChar()) && Char.IsDigit(text.NNChar()))
{
// a trigraph
text.Skip(3);
return(new Span(text.Position - 4, 4));
}
if (text.Char() == '0' && !Char.IsDigit(text.NChar()))
{
// \0
text.Next();
return(new Span(text.Position - 2, 2));
}
if (text.Char() == 'u')
{
text.Next();
text.Mark();
Span?span = TryParseShortUnicode();
if (span.HasValue)
{
return(span.Value);
}
text.BackToMark();
}
if (text.Char() == 'U')
{
text.Next();
text.Mark();
Span?span = TryParseLongUnicode();
if (span.HasValue)
{
return(span.Value);
}
text.BackToMark();
}
}
else
{
text.Next();
}
}
return(null);
}
private void ParseHereExpandableString(ITextChars tc)
{
while (!tc.EndOfLine)
{
if (tc.Char() == '`')
{
// skip over escape sequences
tc.Skip(2);
}
else if (tc.Char() == '"' && tc.NChar() == '@')
{
tc.Skip(2);
break;
}
else
{
tc.Next();
}
}
this.status = stText;
}
private bool ParseText(ITextChars tc, ref CharPos pos)
{
while (!tc.AtEnd)
{
// multi-line comment
if (tc.Char() == '/' && tc.NChar() == '*')
{
this.status = stMultiLineComment;
tc.Skip(2);
this.ParseMultiLineComment(tc);
}
else if (tc.Char() == '/' && tc.NChar() == '/')
{
tc.SkipRemainder();
}
else if (tc.Char() == '/' && CheckPrevious(tc.PreviousToken()))
{
// probably a regular expression literal
tc.Next();
this.status = stRegex;
this.ParseRegex(tc);
}
else if (tc.Char() == '"')
{
this.status = stString;
tc.Next();
this.ParseString(tc);
}
else if (tc.Char() == '\'')
{
this.status = stString;
tc.Next();
this.ParseCharLiteral(tc);
}
else if (tc.Char() == '`')
{
this.status = stIString;
tc.Next();
return(this.ParseInterpolatedString(tc, ref pos));
}
else if (this.BraceList.IndexOf(tc.Char()) >= 0)
{
pos = new CharPos(tc.Char(), tc.AbsolutePosition);
tc.Next();
return(true);
}
else
{
tc.Next();
}
}
return(false);
}
private void ParseComment(ITextChars tc)
{
while (!tc.EndOfLine)
{
if (tc.Char() == '*' && tc.NChar() == '/')
{
tc.Skip(2);
this.state = stText;
return;
}
tc.Next();
}
}
private void ParseString(ITextChars tc) {
while ( !tc.AtEnd ) {
if ( tc.Char() == '\\' ) {
// skip over escape sequences
tc.Skip(2);
} else if ( tc.Char() == '"' ) {
tc.Next();
break;
} else {
tc.Next();
}
}
this.status = stText;
}
private void ParseString(ITextChars tc)
{
while ( !tc.EndOfLine ) {
if ( tc.Char() == '\'' && tc.NChar() == '\'' ) {
tc.Skip(2);
} else if ( tc.Char() == '\'' ) {
tc.Next();
this.status = stText;
break;
} else {
tc.Next();
}
}
}
private bool TryParseEscapeSequence(ref StringPart part)
{
text.Next();
if (escapeChar.IndexOf(text.Char()) >= 0)
{
text.Next();
part = new StringPart(new Span(text.Position - 2, 2));
return(true);
}
if (Char.IsDigit(text.Char()) && Char.IsDigit(text.NChar()) && Char.IsDigit(text.NNChar()))
{
// a trigraph
text.Skip(3);
part = new StringPart(new Span(text.Position - 4, 4));
return(true);
}
if (text.Char() == '0' && !Char.IsDigit(text.NChar()))
{
// \0
text.Next();
part = new StringPart(new Span(text.Position - 2, 2));
return(true);
}
if (text.Char() == 'u')
{
text.Next();
text.Mark();
Span?span = TryParseShortUnicode();
if (span.HasValue)
{
part = new StringPart(span.Value);
return(true);
}
text.BackToMark();
}
if (text.Char() == 'U')
{
text.Next();
text.Mark();
Span?span = TryParseLongUnicode();
if (span.HasValue)
{
part = new StringPart(span.Value);
return(true);
}
text.BackToMark();
}
return(false);
}
private void ParseMultiLineString(ITextChars tc) {
while ( !tc.AtEnd ) {
if ( tc.Char() == '"' && tc.NChar() == '"' ) {
// means a single embedded double quote
tc.Skip(2);
} else if ( tc.Char() == '"' ) {
tc.Next();
this.status = stText;
this.multiLine = false;
return;
} else {
tc.Next();
}
}
}
public string Parse(ITextChars tc)
{
SkipWhitespace(tc);
if (tc.Char() == '/' && tc.NChar() == '/')
{
// C single line comment
tc.Skip(2);
return(TrimmedRemainder(tc));
}
else if (tc.Char() == '/' && tc.NChar() == '*')
{
// C multi line comment
tc.Skip(2);
return(TrimmedMinus(tc, "*/"));
}
else if (tc.Char() == '(' && tc.NChar() == '*')
{
// F# multi line comment
tc.Skip(2);
return(TrimmedMinus(tc, "*)"));
}
else if (tc.Char() == '-' && tc.NChar() == '-')
{
// SQL single line comment
tc.Skip(2);
return(TrimmedRemainder(tc));
}
else if (tc.Char() == '#')
{
// Python single line comment
tc.Skip(1);
return(TrimmedRemainder(tc));
}
else if (tc.Char() == '\'')
{
// VB single line comment
tc.Skip(1);
return(TrimmedRemainder(tc));
}
else if (tc.Char() == '<' && tc.NChar() == '!' && tc.NNChar() == '-')
{
// XML comment
tc.Skip(3);
if (tc.Char() == '-')
{
tc.Next();
return(TrimmedMinus(tc, "-->"));
}
}
return(null);
}
private void ParseString(ITextChars tc, char quote)
{
while ( !tc.EndOfLine ) {
if ( tc.Char() == '\\' ) {
// escape sequence
// could be 1-6 hex digits or something else
tc.Skip(2);
} else if ( tc.Char() == quote ) {
tc.Next();
this.state = stText;
break;
}
tc.Next();
}
}
private void ParseCharLiteral(ITextChars tc)
{
while ( !tc.EndOfLine ) {
if ( tc.Char() == '\\' ) {
// skip over escape sequences
tc.Skip(2);
} else if ( tc.Char() == '\'' ) {
tc.Next();
break;
} else {
tc.Next();
}
}
this.status = stText;
}
private void ParseString(ITextChars tc)
{
while ( !tc.EndOfLine ) {
if ( tc.Char() == '"' && tc.NChar() == '"' ) {
// embedded quotes, skip
tc.Skip(2);
} else if ( tc.Char() == '"' ) {
this.status = stText;
tc.Next();
break;
} else {
tc.Next();
}
}
}
private void ParseStringInt(ITextChars tc, char quote)
{
while ( !tc.EndOfLine ) {
if ( tc.Char() == '\\' ) {
// skip over escape sequences
tc.Skip(2);
} else if ( tc.Char() == quote ) {
tc.Next();
this.status = stText;
break;
} else {
tc.Next();
}
}
}
private void ParseMultilineComment(ITextChars tc)
{
while (!tc.EndOfLine)
{
if (tc.Char() == '*' && tc.Char() == '/')
{
tc.Skip(2);
status = stText;
break;
}
else
{
tc.Next();
}
}
}
private void ParseMultiLineString(ITextChars tc)
{
while (!tc.AtEnd)
{
if (tc.Char() == this.quoteChar && tc.NChar() == this.quoteChar && tc.NNChar() == this.quoteChar)
{
tc.Skip(3);
this.status = stText;
return;
}
else
{
tc.Next();
}
}
}
private void ParseHereString(ITextChars tc)
{
while (!tc.EndOfLine)
{
if (tc.Char() == '\'' && tc.NChar() == '@')
{
tc.Skip(2);
break;
}
else
{
tc.Next();
}
}
this.status = stText;
}
private void ParseTripleQuotedString(ITextChars tc)
{
while (!tc.AtEnd)
{
if (tc.Char() == '"' && tc.NChar() == '"' && tc.NNChar() == '"')
{
tc.Skip(3);
this.status = stText;
return;
}
else
{
tc.Next();
}
}
}
private IEnumerable <CharPos> ParseText(ITextChars tc)
{
while (!tc.EndOfLine)
{
// multi-line comment
if (tc.Char() == '/' && tc.NChar() == '*')
{
this.status = stMultiLineComment;
tc.Skip(2);
this.ParseMultiLineComment(tc);
}
else if (tc.Char() == '/' && tc.NChar() == '/')
{
tc.SkipRemainder();
}
else if (tc.Char() == '/' && CheckPrevious(tc.PreviousToken()))
{
// probably a regular expression literal
tc.Next();
this.status = stRegex;
this.ParseRegex(tc);
}
else if (tc.Char() == '"')
{
this.status = stString;
tc.Next();
this.ParseString(tc);
}
else if (tc.Char() == '\'')
{
this.status = stString;
tc.Next();
this.ParseCharLiteral(tc);
}
else if (lang.BraceList.IndexOf(tc.Char()) >= 0)
{
yield return(new CharPos(tc.Char(), tc.AbsolutePosition));
tc.Next();
}
else
{
tc.Next();
}
}
}
// template literal support,
// see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals
private bool ParseInterpolatedString(ITextChars tc, ref CharPos pos)
{
while (!tc.AtEnd)
{
if (this.parsingExpression)
{
// inside template literal expression in ${}
if (ParseTemplateExpressionChar(tc, ref pos))
{
return(true);
}
}
else
{
// in the string part
if (tc.Char() == '\\')
{
// skip over escape sequences
tc.Skip(2);
}
else if (tc.Char() == '$' && tc.NChar() == '{')
{
// opening expression
this.parsingExpression = true;
this.nestingLevel++;
tc.Next(); // skip $
pos = new CharPos(tc.Char(), tc.AbsolutePosition, EncodedState());
tc.Next(); // skip {
return(true);
}
else if (tc.Char() == '`')
{
// done parsing the template
this.status = stText;
tc.Next();
break;
}
else
{
tc.Next();
}
}
}
return(false);
}
private bool ParseText(ITextChars tc, ref CharPos pos)
{
pos = CharPos.Empty;
while (!tc.AtEnd)
{
if (tc.Char() == '/' && tc.NChar() == '*')
{
this.state = stComment;
tc.Skip(2);
ParseComment(tc);
}
else if (tc.Char() == '/' && tc.NChar() == '/')
{
// CSS doesn't really support single-line comments,
// but SASS does, and it doesn't harm too
// much to implement it as a single thing
tc.SkipRemainder();
}
else if (tc.Char() == '"')
{
this.state = stDoubleQuotedString;
tc.Next();
ParseDString(tc);
}
else if (tc.Char() == '\'')
{
this.state = stSingleQuotedString;
tc.Next();
ParseString(tc);
}
else if (this.BraceList.Contains(tc.Char()))
{
pos = new CharPos(tc.Char(), tc.AbsolutePosition);
tc.Next();
return(true);
}
else
{
tc.Next();
}
}
return(false);
}
private void ParseString(ITextChars tc, char quote)
{
while (!tc.AtEnd)
{
if (tc.Char() == '\\')
{
// escape sequence
// could be 1-6 hex digits or something else
tc.Skip(2);
}
else if (tc.Char() == quote)
{
tc.Next();
this.state = stText;
break;
}
tc.Next();
}
}
private void ParseString(ITextChars tc)
{
while (!tc.AtEnd)
{
if (tc.Char() == '\'' && tc.NChar() == '\'')
{
tc.Skip(2);
}
else if (tc.Char() == '\'')
{
tc.Next();
this.status = stText;
break;
}
else
{
tc.Next();
}
}
}
private IEnumerable <CharPos> ParseText(ITextChars tc)
{
while (!tc.EndOfLine)
{
if (tc.Char() == '/' && tc.NChar() == '*')
{
this.state = stComment;
tc.Skip(2);
ParseComment(tc);
}
else if (tc.Char() == '/' && tc.NChar() == '/')
{
// CSS doesn't really support single-line comments,
// but SASS does, and it doesn't harm too
// much to implement it as a single thing
tc.SkipRemainder();
}
else if (tc.Char() == '"')
{
this.state = stDoubleQuotedString;
tc.Next();
ParseDString(tc);
}
else if (tc.Char() == '\'')
{
this.state = stSingleQuotedString;
tc.Next();
ParseString(tc);
}
else if (lang.BraceList.Contains(tc.Char()))
{
yield return(new CharPos(tc.Char(), tc.AbsolutePosition));
tc.Next();
}
else
{
tc.Next();
}
}
}
private void ParseCharLiteral(ITextChars tc)
{
while (!tc.EndOfLine)
{
if (tc.Char() == '\\')
{
// skip over escape sequences
tc.Skip(2);
}
else if (tc.Char() == '\'')
{
tc.Next();
break;
}
else
{
tc.Next();
}
}
this.status = stText;
}
private void ParseString(ITextChars tc, char quote)
{
while (!tc.AtEnd)
{
if (tc.Char() == quote && tc.NChar() == quote)
{
// double quote, meaning a single literal quote, skip
tc.Skip(2);
}
else if (tc.Char() == quote)
{
tc.Next();
break;
}
else
{
tc.Next();
}
}
this.status = stText;
}
private bool ParseText(ITextChars tc, ref CharPos pos)
{
while ( !tc.EndOfLine ) {
// multi-line comment
if ( tc.Char() == '/' && tc.NChar() == '*' ) {
this.status = stMultiLineComment;
tc.Skip(2);
this.ParseMultiLineComment(tc);
} else if ( tc.Char() == '-' && tc.NChar() == '-' ) {
tc.SkipRemainder();
} else if ( tc.Char() == '\'' ) {
this.status = stString;
tc.Next();
this.ParseString(tc);
} else if ( this.BraceList.IndexOf(tc.Char()) >= 0 ) {
pos = new CharPos(tc.Char(), tc.AbsolutePosition);
tc.Next();
return true;
} else {
tc.Next();
}
}
return false;
}
public string Parse(ITextChars tc)
{
SkipWhitespace(tc);
if ( tc.Char() == '/' && tc.NChar() == '/' ) {
// C single line comment
tc.Skip(2);
return TrimmedRemainder(tc);
} else if ( tc.Char() == '/' && tc.NChar() == '*' ) {
// C multi line comment
tc.Skip(2);
return TrimmedMinus(tc, "*/");
} else if ( tc.Char() == '(' && tc.NChar() == '*' ) {
// F# multi line comment
tc.Skip(2);
return TrimmedMinus(tc, "*)");
} else if ( tc.Char() == '-' && tc.NChar() == '-' ) {
// SQL single line comment
tc.Skip(2);
return TrimmedRemainder(tc);
} else if ( tc.Char() == '#' ) {
// Python single line comment
tc.Skip(1);
return TrimmedRemainder(tc);
} else if ( tc.Char() == '\'' ) {
// VB single line comment
tc.Skip(1);
return TrimmedRemainder(tc);
} else if ( tc.Char() == '<' && tc.NChar() == '!' && tc.NNChar() == '-' ) {
// XML comment
tc.Skip(3);
if ( tc.Char() == '-' ) {
tc.Next();
return TrimmedMinus(tc, "-->");
}
}
return null;
}
private IEnumerable<CharPos> ParseText(ITextChars tc)
{
while ( !tc.EndOfLine ) {
if ( tc.Char() == '/' && tc.NChar() == '*' ) {
this.state = stComment;
tc.Skip(2);
ParseComment(tc);
} else if ( tc.Char() == '/' && tc.NChar() == '/' ) {
// CSS doesn't really support single-line comments,
// but SASS does, and it doesn't harm too
// much to implement it as a single thing
tc.SkipRemainder();
} else if ( tc.Char() == '"' ) {
this.state = stDoubleQuotedString;
tc.Next();
ParseDString(tc);
} else if ( tc.Char() == '\'' ) {
this.state = stSingleQuotedString;
tc.Next();
ParseString(tc);
} else if ( braceList.Contains(tc.Char()) ) {
yield return new CharPos(tc.Char(), tc.AbsolutePosition);
tc.Next();
} else {
tc.Next();
}
}
}
private bool ParseText(ITextChars tc, ref CharPos pos)
{
while ( !tc.EndOfLine ) {
// multi-line comment
if ( tc.Char() == '/' && tc.NChar() == '*' ) {
this.status = stMultiLineComment;
tc.Skip(2);
this.ParseMultiLineComment(tc);
} else if ( tc.Char() == '/' && tc.NChar() == '/' ) {
tc.SkipRemainder();
} else if ( tc.Char() == '/' && CheckPrevious(tc.PreviousToken()) ) {
// probably a regular expression literal
tc.Next();
this.status = stRegex;
this.ParseRegex(tc);
} else if ( tc.Char() == '"' ) {
this.status = stString;
tc.Next();
this.ParseString(tc);
} else if ( tc.Char() == '\'' ) {
this.status = stString;
tc.Next();
this.ParseCharLiteral(tc);
} else if ( this.BraceList.IndexOf(tc.Char()) >= 0 ) {
pos = new CharPos(tc.Char(), tc.AbsolutePosition);
tc.Next();
return true;
} else {
tc.Next();
}
}
return false;
}
private bool ParseText(ITextChars tc, ref CharPos pos)
{
while ( !tc.EndOfLine ) {
// multi-line comment
if ( tc.Char() == '/' && tc.NChar() == '*' ) {
this.status = stMultiLineComment;
tc.Skip(2);
this.ParseMultiLineComment(tc);
} else if ( tc.Char() == '/' && tc.NChar() == '/' ) {
tc.SkipRemainder();
} else if ( tc.Char() == '"' ) {
this.status = stString;
tc.Next();
this.ParseString(tc);
} else if ( Char.IsDigit(tc.Char()) && tc.NChar() == '\'' ) {
// this is a C++ 14 digit separator, such as 1'000'000
tc.Skip(2);
} else if ( tc.Char() == '\'' ) {
this.status = stString;
tc.Next();
this.ParseCharLiteral(tc);
} else if ( this.BraceList.IndexOf(tc.Char()) >= 0 ) {
pos = new CharPos(tc.Char(), tc.AbsolutePosition);
tc.Next();
return true;
} else {
tc.Next();
}
}
return false;
}
private IEnumerable<CharPos> ParseText(ITextChars tc)
{
while ( !tc.EndOfLine ) {
if ( tc.Char() == '#' ) {
tc.SkipRemainder();
} else if ( (tc.Char() == '"' && tc.NChar() == '"' && tc.NNChar() == '"')
|| (tc.Char() == '\'' && tc.NChar() == '\'' && tc.NNChar() == '\'') ) {
this.status = stMultiLineString;
this.quoteChar = tc.Char();
tc.Skip(3);
this.ParseMultiLineString(tc);
} else if ( tc.Char() == '\'' || tc.Char() == '"' ) {
this.status = stString;
this.quoteChar = tc.Char();
tc.Next();
this.ParseString(tc);
} else if ( braceList.IndexOf(tc.Char()) >= 0 ) {
yield return new CharPos(tc.Char(), tc.AbsolutePosition);
tc.Next();
} else {
tc.Next();
}
}
}
// C# 6.0 interpolated string support:
// this is a hack. It will not handle all possible expressions
// but will handle most basic stuff
private bool ParseInterpolatedString(ITextChars tc, ref CharPos pos)
{
while ( !tc.EndOfLine ) {
if ( parsingExpression ) {
//
// we're inside an interpolated section
//
if ( tc.Char() == '"' ) {
// opening string
tc.Next();
this.ParseString(tc);
this.status = stIString;
} else if ( tc.Char() == '\'' ) {
tc.Next();
ParseCharLiteral(tc);
this.status = stIString;
} else if ( tc.Char() == '}' ) {
// reached the end
this.nestingLevel--;
if ( nestingLevel == 0 ) {
this.parsingExpression = false;
}
pos = new CharPos(tc.Char(), tc.AbsolutePosition, EncodedState());
tc.Next();
return true;
} else if ( BraceList.Contains(tc.Char()) ) {
pos = new CharPos(tc.Char(), tc.AbsolutePosition, EncodedState());
if ( tc.Char() == '{' )
this.nestingLevel++;
tc.Next();
return true;
} else {
tc.Next();
}
} else {
//
// parsing the string part
// if it's an at-string, don't look for escape sequences
//
if ( tc.Char() == '\\' && !this.multiLine ) {
// skip over escape sequences
tc.Skip(2);
} else if ( tc.Char() == '{' && tc.NChar() == '{' ) {
tc.Skip(2);
} else if ( tc.Char() == '{' ) {
this.parsingExpression = true;
this.nestingLevel++;
pos = new CharPos(tc.Char(), tc.AbsolutePosition, EncodedState());
tc.Next();
return true;
} else if ( this.multiLine && tc.Char() == '"' && tc.NChar() == '"' ) {
// single embedded double quote
tc.Skip(2);
} else if ( tc.Char() == '"' ) {
// done parsing the interpolated string
this.status = stText;
this.multiLine = false;
tc.Next();
break;
} else {
tc.Next();
}
}
}
return false;
}
private bool ParseText(ITextChars tc, ref CharPos pos)
{
while ( !tc.EndOfLine ) {
// multi-line comment
if ( tc.Char() == '/' && tc.NChar() == '*' ) {
this.status = stMultiLineComment;
tc.Skip(2);
this.ParseMultiLineComment(tc);
} else if ( tc.Char() == '/' && tc.NChar() == '/' ) {
tc.SkipRemainder();
} else if ( tc.Char() == '@' && tc.NChar() == '"' ) {
this.status = stString;
this.multiLine = true;
tc.Skip(2);
this.ParseMultiLineString(tc);
} else if ( tc.Char() == '$' && tc.NChar() == '"' ) {
// Roslyn interpolated string
this.parsingExpression = false;
this.status = stIString;
tc.Skip(2);
return this.ParseInterpolatedString(tc, ref pos);
} else if ( tc.Char() == '$' && tc.NChar() == '@' && tc.NNChar() == '"' ) {
this.status = stIString;
this.multiLine = true;
this.parsingExpression = false;
tc.Skip(3);
return this.ParseInterpolatedString(tc, ref pos);
} else if ( tc.Char() == '"' ) {
this.status = stString;
tc.Next();
this.ParseString(tc);
} else if ( tc.Char() == '\'' ) {
this.status = stString;
tc.Next();
this.ParseCharLiteral(tc);
} else if ( this.BraceList.IndexOf(tc.Char()) >= 0 ) {
pos = new CharPos(tc.Char(), tc.AbsolutePosition, EncodedState());
tc.Next();
return true;
} else {
tc.Next();
}
}
return false;
}
private bool ParseText(ITextChars tc, ref CharPos pos)
{
pos = CharPos.Empty;
while ( !tc.EndOfLine ) {
if ( tc.Char() == '/' && tc.NChar() == '*' ) {
this.state = stComment;
tc.Skip(2);
ParseComment(tc);
} else if ( tc.Char() == '/' && tc.NChar() == '/' ) {
// CSS doesn't really support single-line comments,
// but SASS does, and it doesn't harm too
// much to implement it as a single thing
tc.SkipRemainder();
} else if ( tc.Char() == '"' ) {
this.state = stDoubleQuotedString;
tc.Next();
ParseDString(tc);
} else if ( tc.Char() == '\'' ) {
this.state = stSingleQuotedString;
tc.Next();
ParseString(tc);
} else if ( this.BraceList.Contains(tc.Char()) ) {
pos = new CharPos(tc.Char(), tc.AbsolutePosition);
tc.Next();
return true;
} else {
tc.Next();
}
}
return false;
}
private bool ParseText(ITextChars tc, ref CharPos pos)
{
while ( !tc.EndOfLine ) {
if ( tc.Char() == '#' ) {
tc.SkipRemainder();
} else if ( (tc.Char() == '"' && tc.NChar() == '"' && tc.NNChar() == '"')
|| (tc.Char() == '\'' && tc.NChar() == '\'' && tc.NNChar() == '\'') ) {
this.status = stMultiLineString;
this.quoteChar = tc.Char();
tc.Skip(3);
this.ParseMultiLineString(tc);
} else if ( tc.Char() == '\'' || tc.Char() == '"' ) {
this.status = stString;
this.quoteChar = tc.Char();
tc.Next();
this.ParseString(tc);
} else if ( this.BraceList.IndexOf(tc.Char()) >= 0 ) {
pos = new CharPos(tc.Char(), tc.AbsolutePosition);
tc.Next();
return true;
} else {
tc.Next();
}
}
return false;
}
private IEnumerable<CharPos> ParseText(ITextChars tc)
{
while ( !tc.EndOfLine ) {
// multi-line comment
if ( tc.Char() == '<' && tc.NChar() == '#' ) {
this.status = stMultiLineComment;
tc.Skip(2);
this.ParseMultiLineComment(tc);
} else if ( tc.Char() == '#' ) {
tc.SkipRemainder();
} else if ( tc.Char() == '@' && tc.NChar() == '\'' ) {
this.status = stHereString;
tc.Skip(2);
this.ParseHereString(tc);
} else if ( tc.Char() == '@' && tc.NChar() == '"' ) {
this.status = stHereExpandableString;
tc.Skip(2);
this.ParseHereExpandableString(tc);
} else if ( tc.Char() == '"' ) {
this.status = stString;
tc.Next();
this.ParseExpandableString(tc);
} else if ( tc.Char() == '\'' ) {
this.status = stString;
tc.Next();
this.ParseString(tc);
} else if ( braceList.IndexOf(tc.Char()) >= 0 ) {
yield return new CharPos(tc.Char(), tc.AbsolutePosition);
tc.Next();
} else {
tc.Next();
}
}
}
private void ParseMultiLineComment(ITextChars tc)
{
while ( !tc.EndOfLine ) {
if ( tc.Char() == '#' && tc.NChar() == '>' ) {
tc.Skip(2);
this.status = stText;
return;
} else {
tc.Next();
}
}
}
private void ParseMultiLineString(ITextChars tc)
{
while ( !tc.EndOfLine ) {
if ( tc.Char() == '"' && tc.NChar() == '"' ) {
// means a single embedded double quote
tc.Skip(2);
} else if ( tc.Char() == '"' ) {
tc.Next();
this.status = stText;
return;
} else {
tc.Next();
}
}
}
private bool ParseText(ITextChars tc, ref CharPos pos)
{
while ( !tc.EndOfLine ) {
// multi-line comment
if ( tc.Char() == '(' && tc.NChar() == '*' && tc.NNChar() != ')') {
this.status = stMultiLineComment;
tc.Skip(2);
this.ParseMultiLineComment(tc);
} else if ( tc.Char() == '/' && tc.NChar() == '/' ) {
tc.SkipRemainder();
} else if ( tc.Char() == '@' && tc.NChar() == '"' ) {
this.status = stVerbatimString;
tc.Skip(2);
this.ParseVerbatimString(tc);
} else if ( tc.Char() == '"' && tc.NChar() == '"' && tc.NNChar() == '"' ) {
this.status = stTripleQuotedString;
tc.Skip(3);
this.ParseTripleQuotedString(tc);
} else if ( tc.Char() == '"' ) {
this.status = stString;
tc.Next();
this.ParseString(tc);
} else if ( tc.Char() == '<' && tc.NChar() == '\'') {
// this is just a generic parameter, so skip it already
tc.Skip(2);
} else if ( Char.IsLetterOrDigit(tc.Char()) && tc.NChar() == '\'' ) {
// identifier like c'
tc.Skip(2);
} else if ( tc.Char() == '\'' ) {
this.status = stChar;
tc.Next();
this.ParseCharLiteral(tc);
} else if ( this.BraceList.IndexOf(tc.Char()) >= 0 ) {
pos = new CharPos(tc.Char(), tc.AbsolutePosition);
tc.Next();
return true;
} else {
tc.Next();
}
}
return false;
}
private void ParseTripleQuotedString(ITextChars tc)
{
while ( !tc.EndOfLine ) {
if ( tc.Char() == '"' && tc.NChar() == '"' && tc.NNChar() == '"' ) {
tc.Skip(3);
this.status = stText;
return;
} else {
tc.Next();
}
}
}