public IList <ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
{
if (span.Length == 0)
{
return(emptyClassification);
}
// classifications are cached by textbuffer and invalidated as the version of the snapshot changes
Tuple <int, FSharp.Collections.FSharpList <SyntaxHighlighting.Ast.Span> > cacheEntry;
FSharp.Collections.FSharpList <SyntaxHighlighting.Ast.Span> cachedSpans;
if (this.classificationCache.TryGetValue(span.Snapshot.TextBuffer, out cacheEntry) && cacheEntry.Item1 == span.Snapshot.Version.VersionNumber)
{
cachedSpans = cacheEntry.Item2;
}
else
{
// previously unknown or version changed
try {
cachedSpans = SyntaxHighlighting.Parser.Parse(span.Snapshot.GetText());
this.classificationCache[span.Snapshot.TextBuffer] = Tuple.Create(span.Snapshot.Version.VersionNumber, cachedSpans);
} catch {
// errors in syntax highlighting should not bring down VS
return(emptyClassification);
}
}
this.highlightedSpans[span.Snapshot.TextBuffer] = new SnapshotSpan(span.Snapshot, 0, span.Snapshot.Length);
var options = VSPackagePackage.Instance.OptionPage;
var kt = options.DimAnnotations ? this.dimmedKeywordType : this.keywordType;
var st = options.DimAnnotations ? this.dimmedSpecType : this.specType;
// return list of detected spans filtered to those that overlap the given span
List <ClassificationSpan> result = new List <ClassificationSpan>();
foreach (var pos in cachedSpans)
{
if (pos.IsSpec)
{
var spec = (SyntaxHighlighting.Ast.Span.Spec)pos;
var specSpan = new Span(spec.Item1, spec.Item2);
if (span.OverlapsWith(specSpan))
{
result.Add(new ClassificationSpan(new SnapshotSpan(span.Snapshot, specSpan), st));
}
}
else if (pos.IsKeyword)
{
var kw = (SyntaxHighlighting.Ast.Span.Keyword)pos;
var kwSpan = new Span(kw.Item1, kw.Item2);
if (span.OverlapsWith(kwSpan))
{
result.Add(new ClassificationSpan(new SnapshotSpan(span.Snapshot, kwSpan), kt));
}
}
}
return(result);
}
public IEnumerable <ClassificationSpan> Classify(SnapshotSpan span)
{
SnapshotSpan prefixSpan, commandSpan, argumentsSpan;
var command = TryParseCommand(span.Snapshot.GetExtent(), out prefixSpan, out commandSpan, out argumentsSpan);
if (command == null)
{
yield break;
}
if (span.OverlapsWith(prefixSpan))
{
yield return(Classification(span.Snapshot, prefixSpan, _classificationRegistry.Keyword));
}
if (span.OverlapsWith(commandSpan))
{
yield return(Classification(span.Snapshot, commandSpan, _classificationRegistry.Keyword));
}
if (argumentsSpan.Length > 0)
{
foreach (var classifiedSpan in command.ClassifyArguments(span.Snapshot, argumentsSpan.Span, span.Span))
{
yield return(classifiedSpan);
}
}
}
internal bool OverlapsWith(SnapshotSpan span, ITextSnapshot snapshot)
{
if (IsSelection())
{
return(span.OverlapsWith(GetSpan(snapshot)));
}
else
{
return(span.OverlapsWith(new SnapshotSpan(Caret.GetPoint(snapshot), 1)));
}
}
internal bool OverlapsWith(SnapshotSpan span, ITextSnapshot snapshot)
{
if (IsSelection())
{
return(span.OverlapsWith(GetSpan(snapshot)));
}
else
{
var caretPoint = Caret.GetPoint(snapshot);
return(span.OverlapsWith(new SnapshotSpan(caretPoint, snapshot.Length > caretPoint.Position ? 1 : 0)));
}
}
public IEnumerable <ITagSpan <CommentTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (!CommentTranslatorPackage.Settings.AutoTranslateComment || spans.Count == 0 || _parser == null)
{
yield break;
}
var currentRegions = this._regions;
var currentSnapshot = this._snapshot;
var entire = new SnapshotSpan(spans[0].Start, spans[spans.Count - 1].End).TranslateTo(currentSnapshot, SpanTrackingMode.EdgeExclusive);
var commentTagSpans = _classificationTag.GetTagSpan(spans, "comment");
var rangeItems = commentTagSpans.Select(tp => new RangeItem(tp.Span.Start.Position, tp.Span.End.Position));
var ranges = new RangeTree <int, RangeItem>(new RangeItemComparer());
if (rangeItems.Count() > 0)
{
ranges.Add(rangeItems);
}
foreach (var region in currentRegions)
{
if (entire.OverlapsWith(new Span(region.Start, region.Length)) && ranges.Query(new Range <int>(region.Start, region.End)).Count > 0)
{
var span = new SnapshotSpan(currentSnapshot, region.Start, region.Length);
var tag = new CommentTag(span.GetText(), _parser, 200);
yield return(new TagSpan <CommentTag>(span, tag));
}
}
}
public IEnumerable <ITagSpan <LexTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
foreach (SnapshotSpan curSpan in spans)
{
if (curSpan.Snapshot != _lineCacheSnapshot)
{
yield break;
}
ITextSnapshotLine line = curSpan.Start.GetContainingLine();
_lexer.HaveLine(line.GetText(), _lineStartState[line.LineNumber]);
int location = line.Start;
while (location < line.End)
{
int length;
TokenId token = _lexer.Token(out length);
if (token != TokenId.Ignore)
{
var tokenSpan = new SnapshotSpan(curSpan.Snapshot, new Span(location, length));
if (tokenSpan.OverlapsWith(curSpan))
{
yield return(new TagSpan <LexTag>(tokenSpan, new LexTag(token)));
}
}
location += length;
}
}
}
public IList <ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
{
List <ClassificationSpan> result = new List <ClassificationSpan>();
this.UpdateBlocks(span, true);
int position = span.Start.Position;
int index = this.FindBlockIndex(span, span.Start.Position, false);
while (index < this.trackedBlocks.Count)
{
TrackedBlock block = this.trackedBlocks[index];
this.CacheBlock(span, block);
int classificationStartPosition = block.Block.GetStartPoint(span.Snapshot);
int classificationIndex = 0;
while (classificationIndex < block.CachedClassifications.Count && position < span.End.Position)
{
ClassificationSpan classification = block.CachedClassifications[classificationIndex];
int classificationEndPosition = classificationStartPosition + classification.Span.Length;
if (span.OverlapsWith(Span.FromBounds(classificationStartPosition, classificationEndPosition)))
{
result.Add(classification);
}
++classificationIndex;
classificationStartPosition = classificationEndPosition;
if (classificationEndPosition >= span.End.Position)
{
return(result);
}
}
++index;
}
return(result);
}
public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
{
if (span.Length == 0) return emptyClassification;
// classifications are cached by textbuffer and invalidated as the version of the snapshot changes
Tuple<int, FSharp.Collections.FSharpList<SyntaxHighlighting.Ast.Span>> cacheEntry;
FSharp.Collections.FSharpList<SyntaxHighlighting.Ast.Span> cachedSpans;
if (this.classificationCache.TryGetValue(span.Snapshot.TextBuffer, out cacheEntry) && cacheEntry.Item1 == span.Snapshot.Version.VersionNumber) {
cachedSpans = cacheEntry.Item2;
} else {
// previously unknown or version changed
try {
cachedSpans = SyntaxHighlighting.Parser.Parse(span.Snapshot.GetText());
this.classificationCache[span.Snapshot.TextBuffer] = Tuple.Create(span.Snapshot.Version.VersionNumber, cachedSpans);
} catch {
// errors in syntax highlighting should not bring down VS
return emptyClassification;
}
}
this.highlightedSpans[span.Snapshot.TextBuffer] = new SnapshotSpan(span.Snapshot, 0, span.Snapshot.Length);
var options = VSPackagePackage.Instance.OptionPage;
var kt = options.DimAnnotations ? this.dimmedKeywordType : this.keywordType;
var st = options.DimAnnotations ? this.dimmedSpecType : this.specType;
// return list of detected spans filtered to those that overlap the given span
List<ClassificationSpan> result = new List<ClassificationSpan>();
foreach (var pos in cachedSpans) {
if (pos.IsSpec) {
var spec = (SyntaxHighlighting.Ast.Span.Spec)pos;
var specSpan = new Span(spec.Item1, spec.Item2);
if (span.OverlapsWith(specSpan)) result.Add(new ClassificationSpan(new SnapshotSpan(span.Snapshot, specSpan), st));
} else if (pos.IsKeyword) {
var kw = (SyntaxHighlighting.Ast.Span.Keyword)pos;
var kwSpan = new Span(kw.Item1, kw.Item2);
if (span.OverlapsWith(kwSpan)) result.Add(new ClassificationSpan(new SnapshotSpan(span.Snapshot, kwSpan), kt));
}
}
return result;
}
public void RemoveAdornmentsByVisualSpan(SnapshotSpan visualSpan)
{
if (visualSpan.Snapshot is null)
{
throw new ArgumentException();
}
for (int i = adornmentLayerElements.Count - 1; i >= 0; i--)
{
var elem = adornmentLayerElements[i];
if (elem.VisualSpan is not null && visualSpan.OverlapsWith(GetOverlapsWithSpan(elem.VisualSpan.Value)))
{
adornmentLayerElements.RemoveAt(i);
Children.RemoveAt(i);
elem.RemovedCallback?.Invoke(elem.Tag, elem.Adornment);
}
}
}
public Collection <TextBounds> GetNormalizedTextBounds(SnapshotSpan bufferSpan)
{
if (bufferSpan.OverlapsWith(lineSpan))
{
double leading = 0;
if (lineSpan.Contains(bufferSpan.Start))
{
leading = textEditor.LocationToPoint(textEditor.OffsetToLocation(bufferSpan.Start)).X;
}
var endLoc = textEditor.OffsetToLocation(lineSpan.Contains(bufferSpan.End) ? bufferSpan.End : lineSpan.End);
double endPos = textEditor.LocationToPoint(endLoc).X;
return(new Collection <TextBounds>(new List <TextBounds>()
{
new TextBounds(leading, Top, endPos - leading, TextHeight, TextTop, TextHeight)
}));
}
else
{
return(new Collection <TextBounds>());
}
}
public void RemoveMatchingAdornments(SnapshotSpan visualSpan, Predicate <IAdornmentLayerElement> match)
{
if (visualSpan.Snapshot is null)
{
throw new ArgumentException();
}
if (match is null)
{
throw new ArgumentNullException(nameof(match));
}
for (int i = adornmentLayerElements.Count - 1; i >= 0; i--)
{
var elem = adornmentLayerElements[i];
if (elem.VisualSpan is not null && visualSpan.OverlapsWith(GetOverlapsWithSpan(elem.VisualSpan.Value)) && match(elem))
{
adornmentLayerElements.RemoveAt(i);
Children.RemoveAt(i);
elem.RemovedCallback?.Invoke(elem.Tag, elem.Adornment);
}
}
}
public IEnumerable <ITagSpan <IOutliningRegionTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (0 == spans.Count)
{
yield break;
}
var currentRegionSpans = regionSpans;
if (0 == currentRegionSpans.Count)
{
yield break;
}
SnapshotSpan entire = new SnapshotSpan(spans[0].Start, spans[spans.Count - 1].End).TranslateTo(currentRegionSpans[0].Snapshot, SpanTrackingMode.EdgeInclusive);
foreach (var region in currentRegionSpans)
{
if (entire.OverlapsWith(region))
{
yield return(new TagSpan <IOutliningRegionTag>(region, new OutliningRegionTag(false, false, ellipsis, region.GetText())));
}
}
}
public IList <ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
{
VSSnapshot currentSnapshot = new VSSnapshot(this.source, span.Snapshot);
LinkedList <Token> tokens = this.lexer.Run(currentSnapshot, span.Start.GetContainingLine().ExtentIncludingLineBreak.Span.ToGLSLSpan());
List <ClassificationSpan> spans = new List <ClassificationSpan>();
SyntaxTree tree = this.source.Tree;
if (tree == null)
{
return(spans);
}
foreach (Token token in tokens)
{
if (!span.OverlapsWith(token.Span.ToVSSpan()))
{
continue;
}
SyntaxToken syntaxToken = tree?.GetNodeFromPosition(this.source.CurrentSnapshot, token.Span.Start) as SyntaxToken;
string classificationName = string.Empty;
if (syntaxToken != null)
{
classificationName = syntaxToken.GetClassificationName();
}
else
{
if (token.SyntaxType.IsPreprocessor())
{
classificationName = GLSLConstants.PreprocessorKeyword;
}
else if (token.SyntaxType.IsPunctuation())
{
classificationName = GLSLConstants.Punctuation;
}
else if (token.SyntaxType.IsKeyword())
{
classificationName = GLSLConstants.Keyword;
}
else if (token.SyntaxType.IsNumber())
{
classificationName = GLSLConstants.Number;
}
else if (token.SyntaxType == SyntaxType.IdentifierToken)
{
classificationName = GLSLConstants.Identifier;
}
}
if (!string.IsNullOrEmpty(classificationName))
{
SnapshotSpan snapshotSpan = new SnapshotSpan(span.Snapshot, token.Span.ToVSSpan());
spans.Add(new ClassificationSpan(snapshotSpan, this.classificationTypeRegistryService.GetClassificationType(classificationName)));
}
}
this.ColorComments(span, spans, currentSnapshot, this.lexer.CommentSpans);
return(spans);
}
public IEnumerable<ClassificationSpan> Classify(SnapshotSpan span)
{
SnapshotSpan prefixSpan, commandSpan, argumentsSpan;
var command = TryParseCommand(span.Snapshot.GetExtent(), out prefixSpan, out commandSpan, out argumentsSpan);
if (command == null)
{
yield break;
}
if (span.OverlapsWith(prefixSpan))
{
yield return Classification(span.Snapshot, prefixSpan, _classificationRegistry.Keyword);
}
if (span.OverlapsWith(commandSpan))
{
yield return Classification(span.Snapshot, commandSpan, _classificationRegistry.Keyword);
}
if (argumentsSpan.Length > 0)
{
foreach (var classifiedSpan in command.ClassifyArguments(span.Snapshot, argumentsSpan.Span, span.Span))
{
yield return classifiedSpan;
}
}
}
public void RemoveAdornmentsByVisualSpan(SnapshotSpan visualSpan) {
if (visualSpan.Snapshot == null)
throw new ArgumentException();
for (int i = adornmentLayerElements.Count - 1; i >= 0; i--) {
var elem = adornmentLayerElements[i];
if (elem.VisualSpan != null && visualSpan.OverlapsWith(GetOverlapsWithSpan(elem.VisualSpan.Value))) {
adornmentLayerElements.RemoveAt(i);
Children.RemoveAt(i);
elem.RemovedCallback?.Invoke(elem.Tag, elem.Adornment);
}
}
}
private void CallWrappedParser(SnapshotSpan?_span, out ITextSnapshot currentSnapshot, out bool is_globalParse, out List <TSLTokenSpan> tokenSpans)
{
string buffer;
var bufferLines = new List <string>();
var lineOffsets = new List <int>();
currentSnapshot = null;
is_globalParse = (_span == null);
if (is_globalParse)
{
currentSnapshot = _textBuffer.CurrentSnapshot;
buffer = currentSnapshot.GetText();
foreach (var line in currentSnapshot.Lines)
{
bufferLines.Add(line.GetText());
lineOffsets.Add(line.Start);
}
}
else
{
SnapshotSpan span = _span.Value;
buffer = span.GetText();
currentSnapshot = span.Snapshot;
foreach (var overlappedLine in
from snapshotLine in currentSnapshot.Lines.Select(line => new SnapshotSpan(line.Start, line.End))
where span.OverlapsWith(snapshotLine)
select span.Overlap(snapshotLine).Value)
{
//TODO efficiency low
bufferLines.Add(overlappedLine.GetText());
lineOffsets.Add(overlappedLine.Start);
}
}
WrappedTokenList tokenList = null;
tokenSpans = new List <TSLTokenSpan>();
lock (gParserLock)
{
//Trinity.TSL.Parser lib is not reentrant.
try
{
tokenList = new WrappedTokenList(
buffer,
bufferLines,
lineOffsets
);
}
catch (Exception)
{
//TODO log
return;
}
}
foreach (var token in tokenList.tokens)
{
try
{
tokenSpans.Add(new TSLTokenSpan(new SnapshotSpan(currentSnapshot, new Span(token.FirstOffset, token.SecondOffset - token.FirstOffset + 1)), token.type));
}
catch (Exception)
{
//TODO log
}
}
}
public void RemoveMatchingAdornments(SnapshotSpan visualSpan, Predicate<IAdornmentLayerElement> match) {
if (visualSpan.Snapshot == null)
throw new ArgumentException();
if (match == null)
throw new ArgumentNullException(nameof(match));
for (int i = adornmentLayerElements.Count - 1; i >= 0; i--) {
var elem = adornmentLayerElements[i];
if (elem.VisualSpan != null && visualSpan.OverlapsWith(GetOverlapsWithSpan(elem.VisualSpan.Value)) && match(elem)) {
adornmentLayerElements.RemoveAt(i);
Children.RemoveAt(i);
elem.RemovedCallback?.Invoke(elem.Tag, elem.Adornment);
}
}
}
