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; }