public IEnumerable <ITagSpan <GcodeTokenTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
foreach (SnapshotSpan curSpan in spans)
{
ITextSnapshotLine containingLine = curSpan.Start.GetContainingLine();
int curLoc = containingLine.Start.Position;
string tokenLine = containingLine.GetText();
// by the time we get here, we might have a tag with adjacent comments:
// G01(isthisacomment)X21
GcodeHelper GcodeHelper = new GcodeHelper(tokenLine);
foreach (GcodeHelper.GcodeItem Item in GcodeHelper.GcodeItems)
{
var tokenSpan = new SnapshotSpan(curSpan.Snapshot, new Span(curLoc, Item.ItemText.Length));
if (Item.ItemType != GcodeTokenTypes.Gcode_Undefined && tokenSpan.IntersectsWith(curSpan))
{
yield return(new TagSpan <GcodeTokenTag>(tokenSpan,
new GcodeTokenTag(Item.ItemType)));
}
else
{
// no tag colorization
}
curLoc += Item.ItemText.Length;
}
}
}
public IEnumerable <ITagSpan <ObjectiveCTokenTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
foreach (SnapshotSpan curSpan in spans)
{
ITextSnapshotLine containingLine = curSpan.Start.GetContainingLine();
int curLoc = containingLine.Start.Position;
string[] delimiters = new string[10] {
" ", "\t", ";", ":", ".", ",", "(", ")", "[", "]"
};
string[] tokens = containingLine.GetText().Split(delimiters, StringSplitOptions.None);
foreach (string ObjectiveCToken in tokens)
{
if (mDict.ContainsKey(ObjectiveCToken))
{
var tokenSpan = new SnapshotSpan(curSpan.Snapshot, new Span(curLoc, ObjectiveCToken.Length));
if (tokenSpan.IntersectsWith(curSpan))
{
yield return(new TagSpan <ObjectiveCTokenTag>(tokenSpan, new ObjectiveCTokenTag(mDict[ObjectiveCToken])));
}
}
else if (ObjectiveCToken.StartsWith("@\""))
{
var tokenSpan = new SnapshotSpan(curSpan.Snapshot, new Span(curLoc, 1));
if (tokenSpan.IntersectsWith(curSpan))
{
yield return(new TagSpan <ObjectiveCTokenTag>(tokenSpan, new ObjectiveCTokenTag(ObjectiveCTokenTypes.AtString)));
}
}
//add an extra char location because of the space
curLoc += ObjectiveCToken.Length + 1;
}
}
}
public IEnumerable <ITagSpan <PerlTokenTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
foreach (SnapshotSpan span in spans)
{
ITextSnapshotLine snapshotLine = span.Start.GetContainingLine();
string line = snapshotLine.GetText();
string[] lineTokens = Regex.Split(line, @"(\#\!.*|\#.*|""[^""]*""|'[^']*'|\s+|\(|\)|\{|\}|->)");
int pos = snapshotLine.Start.Position;
//int linePos = 0;
foreach (string token in lineTokens)
{
//if(TokenTypes.All.Contains(token, StringComparer.OrdinalIgnoreCase))
//{
SnapshotSpan tokenSpan = new SnapshotSpan(span.Snapshot, new Span(pos, token.Length));
if (tokenSpan.IntersectsWith(span))
{
yield return(new TagSpan <PerlTokenTag>(
tokenSpan,
new PerlTokenTag(token)));
}
//}
//linePos += token.Length;
pos += token.Length;
}
}
}
public IEnumerable <ITagSpan <BrightScriptTokenTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
foreach (SnapshotSpan curSpan in spans)
{
ITextSnapshotLine containingLine = curSpan.Start.GetContainingLine();
int startPos = containingLine.Start.Position;
var line = containingLine.GetText();
var scanner = new ScannerColor();
scanner.SetSource(line, 0);
int token;
while ((token = scanner.yylex()) != (int)TokensColor.EOF)
{
if (_bsTypes.ContainsKey(token))
{
var tokenSpan = new SnapshotSpan(curSpan.Snapshot, new Span(startPos + scanner.GetPos(), scanner.yyleng));
if (tokenSpan.IntersectsWith(curSpan))
{
yield return(new TagSpan <BrightScriptTokenTag>(tokenSpan, new BrightScriptTokenTag(_bsTypes[token])));
}
}
}
}
}
public IEnumerable <ITagSpan <IErrorTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
//this may be assigned from another thread so capture a consistent value
var args = lastArgs;
if (args == null || spans.Count == 0)
{
yield break;
}
var parse = args.ParseResult;
var snapshot = args.Snapshot;
//FIXME is this correct handling of errors that span multiple spans?
foreach (var taggingSpan in spans)
{
foreach (var diag in parse.Diagnostics)
{
var diagSpan = new SnapshotSpan(snapshot, diag.Span.Start, diag.Span.Length);
//if the parse was from an older snapshot, map the positions into the current snapshot
if (snapshot != taggingSpan.Snapshot)
{
var trackingSpan = snapshot.CreateTrackingSpan(diagSpan, SpanTrackingMode.EdgeInclusive);
diagSpan = trackingSpan.GetSpan(taggingSpan.Snapshot);
}
if (diagSpan.IntersectsWith(taggingSpan))
{
var errorType = GetErrorTypeName(diag.Descriptor.Severity);
yield return(new TagSpan <ErrorTag> (diagSpan, new ErrorTag(errorType, diag.GetFormattedMessage())));
}
}
}
}
public IEnumerable <ITagSpan <AZTokenTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
/// Called by GetTags from aggregator, spans is one line inside the file
foreach (SnapshotSpan curSpan in spans)
{
// Get the line into ITextSnapshotLine
ITextSnapshotLine containingLine = curSpan.Start.GetContainingLine();
// Get the start position
int curLoc = containingLine.Start.Position;
// Truncated into different parts
string[] tokens = containingLine.GetText().ToLower().Split(' ');
foreach (string currSubString in tokens)
{
if (_AZTypes.ContainsKey(currSubString))
{
var tokenSpan = new SnapshotSpan(curSpan.Snapshot, new Span(curLoc, currSubString.Length));
if (tokenSpan.IntersectsWith(curSpan))
{
yield return(new TagSpan <AZTokenTag>(tokenSpan, new AZTokenTag(_AZTypes[currSubString])));
}
}
//add an extra char location because of the space
curLoc += currSubString.Length + 1;
}
}
}
public IEnumerable <ITagSpan <FanucGCodeTokenTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
foreach (SnapshotSpan curSpan in spans)
{
ITextSnapshotLine containingLine = curSpan.Start.GetContainingLine();
int curLoc = containingLine.Start.Position;
var tokens = FanucGCodeScanner.Tokenise(containingLine.GetText());
foreach (var fanucGCodeToken in tokens)
{
// tag known tokens only. when all valid tokens are supported for tagging, can just have:
//if (fanucGCodeToken.TokenType != FanucGCodeTokenTypes.Unknown) here.
if (_supportedTypes.Contains(fanucGCodeToken.TokenType))
{
var tokenSpan = new SnapshotSpan(curSpan.Snapshot, new Span(curLoc + fanucGCodeToken.StartPos, fanucGCodeToken.Length));
if (tokenSpan.IntersectsWith(curSpan))
{
yield return(new TagSpan <FanucGCodeTokenTag>(tokenSpan,
new FanucGCodeTokenTag(fanucGCodeToken.TokenType)));
}
}
}
}
}
//This is the main method of the classifier. It should return one ClassificationSpan per group that needs coloring.
//It will be called with a span that spans a single line where the edit has been made (or multiple times in paste operations).
public IList <ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
{
List <ClassificationSpan> classificationSpans = new List <ClassificationSpan>();
//Create a parser to parse the regular expression, and return the classification spans defined by it.
foreach (Token token in span.Snapshot.TextBuffer.Properties.GetProperty <ParserRunner>(typeof(ParserRunner)).Parser.Tokens)
{
if (token.Kind == TokenKind.Capture)
{
classificationSpans.Add(new ClassificationSpan(new SnapshotSpan(span.Snapshot, token.Start, 1), classificationTypeRegistry.GetClassificationType(ClassificationTypes.Capture)));
classificationSpans.Add(new ClassificationSpan(new SnapshotSpan(span.Snapshot, token.End - 1, 1), classificationTypeRegistry.GetClassificationType(ClassificationTypes.Capture)));
}
else
{
classificationSpans.Add(new ClassificationSpan(new SnapshotSpan(span.Snapshot, token.Start, token.End - token.Start), classificationTypeRegistry.GetClassificationType(Token.TranslateEnumToString(token.Kind))));
}
if (span.IntersectsWith(new Span(token.Start, token.End)) && !(span.Start.Position <= token.Start && span.End.Position >= token.End) &&
(token.Kind == TokenKind.Capture || token.Kind == TokenKind.CharGroup || token.Kind == TokenKind.Multiplier))
{
RecolorizeAffectedLines(new Span(span.End, token.End - span.End), span.Snapshot);
}
}
return(classificationSpans);
}
public IList <ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
{
if (_classificationSpans.Length == 0)
{
return(ClassifierUtils.EmptyClassifications);
}
List <ClassificationSpan> spans = null;
foreach (var s in _classificationSpans)
{
if (span.End < s.Span.Start)
{
break;
}
if (span.IntersectsWith(s.Span))
{
if (spans == null)
{
spans = new List <ClassificationSpan>();
}
spans.Add(s);
}
}
return(spans ?? ClassifierUtils.EmptyClassifications);
}
public IEnumerable <ITagSpan <OokTokenTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
foreach (SnapshotSpan curSpan in spans)
{
ITextSnapshotLine containingLine = curSpan.Start.GetContainingLine();
int curLoc = containingLine.Start.Position;
string[] tokens = containingLine.GetText().ToLower().Split(' ');
foreach (string ookToken in tokens)
{
if (_ookTypes.ContainsKey(ookToken))
{
var tokenSpan = new SnapshotSpan(curSpan.Snapshot, new Span(curLoc, ookToken.Length));
if (tokenSpan.IntersectsWith(curSpan))
{
yield return(new TagSpan <OokTokenTag>(tokenSpan,
new OokTokenTag(_ookTypes[ookToken])));
}
}
//add an extra char location because of the space
curLoc += ookToken.Length + 1;
}
}
}
public IEnumerable <ITagSpan <ClassificationTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
foreach (SnapshotSpan curSpan in spans)
{
string snapshotText = curSpan.Snapshot.GetText();
ITextSnapshotLine containingLine = curSpan.Start.GetContainingLine();
int currentLocation = containingLine.Start.Position;
string[] tokens = containingLine.GetText().Split(delimiters);
foreach (string strToken in tokens)
{
if (0 < strToken.Length)
{
if (hashedKeywords.Contains(strToken))
{
// If it's inside the span of a (single or multiline) comment, do not highlight the keyword:
bool isInsideMultilineComment = snapshotText.LastIndexOf("/*", currentLocation) > snapshotText.LastIndexOf("*/", currentLocation);
bool isInsideSingleLineComment = snapshotText.LastIndexOf("//", currentLocation) > containingLine.Start.Position;
if (!(isInsideMultilineComment || isInsideSingleLineComment))
{
// If this is a keyword and it is part of the input span, return it:
var tokenSpan = new SnapshotSpan(curSpan.Snapshot, new Span(currentLocation, strToken.Length));
if (tokenSpan.IntersectsWith(curSpan))
{
yield return(new TagSpan <ClassificationTag>(tokenSpan, new ClassificationTag(_keywordType)));
}
}
}
}
// Also add an index for the delimiter we skipped:
currentLocation += strToken.Length + 1;
}
}
}
public IEnumerable <ISuggestedAction> GetSuggestedActions(SnapshotSpan range)
{
if (!TryGetLintChecker(out var lintChecker))
{
yield break;
}
if (!lintChecker.HasSnapshot)
{
yield break;
}
foreach (var error in lintChecker.LastErrorsSnapshot.Errors)
{
if (range.IntersectsWith(error.Span))
{
if (error.HasSuggestedFix)
{
yield return(new LintFixAction(error));
}
yield return(new LintSuppressAction(error));
}
}
}
public IEnumerable <ITagSpan <ClipsTokenTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
//Debug.WriteLine("GetTags");
foreach (SnapshotSpan curSpan in spans)
{
//Debug.WriteLine("curSpan = {0}", curSpan);
ITextSnapshotLine containingLine = curSpan.Start.GetContainingLine();
var lineStart = containingLine.Start.Position;
var position = lineStart;
var line = containingLine.GetText();
var lastToken = (string)null;
foreach (var token in Tokenize(line))
{
var type = GetTokenType(token, lastToken);
var tokenSpan = new SnapshotSpan(curSpan.Snapshot,
new Span(position, token.Length));
if (type != null && tokenSpan.IntersectsWith(curSpan))
{
var tag = new ClipsTokenTag(type);
var span = new TagSpan <ClipsTokenTag>(tokenSpan, tag);
//Debug.WriteLine("{0}", tag);
yield return(span);
}
if (type != PredefinedClassificationTypeNames.WhiteSpace)
{
lastToken = token;
}
position += token.Length;
}
}
}
//private void HandleLayoutChanged(object sender, TextViewLayoutChangedEventArgs e)
//{
// var visibleSpan = view.TextViewLines.FormattedSpan;
// // Filter out the adornments that are no longer visible.
// var toRemove =
// (from kv
// in adornmentCache
// where !kv.Key.Span.TranslateTo(visibleSpan.Snapshot, SpanTrackingMode.EdgeExclusive).IntersectsWith(visibleSpan)
// select kv.Key).ToList();
// foreach (var span in toRemove)
// adornmentCache.Remove(span);
//}
// Produces tags on the snapshot that the tag consumer asked for.
public IEnumerable <ITagSpan <IntraTextAdornmentTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (!isEnabled || spans == null || spans.Count == 0)
{
yield break;
}
var requestedSnapshot = spans[0].Snapshot;
var allTagSpans = perSnapshotResults.GetValue(Snapshot);
foreach (var tagSpan in allTagSpans)
{
foreach (var span in spans)
{
var adornment = (TeXCommentAdornment)tagSpan.Tag.Adornment;
var dataTagSpan = adornment.DataTag.SpanWithLastLineBreak;
var translatedDataTagSpan = new SnapshotSpan(Snapshot, dataTagSpan).TranslateTo(requestedSnapshot, SpanTrackingMode.EdgeExclusive);
if (translatedDataTagSpan.IntersectsWith(span))
{
var translatedTagSpan = new SnapshotSpan(Snapshot, tagSpan.Span).TranslateTo(requestedSnapshot, SpanTrackingMode.EdgeExclusive);
yield return(new TagSpan <IntraTextAdornmentTag>(translatedTagSpan, tagSpan.Tag));
break;
}
}
}
}
/// <summary>
/// Gets all the tags that intersect the spans in the specified snapshot
/// of the desired type.
/// </summary>
/// <param name="spans">The spans to visit.</param>
/// <returns>A <see cref="ITagSpan<T>"/> for each tag.</returns>
public IEnumerable <ITagSpan <T> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (spans.Count == 0)
{
yield break;
}
IList <TrackingTagSpan <T> > tagSpanList;
lock (mutex)
{
tagSpanList = new List <TrackingTagSpan <T> >(_trackingTagSpans);
}
foreach (var tagSpan in tagSpanList)
{
SnapshotSpan tagSnapshotSpan = tagSpan.Span.GetSpan(spans[0].Snapshot);
foreach (var querySpan in spans)
{
if (tagSnapshotSpan.IntersectsWith(querySpan))
{
yield return(new TagSpan <T>(tagSnapshotSpan, tagSpan.Tag));
break;
}
}
}
}
public IEnumerable <ITagSpan <ClassificationTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
foreach (SnapshotSpan curSpan in spans)
{
// Get our start and end line
var startLine = curSpan.Start.GetContainingLine();
var endLine = curSpan.End.GetContainingLine();
for (int x = startLine.LineNumber; x < endLine.LineNumber; x++)
{
var curLine = curSpan.Snapshot.GetLineFromLineNumber(x);
var curLineText = curLine.GetText();
_scanner.VsSetSource(curLineText, 0);
int state = 0; Token token;
while ((token = _scanner.VsReadToken(ref state)) != null)
{
var tokenSpan = new SnapshotSpan(curSpan.Snapshot, new Span(curLine.Start.Position + token.Location.Position, token.Length));
if (tokenSpan.IntersectsWith(curSpan))
{
yield return(new TagSpan <ClassificationTag>(tokenSpan, TaggerColors.Instance.TagColors[token.EditorInfo.Type]));
}
}
}
}
}
public async Task <MSBuildDiagnosticSeverity> GetFixSeverity(
ITextBuffer buffer, MSBuildParseResult result, SnapshotSpan range,
MSBuildDiagnosticSeverity severities, CancellationToken cancellationToken)
{
var filteredDiags = result.Diagnostics.Where(d => range.IntersectsWith(new SnapshotSpan(range.Snapshot, d.Span.Start, d.Span.Length)));
var severity = MSBuildDiagnosticSeverity.None;
void ReportFix(MSBuildAction a, ImmutableArray <MSBuildDiagnostic> diags)
{
foreach (var d in diags)
{
severity |= d.Descriptor.Severity;
}
};
//TODO invoke the provider once for all the diagnostics it supports
foreach (var diagnostic in filteredDiags)
{
if (cancellationToken.IsCancellationRequested)
{
return(severity);
}
if (range.IntersectsWith(new SnapshotSpan(range.Snapshot, diagnostic.Span.Start, diagnostic.Span.Length)))
{
if (diagnosticIdToFixProviderMap.TryGetValue(diagnostic.Descriptor.Id, out var fixProvider))
{
var ctx = new MSBuildFixContext(
buffer,
result.MSBuildDocument,
result.MSBuildDocument.XDocument,
new Xml.Dom.TextSpan(range.Start, range.Length),
ImmutableArray.Create(diagnostic),
ReportFix, cancellationToken);
await fixProvider.RegisterCodeFixesAsync(ctx);
//callers only really care about the highest severity, so if we got error, we can early out
if ((severity | MSBuildDiagnosticSeverity.Error) != 0)
{
return(severity);
}
}
}
}
return(severity);
}
/// <remarks>
/// FIXME: The buffer parameter is workaround for the spellchecker. It can be removed when
/// there is a better concept of a durable context/scope to which information can be bound.
/// </remarks>
public async Task <List <MSBuildCodeFix> > GetFixes(
ITextBuffer buffer, MSBuildParseResult result, SnapshotSpan range,
MSBuildDiagnosticSeverity requestedSeverities, CancellationToken cancellationToken)
{
var filteredDiags = ImmutableArray.CreateRange(
result.Diagnostics.Where(d => range.IntersectsWith(new SnapshotSpan(range.Snapshot, d.Span.Start, d.Span.Length))));
var fixes = new List <MSBuildCodeFix> ();
void ReportFix(MSBuildAction a, ImmutableArray <MSBuildDiagnostic> d)
{
lock (fixes) {
fixes.Add(new MSBuildCodeFix(a, d));
}
}
//TODO invoke the provider once for all the diagnostics it supports
foreach (var diagnostic in filteredDiags)
{
if ((diagnostic.Descriptor.Severity | requestedSeverities) == 0)
{
continue;
}
if (cancellationToken.IsCancellationRequested)
{
return(null);
}
if (range.IntersectsWith(new SnapshotSpan(range.Snapshot, diagnostic.Span.Start, diagnostic.Span.Length)))
{
if (diagnosticIdToFixProviderMap.TryGetValue(diagnostic.Descriptor.Id, out var fixProvider))
{
var ctx = new MSBuildFixContext(
buffer,
result.MSBuildDocument,
result.MSBuildDocument.XDocument,
new Xml.Dom.TextSpan(range.Start, range.Length),
ImmutableArray.Create(diagnostic),
ReportFix, cancellationToken);
await fixProvider.RegisterCodeFixesAsync(ctx);
}
}
}
return(fixes);
}
public IList <ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
{
List <OutputColors> colors;
if (_buffer.Properties.TryGetProperty(ColorKey, out colors))
{
List <ClassificationSpan> res = new List <ClassificationSpan>();
int startIndex = colors.BinarySearch(
new OutputColors(span.Start, span.Length, ConsoleColor.White),
MyComparer.Instance
);
if (startIndex < 0)
{
startIndex = ~startIndex;
}
for (int i = startIndex; i < colors.Count && ((colors[i].Start + colors[i].Length) >= span.Start); i++)
{
if (span.IntersectsWith(new Span(colors[i].Start, colors[i].Length)))
{
IClassificationType type;
if (_provider._classTypes.TryGetValue(colors[i].Color, out type))
{
SnapshotPoint start, end;
if (colors[i].Start < span.Start.Position)
{
start = span.Start;
}
else
{
start = new SnapshotPoint(span.Snapshot, colors[i].Start);
}
int endPos = colors[i].Start + colors[i].Length;
if (span.End < endPos)
{
end = span.End;
}
else
{
end = new SnapshotPoint(span.Snapshot, endPos);
}
res.Add(
new ClassificationSpan(
new SnapshotSpan(start, end),
type
)
);
}
}
}
return(res);
}
return(new ClassificationSpan[0]);
}
/// <summary>
/// Intersectses the with.
/// </summary>
static bool IntersectsWith(SnapshotSpan a, SnapshotSpan b)
{
return(SafeExecute(() =>
{
a = ToLine(a);
b = ToLine(b);
return a.IntersectsWith(b);
}));
}
/// <summary>
/// Gets the tagged spans that intersect the given <see cref="SnapshotSpan"/>.
/// </summary>
/// <param name="span">The <see cref="SnapshotSpan"/> to use.</param>
/// <returns>The set of <see cref="TrackingTagSpan<T>"/> objects that intersect the given span, in order.</returns>
public IEnumerable <TrackingTagSpan <T> > GetTaggedSpans(SnapshotSpan span)
{
IList <TrackingTagSpan <T> > tagSpanList = new List <TrackingTagSpan <T> >(_trackingTagSpans);
lock (mutex)
{
tagSpanList = new List <TrackingTagSpan <T> >(_trackingTagSpans);
}
return(tagSpanList.Where(tagSpan => span.IntersectsWith(tagSpan.Span.GetSpan(span.Snapshot))));
}
//=====================================================================
/// <inheritdoc />
public IEnumerable <ITagSpan <ClassificationTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (this.CurrentUnderlineSpan != null && spans.Count != 0)
{
SnapshotSpan request = new SnapshotSpan(spans[0].Start, spans[spans.Count - 1].End);
SnapshotSpan underline = this.CurrentUnderlineSpan.Value.TranslateTo(request.Snapshot, SpanTrackingMode.EdgeInclusive);
if (underline.IntersectsWith(request))
{
yield return(new TagSpan <ClassificationTag>(underline,
new ClassificationTag(UnderlineClassifierProvider.UnderlineClassification)));
}
}
}
public IEnumerable <ITagSpan <ClassificationTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (!this._underlineSpan.HasValue || (spans.Count == 0))
{
yield break;
}
SnapshotSpan request = new SnapshotSpan(spans[0].Start, spans[spans.Count - 1].End);
SnapshotSpan underline = this._underlineSpan.Value.TranslateTo(request.Snapshot, SpanTrackingMode.EdgeInclusive);
if (underline.IntersectsWith(request))
{
yield return(new TagSpan <ClassificationTag>(underline, new ClassificationTag(this._classificationType)));
}
}
public IEnumerable <ITagSpan <PropertiesTokenTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
foreach (SnapshotSpan curSpan in spans)
{
ITextSnapshotLine containingLine = curSpan.Start.GetContainingLine();
int lineStartLoc = containingLine.Start.Position;
int curLoc = lineStartLoc;
string lineText = containingLine.GetText();
string[] commentSplitTokens = lineText.ToLower().Split(new [] { '#' }, 2);
string[] keyValueSplitToken = commentSplitTokens[0].Split(new [] { '=' }, 2);
string key = keyValueSplitToken[0];
string value = keyValueSplitToken.Length == 1 ? null : keyValueSplitToken[1];
string comment = commentSplitTokens.Length == 1 ? null : commentSplitTokens[1];
if (!string.IsNullOrEmpty(key))
{
var tokenSpan = new SnapshotSpan(curSpan.Snapshot, new Span(curLoc, key.Length));
if (tokenSpan.IntersectsWith(curSpan))
{
yield return(new TagSpan <PropertiesTokenTag>(tokenSpan, new PropertiesTokenTag(KeyType)));
}
curLoc += key.Length + 1;
}
if (!string.IsNullOrEmpty(value))
{
var tokenSpan = new SnapshotSpan(curSpan.Snapshot, new Span(curLoc, value.Length));
if (tokenSpan.IntersectsWith(curSpan))
{
yield return(new TagSpan <PropertiesTokenTag>(tokenSpan, new PropertiesTokenTag(ValueType)));
}
curLoc += value.Length;
}
if (lineText.Contains("#"))
{
int commentStartLoc = lineStartLoc + lineText.IndexOf('#');
int commentLength = lineStartLoc + lineText.Length - commentStartLoc;
var tokenSpan = new SnapshotSpan(curSpan.Snapshot, new Span(commentStartLoc, commentLength));
if (tokenSpan.IntersectsWith(curSpan))
{
yield return(new TagSpan <PropertiesTokenTag>(tokenSpan, new PropertiesTokenTag(CommentType)));
}
curLoc += comment.Length + 1;
}
}
}
private IList <ClassificationSpan> GetSpansFor(ITextSnapshot compiledSnapshot, SnapshotSpan span, AmmyFile <Top> file)
{
var spanSnapshot = span.Snapshot;
var result = new List <ClassificationSpan>();
var ast = file.Ast;
var translatedSpan = span.TranslateTo(compiledSnapshot, SpanTrackingMode.EdgeExclusive);
var spanInfos = new HashSet <SpanInfo>();
file.ParseResult.GetSpans(span.Start, span.End, spanInfos);
var spanFinder = new FindSpansForVisitor(translatedSpan);
ast.Accept(spanFinder);
var allSpans = spanFinder.SpanInfos
.Concat(spanInfos)
.Where(si => si.Span.Length != spanSnapshot.Length)
.Distinct();
foreach (var spanInfo in allSpans)
{
var astSpan = spanInfo.Span;
var newSpan = new SnapshotSpan(compiledSnapshot, new Span(astSpan.StartPos, astSpan.Length))
.TranslateTo(spanSnapshot, SpanTrackingMode.EdgeInclusive);
var classificationType = _classifications.GetClassificationType(TranslateSpanName(spanInfo.SpanClass.FullName));
if (!newSpan.IntersectsWith(span))
{
continue;
}
if (newSpan.Start > 0)
{
var prefix = spanSnapshot.GetText(newSpan.Start - 1, 1);
if (prefix == "@" || prefix == "#" || prefix == "$")
{
newSpan = new SnapshotSpan(newSpan.Snapshot, newSpan.Start - 1, newSpan.Length + 1);
}
}
result.Add(new ClassificationSpan(newSpan, classificationType));
}
return(result);
}
#pragma warning restore 67
public IList <ClassificationSpan> GetClassificationSpans(SnapshotSpan processedSpan)
{
var currentSnapshot = processedSpan.Snapshot;
var result = new List <ClassificationSpan>();
for (int i = 0; i < _spanInfos.Length; i++)
{
var snapshot = _snapshots[i];
var spanInfos = _spanInfos[i];
var translatesSnapshot = processedSpan.TranslateTo(snapshot, SpanTrackingMode.EdgeExclusive);
var processedSpanInfo = new SpanInfo(new NSpan(translatesSnapshot.Span.Start, translatesSnapshot.Span.End), -1);
var index = spanInfos.BinarySearch(processedSpanInfo, SpanInfo.Comparer);
if (index < 0)
{
index = ~index;
}
var oldSpan = default(NSpan);
for (int k = index; k < spanInfos.Length; k++)
{
var spanInfo = spanInfos[k];
var span = spanInfo.Span;
if (oldSpan == span)
{
continue;
}
oldSpan = span;
var newSpan = new SnapshotSpan(snapshot, new Span(span.StartPos, span.Length))
.TranslateTo(currentSnapshot, SpanTrackingMode.EdgeExclusive);
if (!newSpan.IntersectsWith(processedSpan))
{
break;
}
if (ClassificationMap.TryGetValue(spanInfo.SpanClassId, out var classificationType))
{
result.Add(new ClassificationSpan(newSpan, classificationType));
}
else
{
}
}
}
return(result);
}
public void RemoveGlyphsByVisualSpan(SnapshotSpan span) {
List<UIElement> glyphsInSpan = new List<UIElement>();
foreach (var glyph in _glyphs) {
GlyphData data = glyph.Value;
if (data.VisualSpan.HasValue) {
if (span.IntersectsWith(data.VisualSpan.Value)) {
glyphsInSpan.Add(glyph.Key);
_canvas.Children.Remove(data.Element);
}
}
}
foreach (UIElement element in glyphsInSpan) {
_glyphs.Remove(element);
}
}
public IList <ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
{
Span lastSpan = new Span();
var list = new List <ClassificationSpan>();
if (_doc == null || _isProcessing || span.IsEmpty)
{
return(list);
}
var e = _doc.Descendants().Where(b => b.Span.Start <= span.End && b.Span.Length > 0);
foreach (var mdobj in e)
{
var blockSpan = new Span(mdobj.Span.Start, mdobj.Span.Length);
try
{
if (span.IntersectsWith(blockSpan))
{
var all = GetClassificationTypes(mdobj, span);
foreach (var range in all.Keys)
{
var snapspan = new SnapshotSpan(span.Snapshot, range);
// Literal spans may appear as children of other spans such as headings. When this
// occurs, we ignore them.
if (!lastSpan.Contains(snapspan))
{
list.Add(new ClassificationSpan(snapspan, all[range]));
lastSpan = snapspan;
}
}
}
}
catch (Exception ex)
{
// For some reason span.IntersectsWith throws in some cases.
System.Diagnostics.Debug.Write(ex);
}
}
return(list);
}
public IEnumerable <ITagSpan <RhetosTokenTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
foreach (SnapshotSpan curSpan in spans)
{
ITextSnapshotLine containingLine = curSpan.Start.GetContainingLine();
var regEx = @"(\b[^\s]+\b)";
var commentRegex = @"(//)+";
//TODO: implement error
int curLoc = containingLine.Start.Position;
var matchCollection = Regex.Matches(containingLine.GetText(), regEx, RegexOptions.IgnoreCase);
var commentMatchCollection = Regex.Matches(containingLine.GetText(), commentRegex, RegexOptions.IgnoreCase);
foreach (Match tokenMatch in matchCollection)
{
var matchLoc = curLoc + tokenMatch.Index;
if (_rhetosTypes.ContainsKey(tokenMatch.Value.ToLower()))
{
var tokenSpan = new SnapshotSpan(curSpan.Snapshot, new Span(matchLoc, tokenMatch.Length));
if (tokenSpan.IntersectsWith(curSpan))
{
Debug.WriteLine(String.Format("Match: {0}, CurLoc: {1}, Match index: {2}, MatchLoc: {3}", tokenMatch.Value, curLoc, tokenMatch.Index, matchLoc));
yield return(new TagSpan <RhetosTokenTag>(tokenSpan, new RhetosTokenTag(_rhetosTypes[tokenMatch.Value.ToLower()])));
}
}
}
foreach (Match tokenMatch in commentMatchCollection)
{
var matchLoc = curLoc + tokenMatch.Index;
var tokenSpan = new SnapshotSpan(curSpan.Snapshot, new Span(matchLoc, curSpan.End));
if (tokenSpan.IntersectsWith(curSpan))
{
Debug.WriteLine(String.Format("Match: {0}, CurLoc: {1}, Match index: {2}, MatchLoc: {3}", tokenMatch.Value, curLoc, tokenMatch.Index, matchLoc));
yield return(new TagSpan <RhetosTokenTag>(tokenSpan, new RhetosTokenTag(_rhetosTypes["RhetosComment".ToLower()])));
}
}
}
}
public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
{
if (_classificationSpans.Length == 0)
return ClassifierUtils.EmptyClassifications;
List<ClassificationSpan> spans = null;
foreach (var s in _classificationSpans)
{
if (span.End < s.Span.Start)
break;
if (span.IntersectsWith(s.Span))
{
if (spans == null)
spans = new List<ClassificationSpan>();
spans.Add(s);
}
}
return spans ?? ClassifierUtils.EmptyClassifications;
}
private DevSkimError GetErrorUnderCaret(SnapshotSpan range)
{
if (TryGetSkimChecker())
{
DevSkimErrorsSnapshot securityErrors = _skimChecker.LastSecurityErrors;
if (securityErrors != null)
{
foreach (var error in securityErrors.Errors)
{
if (range.IntersectsWith(error.Span))
{
return(error);
}
}
}
}
return(null);
}
public void RemoveGlyphsByVisualSpan(SnapshotSpan span)
{
var list = new List <UIElement>();
foreach (var pair in glyphs)
{
var data = pair.Value;
if (data.VisualSpan.HasValue && span.IntersectsWith(data.VisualSpan.Value))
{
list.Add(pair.Key);
visuals[data.GlyphType].Children.Remove(data.Glyph);
}
}
foreach (var element in list)
{
glyphs.Remove(element);
}
}
#pragma warning restore 67
public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan processedSpan)
{
var currentSnapshot = processedSpan.Snapshot;
var result = new List<ClassificationSpan>();
for (int i = 0; i < _spanInfos.Length; i++)
{
var snapshot = _snapshots[i];
var spanInfos = _spanInfos[i];
var translatesSnapshot = processedSpan.TranslateTo(snapshot, SpanTrackingMode.EdgeExclusive);
var processedSpanInfo = new SpanInfo(new NSpan(translatesSnapshot.Span.Start, translatesSnapshot.Span.End), -1);
var index = spanInfos.BinarySearch(processedSpanInfo, SpanInfo.Comparer);
if (index < 0)
index = ~index;
for (int k = index; k < spanInfos.Length; k++)
{
var spanInfo = spanInfos[k];
var span = spanInfo.Span;
var newSpan = new SnapshotSpan(snapshot, new Span(span.StartPos, span.Length))
.TranslateTo(currentSnapshot, SpanTrackingMode.EdgeExclusive);
if (!newSpan.IntersectsWith(processedSpan))
break;
var classificationType = ClassificationMap[spanInfo.SpanClassId];
result.Add(new ClassificationSpan(newSpan, classificationType));
}
}
return result;
}
/// <summary>
/// Visits the specified UVSS document and returns a list of classification spans that
/// intersect with the specified span.
/// </summary>
/// <param name="document">The document to visit.</param>
/// <param name="span">The span for which to retrieve classification spans.</param>
/// <returns>The classification spans that intersect with the specified span.</returns>
public IList<ClassificationSpan> VisitDocument(UvssTextParserResult result, SnapshotSpan span)
{
if (result.Document == null)
return null;
span = span.TranslateTo(result.Snapshot, SpanTrackingMode.EdgeExclusive);
var results = new List<ClassificationSpan>();
var visitor = new UvssClassifierVisitor(registry, (start, width, type, kind) =>
{
var nodeSpan = new SnapshotSpan(span.Snapshot, start, width);
if (nodeSpan.IntersectsWith(span))
results.Add(new ClassificationSpan(nodeSpan, type));
});
visitor.Visit(result.Document);
return results;
}
