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() == '\'')
{
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 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 bool ParseText(ITextChars tc, ref CharPos pos)
{
while (!tc.AtEnd)
{
if (tc.Char() == '!')
{
// single line comment
tc.SkipRemainder();
}
else if (tc.Char() == '\'')
{
this.status = stStringSingle;
tc.Next();
ParseStringSingle(tc);
}
else if (tc.Char() == '"')
{
this.status = stStringDouble;
tc.Next();
ParseStringDouble(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 (lang.BraceList.IndexOf(tc.Char()) >= 0)
{
yield return(new CharPos(tc.Char(), tc.AbsolutePosition));
tc.Next();
}
else
{
tc.Next();
}
}
}
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 IEnumerable <CharPos> ParseText(ITextChars tc)
{
while (!tc.EndOfLine)
{
if (tc.Char() == '\'')
{
// single line comment
tc.SkipRemainder();
}
else if (tc.Char() == '"')
{
this.status = stString;
tc.Next();
this.ParseString(tc);
}
else if (language.BraceList.IndexOf(tc.Char()) >= 0)
{
yield return(new CharPos(tc.Char(), tc.AbsolutePosition));
tc.Next();
}
else
{
tc.Next();
}
}
}
internal static StringPart ParseEscapeSequence(ITextChars text)
{
// text.Char() == \
int start = text.Position;
int len = 1;
text.Next();
int maxlen = Int32.MaxValue;
char f = text.Char();
text.Next();
// not perfect, but close enough for first version
if (f == 'x' || f == 'X' || f == 'u' || f == 'U')
{
if (f == 'u')
{
maxlen = 5;
}
else if (f == 'U')
{
maxlen = 9;
}
while (text.Char().IsHexDigit() && len < maxlen)
{
text.Next();
len++;
}
}
var span = new Span(start, len + 1);
return(new StringPart(span, StringPartType.EscapeSequence));
}
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 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.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() == '\'')
{
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);
}
internal static StringPart ParseEscapeSequence(ITextChars text)
{
// text.Char() == \
int start = text.Position;
int len = 1;
text.Next();
int maxlen = Int32.MaxValue;
char f = text.Char();
text.Next();
// not perfect, but close enough for first version
if ( (f == 'x' || f == 'u' || f == 'U') && text.Char() != '{' ) {
if ( f == 'x' ) maxlen = 3;
else if ( f == 'u' ) maxlen = 5;
else if ( f == 'U' ) maxlen = 9;
while ( text.Char().IsHexDigit() && len < maxlen ) {
text.Next();
len++;
}
} else if ( (f == 'u' || f == 'U') && text.Char() == '{' ) {
len++;
while ( text.Char() != '}' && !text.EndOfLine ) {
text.Next();
len++;
}
}
var span = new Span(start, len + 1);
return new StringPart(span, StringPartType.EscapeSequence);
}
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);
}
private bool Parse(ITextChars tc, ref CharPos pos)
{
while (!tc.AtEnd)
{
// Comment.
if (tc.Char() == '#')
{
tc.SkipRemainder();
}
// String.
else if (tc.Char() == '"')
{
tc.Next();
this.status = State.MultiLineString;
this.String(tc);
continue;
}
// Braces.
else if (this.BraceList.IndexOf(tc.Char()) >= 0)
{
pos = new CharPos(tc.Char(), tc.AbsolutePosition);
tc.Next();
return(true);
}
// Code.
tc.Next();
}
return(false);
}
public string Parse(ITextChars tc)
{
while (!tc.EndOfLine && tc.Char() != '/')
{
tc.Next();
}
if (tc.EndOfLine)
{
return(null);
}
StringBuilder sb = new StringBuilder();
tc.Next();
if (tc.Char() == '*')
{
tc.Next();
// multiline comment
while (!tc.EndOfLine && tc.Char() != '*' && tc.NChar() != '/')
{
sb.Append(tc.Char());
tc.Next();
}
}
else if (tc.Char() == '/')
{
tc.Next();
// single line comment
sb.Append(tc.GetRemainder());
}
return(sb.ToString());
}
private void ParseMultiLineString(ITextChars tc)
{
while ( !tc.EndOfLine ) {
if ( tc.Char() == '"' ) {
tc.Next();
this.status = stText;
return;
} else {
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 void ParseExpandableString(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 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 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 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 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();
}
}
}
private void ParseVerbatimString(ITextChars tc)
{
while (!tc.AtEnd)
{
if (tc.Char() == '"')
{
tc.Next();
this.status = stText;
return;
}
else
{
tc.Next();
}
}
}
private void ParseString(ITextChars tc)
{
while (!tc.EndOfLine)
{
if (tc.Char() == '\'')
{
tc.Next();
break;
}
else
{
tc.Next();
}
}
this.status = stText;
}
private void ParseString(ITextChars tc)
{
while (!tc.AtEnd)
{
if (tc.Char() == '\"')
{
tc.Next();
this.status = stText;
break;
}
else
{
tc.Next();
}
}
}
private void SkipWhitespace(ITextChars tc)
{
while (!tc.EndOfLine && Char.IsWhiteSpace(tc.Char()))
{
tc.Next();
}
}
private void ParseMultiLineString(ITextChars tc)
{
while (!tc.EndOfLine)
{
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() == '*')
{
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 StringPart?ParseEscapeSequence(ITextChars text)
{
// text.Char() == \
int start = text.Position;
text.Next();
char f = text.Char();
text.Next();
if (f == '\\' || f == '\"')
{
var span = new TextSpan(start, 2);
return(new StringPart(span, StringPartType.EscapeSequence));
}
return(null);
}
// 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)
{
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() == '\'' ) {
// single line comment
tc.SkipRemainder();
} 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();
}
}
}
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 bool ParseTemplateExpressionChar(ITextChars tc, ref CharPos pos)
{
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 (this.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();
}
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();
}
}
public bool Next()
{
if (tc.EndOfLine)
{
this.currentToken = "";
this.reachedEnd = true;
return(false);
}
// skip whitespace
while (!tc.EndOfLine && Char.IsWhiteSpace(tc.Char()))
{
tc.Next();
}
if (tc.EndOfLine)
{
this.currentToken = "";
this.reachedEnd = true;
return(false);
}
// if it's a special character, return it on its own
if (!Char.IsLetterOrDigit(tc.Char()))
{
char ch = tc.Char();
tc.Next();
this.currentToken = "" + ch;
return(true);
}
// return the word
StringBuilder sb = new StringBuilder();
while (!tc.EndOfLine)
{
char ch = tc.Char();
if (!Char.IsLetterOrDigit(ch))
{
break;
}
tc.Next();
sb.Append(ch);
}
this.currentToken = sb.ToString();
return(true);
}
private void ParseMultiLineComment(ITextChars tc) {
while ( !tc.AtEnd ) {
if ( tc.Char() == '*' && tc.NChar() == '/' ) {
tc.Skip(2);
this.status = stText;
return;
} else {
tc.Next();
}
}
}
private void ParseComment(ITextChars tc)
{
while ( !tc.EndOfLine ) {
if ( tc.Char() == '*' && tc.NChar() == '/' ) {
tc.Skip(2);
this.state = stText;
return;
}
tc.Next();
}
}
private bool ParseText(ITextChars tc, ref CharPos pos)
{
while ( !tc.EndOfLine ) {
if ( tc.Char() == '\'' ) {
// single line comment
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;
}
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();
}
}
}
// we assume endChars is 2 or 3, which is the most common case
private string TrimmedMinus(ITextChars tc, String t)
{
StringBuilder buffer = new StringBuilder();
while ( !tc.EndOfLine ) {
if ( tc.Char() == t[0] && tc.NChar() == t[1] ) {
if ( t.Length <= 2 || tc.NNChar() == t[2] ) {
break;
}
}
buffer.Append(tc.Char());
tc.Next();
}
return buffer.ToString().Trim();
}
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 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 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 void SkipWhitespace(ITextChars tc)
{
while ( !tc.EndOfLine && Char.IsWhiteSpace(tc.Char()) ) {
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 void ParseMultiLineComment(ITextChars tc)
{
while ( !tc.EndOfLine ) {
if ( tc.Char() == '#' && tc.NChar() == '>' ) {
tc.Skip(2);
this.status = stText;
return;
} else {
tc.Next();
}
}
}
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();
}
}
}
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 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 void ParseTripleQuotedString(ITextChars tc)
{
while ( !tc.EndOfLine ) {
if ( tc.Char() == '"' && tc.NChar() == '"' && tc.NNChar() == '"' ) {
tc.Skip(3);
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() == '*' ) {
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)
{
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 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 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 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;
}
// 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;
}
