private TokenTagCollection MatchSquareBrackets(SnapshotSpan span)
{
var tokenTags = new TokenTagCollection(span);
tokenTags.SetClassifierTag(GLSLTokenTypes.SquareBracket);
int start = span.Start;
if (!_squareBracketBuilder.Start.HasValue)
{
_squareBracketBuilder.Start = start;
string text = span.Snapshot.GetText();
int end = GetClosingPosition(text, start, '[', ']', _squareBracketBuilder);
if (end >= 0)
{
_squareBracketBuilder.End = end + 1;
var bracketSpan = _squareBracketBuilder.ToSpan();
_squareBracketBuilder.Clear();
int outlineEnd = _squareBracketBuilder.ConsumeUntil(text, start, "\r", "\n");
if (outlineEnd >= 0 && outlineEnd < end)
{
var collapseText = text.Substring(start, outlineEnd - start) + "...]";
var tagSpan = new TagSpan <GLSLOutlineTag>(bracketSpan, new GLSLOutlineTag(SQUARE_TOKEN_TYPE, collapseText));
tokenTags.AddOutlineTagSpan(tagSpan);
_squareBracketSpans.Add(tagSpan);
}
}
}
return(tokenTags);
}
public TokenTagCollection Match(SnapshotSpan span)
{
_builder.Snapshot = span.Snapshot;
var tokenTags = new TokenTagCollection(span);
string token = span.GetText();
int position = span.Start + token.Length;
if (token.StartsWith("#"))
{
int start = position - token.Length;
if (!_builder.Start.HasValue)
{
_builder.Start = start;
string text = span.Snapshot.GetText();
int nConsumed = _builder.ConsumeUntil(text, start, "\r", "\n");
if (nConsumed >= 0)
{
_builder.End = _builder.Start + nConsumed;
var preprocessorSpan = _builder.ToSpan();
_builder.Clear();
_spans.Add(preprocessorSpan);
tokenTags.Consumed = preprocessorSpan.Length - token.Length;
tokenTags.ClassifierTagSpan = new TagSpan <GLSLClassifierTag>(preprocessorSpan, new GLSLClassifierTag(TOKEN_TYPE));
}
}
}
return(tokenTags);
}
private TokenTagCollection MatchParentheses(SnapshotSpan span)
{
var tokenTags = new TokenTagCollection(span);
tokenTags.SetClassifierTag(GLSLTokenTypes.Parenthesis);
int start = span.Start;
if (!_parenthesisBuilder.Start.HasValue)
{
_parenthesisBuilder.Start = start;
string text = span.Snapshot.GetText();
int end = GetClosingPosition(text, start, '(', ')', _parenthesisBuilder);
if (end >= 0)
{
_parenthesisBuilder.End = end + 1;
var parenthesisSpan = _parenthesisBuilder.ToSpan();
_parenthesisBuilder.Clear();
int outlineEnd = _parenthesisBuilder.ConsumeUntil(text, start, "\r", "\n");
if (outlineEnd >= 0 && outlineEnd < end)
{
var collapseText = text.Substring(start, outlineEnd - start) + "...)";
var tagSpan = new TagSpan <GLSLOutlineTag>(parenthesisSpan, new GLSLOutlineTag(PARENTHESIS_TOKEN_TYPE, collapseText));
tokenTags.AddOutlineTagSpan(tagSpan);
_parenthesisSpans.Add(tagSpan);
}
}
}
return(tokenTags);
}
public TokenTagCollection Match(SnapshotSpan span)
{
var tokenTags = new TokenTagCollection(span);
string token = span.GetText();
if (_tokens.Contains(token))
{
tokenTags.SetClassifierTag(TOKEN_TYPE);
}
return(tokenTags);
}
public TokenTagCollection Match(SnapshotSpan span, Scope scope)
{
var tokenTags = new TokenTagCollection(span);
string token = span.GetText();
var matchType = MatchTokenType(token, scope);
if (matchType != GLSLTokenTypes.None)
{
tokenTags.SetClassifierTag(matchType);
}
return(tokenTags);
}
public TokenTagCollection AddToken(SnapshotSpan span, Scope scope, string variableType, GLSLTokenTypes tokenType)
{
var tokenTags = new TokenTagCollection(span)
{
ClassifierTagSpan = new TagSpan <GLSLClassifierTag>(span, new GLSLClassifierTag(tokenType))
};
// TODO - We need to check the span to ensure that this is a valid variable name
// If not, we need to mark it as an error
_variableInfos.Add(new VariableInfo(span, scope, variableType, tokenType));
return(tokenTags);
}
private TokenTagCollection GetTokenTags(SnapshotSpan span)
{
TokenTagCollection spanResult = _keywordTagger.Match(span);
if (spanResult.ClassifierTagSpan != null)
{
return(spanResult);
}
spanResult = _typeTagger.Match(span);
if (spanResult.ClassifierTagSpan != null)
{
return(spanResult);
}
var scope = _bracketTagger.GetScope(span);
spanResult = _variableTagger.Match(span, scope);
if (spanResult.ClassifierTagSpan != null)
{
return(spanResult);
}
spanResult = _structTagger.Match(span);
if (spanResult.ClassifierTagSpan != null)
{
return(spanResult);
}
spanResult = _constantTagger.Match(span);
if (spanResult.ClassifierTagSpan != null)
{
return(spanResult);
}
spanResult = _functionTagger.Match(span);
if (spanResult.ClassifierTagSpan != null)
{
return(spanResult);
}
spanResult = _operatorTagger.Match(span);
if (spanResult.ClassifierTagSpan != null)
{
return(spanResult);
}
return(new TokenTagCollection(span));
}
public TokenTagCollection AddToken(SnapshotSpan span, string returnType)
{
var token = span.GetText();
var position = span.End;
var tokenTags = new TokenTagCollection(span);
tokenTags.SetClassifierTag(GLSLTokenTypes.Function);
_localFunctions.Add(new TagSpan <IGLSLTag>(span, new GLSLClassifierTag(GLSLTokenTypes.Function)));
var functionInfo = new FunctionInfo(token, GLSLTokenTypes.Function);
functionInfo.Overloads.Add(new FunctionOverload(returnType));
_functionInfos.Add(functionInfo);
return(tokenTags);
}
public TokenTagCollection Match(SnapshotSpan span)
{
_parenthesisBuilder.Snapshot = span.Snapshot;
_curlyBracketBuilder.Snapshot = span.Snapshot;
_squareBracketBuilder.Snapshot = span.Snapshot;
var tokenTags = new TokenTagCollection(span);
switch (span.GetText())
{
case "(":
return(MatchParentheses(span));
case "{":
return(MatchCurlyBrackets(span));
case "[":
return(MatchSquareBrackets(span));
case ")":
tokenTags.SetClassifierTag(GLSLTokenTypes.Parenthesis);
break;
case "}":
tokenTags.SetClassifierTag(GLSLTokenTypes.CurlyBracket);
break;
case "]":
tokenTags.SetClassifierTag(GLSLTokenTypes.SquareBracket);
break;
}
/*result.AddTagSpans(_parenthesisSpans);
* result.AddTagSpans(_curlyBracketSpans);
* result.AddTagSpans(_squareBracketSpans);*/
return(tokenTags);
}
public TokenTagCollection Match(SnapshotSpan span)
{
_singleLineCommentBuilder.Snapshot = span.Snapshot;
_multiLineCommentBuilder.Snapshot = span.Snapshot;
var tokenTags = new TokenTagCollection(span);
string token = span.GetText();
int position = span.Start + token.Length;
if (token.Contains("//"))
{
int tokenIndex = token.IndexOf("//");
int start = position - token.Length + tokenIndex;
if (!_singleLineCommentBuilder.Start.HasValue)
{
_singleLineCommentBuilder.Start = start;
string text = span.Snapshot.GetText();
int end = _singleLineCommentBuilder.ConsumeUntil(text, start, "\r", "\n");
if (end >= 0)
{
_singleLineCommentBuilder.End = end;
var commentSpan = _singleLineCommentBuilder.ToSpan();
_singleLineCommentBuilder.Clear();
var commentTagSpan = new TagSpan <GLSLClassifierTag>(commentSpan, new GLSLClassifierTag(TOKEN_TYPE));
_singleLineComments.Add(commentTagSpan);
tokenTags.Consumed = commentSpan.Length - token.Length;
}
}
}
if (token.Contains("/*"))
{
int tokenIndex = token.IndexOf("/*");
int start = position - token.Length + tokenIndex;
if (!_multiLineCommentBuilder.Start.HasValue)
{
_multiLineCommentBuilder.Start = start;
string text = span.Snapshot.GetText();
int end = _multiLineCommentBuilder.ConsumeUntil(text, start, "*/");
if (end >= 0)
{
_multiLineCommentBuilder.End = end + 1;
var commentSpan = _multiLineCommentBuilder.ToSpan();
_multiLineCommentBuilder.Clear();
var commentTagSpan = new TagSpan <IGLSLTag>(commentSpan, new GLSLClassifierTag(TOKEN_TYPE));
_multiLineComments.Add(commentTagSpan);
int outlineEnd = _multiLineCommentBuilder.ConsumeUntil(text, start, "\r", "\n");
if (outlineEnd >= 0)
{
var outlineTagSpan = new TagSpan <IGLSLTag>(commentSpan, new GLSLOutlineTag(TOKEN_TYPE, text.Substring(start, outlineEnd - start) + "...*/"));
_multiLineComments.Add(outlineTagSpan);
}
tokenTags.Consumed = commentSpan.Length - token.Length;
}
}
}
tokenTags.SetClassifierTag(_singleLineComments);
tokenTags.SetClassifierTag(_multiLineComments.OfType <TagSpan <GLSLClassifierTag> >());
tokenTags.AddOutlineTagSpans(_multiLineComments.OfType <TagSpan <GLSLOutlineTag> >());
return(tokenTags);
}
public TokenTagCollection Match(SnapshotSpan span)
{
var tokenTags = new TokenTagCollection(span);
string token = span.GetText();
int position = span.Start + token.Length;
if (_builtInTokens.Contains(token))
{
tokenTags.SetClassifierTag(BUILT_IN_TOKEN_TYPE);
}
else if (IsFloatingConstant(token))
{
tokenTags.SetClassifierTag(FLOAT_TOKEN_TYPE);
}
else if (IsIntegerConstant(token))
{
var isFloat = false;
// Now that we have matched with an integer, look ahead to see if we are followed by a decimal
if (span.Snapshot.GetText(span.End, 1) == ".")
{
var nConsumed = 1;
var text = span.Snapshot.GetText();
for (var i = span.End.Position + 1; i < text.Length; i++)
{
if (char.IsNumber(text[i]))
{
isFloat = true;
nConsumed++;
}
else if (text[i] == 'f' || text[i] == 'F')
{
nConsumed++;
break;
}
else if (text[i] == 'l')
{
if (text[i + 1] == 'f' || text[i + 1] == 'F')
{
nConsumed += 2;
}
else
{
isFloat = false;
}
break;
}
else
{
break;
}
}
if (isFloat)
{
tokenTags.ClassifierTagSpan = new TagSpan <GLSLClassifierTag>(span.Extended(nConsumed), new GLSLClassifierTag(FLOAT_TOKEN_TYPE));
}
}
if (!isFloat)
{
tokenTags.SetClassifierTag(INT_TOKEN_TYPE);
}
}
return(tokenTags);
}
