public List <PrioritiesClassificationSpan> Parse(SnapshotSpan span)
        {
            var matches = m_Regex.Matches(span.GetText());

            if (matches.Count == 0)
            {
                return(new List <PrioritiesClassificationSpan>());
            }

            List <PrioritiesClassificationSpan> classifications = new List <PrioritiesClassificationSpan>();

            foreach (Match match in matches)
            {
                if (match.Groups.Count == 0)
                {
                    continue;
                }

                Group        group    = match.Groups[1];
                Span         spanWord = new Span(span.Start.Position + group.Index, group.Length);
                SnapshotSpan snapshot = new SnapshotSpan(span.Snapshot, spanWord);

                var prioSpan = new PrioritiesClassificationSpan();
                prioSpan.Span = new ClassificationSpan(snapshot, m_Type);
                classifications.Add(prioSpan);
            }
            return(classifications);
        }
        private List <PrioritiesClassificationSpan> ParseMultiLine(SnapshotSpan span)
        {
            List <PrioritiesClassificationSpan> classifications = new List <PrioritiesClassificationSpan>();

            string code = span.GetText();

            int startPosition = IndexOfCommentStart(code);

            if (startPosition < 0)
            {
                return(new List <PrioritiesClassificationSpan>());
            }

            int segmentIndex = span.Start.Position + startPosition;
            int lineNumber   = span.Snapshot.GetLineNumberFromPosition(segmentIndex);

            try
            {
                string codeSegment = span.Snapshot.GetLineFromLineNumber(lineNumber).GetText();
                int    endPosition = IndexOfCommentEnd(codeSegment);
                while (endPosition < 0)
                {
                    ++lineNumber;
                    codeSegment = span.Snapshot.GetLineFromLineNumber(lineNumber).GetText();
                    endPosition = IndexOfCommentEnd(codeSegment);
                }
            }
            catch (ArgumentOutOfRangeException)
            {
                lineNumber = lineNumber - 1;
            }

            int startIndex = span.Start.Position + startPosition;
            int endIndex   = span.Snapshot.GetLineFromLineNumber(lineNumber).End.Position;
            var multiSpan  = new SnapshotSpan(span.Snapshot, startIndex, (endIndex - startIndex));

            if (multiSpan.End > span.End)
            {
                ClassificationChanged?.Invoke(this,
                                              new ClassificationChangedEventArgs(new SnapshotSpan(span.End + 1, multiSpan.End)));
            }

            var priorClassification = new PrioritiesClassificationSpan
            {
                Span = new ClassificationSpan(multiSpan, m_Type), Priority = 400
            };

            classifications.Add(priorClassification);

            if (m_MultiLineComments.Any(a => a.Tracking.GetSpan(span.Snapshot).Span == multiSpan.Span) == false)
            {
                m_MultiLineComments.Add(new MultiLineComment()
                {
                    Version  = span.Snapshot.Version,
                    Tracking = span.Snapshot.CreateTrackingSpan(multiSpan.Span, SpanTrackingMode.EdgeExclusive)
                });
            }

            return(classifications);
        }
Beispiel #3
0
        public List <PrioritiesClassificationSpan> Parse(SnapshotSpan span)
        {
            List <PrioritiesClassificationSpan> classifications = new List <PrioritiesClassificationSpan>();

            foreach (string word in m_Keywords)
            {
                Regex reg     = new Regex(@"(" + word + @")[\s<]+", RegexOptions.IgnoreCase);
                var   matches = reg.Matches(span.GetText());

                if (matches.Count == 0)
                {
                    continue;
                }

                foreach (Match match in matches)
                {
                    if (match.Groups.Count == 0)
                    {
                        continue;
                    }

                    Group group = match.Groups[1];
                    if (group.Index > 0)
                    {
                        Regex  regWhitspace = new Regex(@"\s+", RegexOptions.IgnoreCase);
                        string code         = "" + span.GetText()[group.Index - 1];
                        if (regWhitspace.IsMatch(code) == false)
                        {
                            continue;
                        }
                    }

                    Span         spanWord = new Span(span.Start.Position + group.Index, group.Length);
                    SnapshotSpan snapshot = new SnapshotSpan(span.Snapshot, spanWord);

                    var prioSpan = new PrioritiesClassificationSpan();
                    prioSpan.Span     = new ClassificationSpan(snapshot, m_Type);
                    prioSpan.Priority = 200;
                    classifications.Add(prioSpan);
                }
            }
            return(classifications);
        }
Beispiel #4
0
        public List <PrioritiesClassificationSpan> Parse(SnapshotSpan span)
        {
            var matches = m_Regex.Matches(span.GetText());

            if (matches.Count == 0)
            {
                return(new List <PrioritiesClassificationSpan>());
            }

            List <PrioritiesClassificationSpan> classifications = new List <PrioritiesClassificationSpan>();

            foreach (Match match in matches)
            {
                Span         spanWord = new Span(span.Start.Position + match.Index, match.Length);
                SnapshotSpan snapshot = new SnapshotSpan(span.Snapshot, spanWord);

                var priorClassification = new PrioritiesClassificationSpan
                {
                    Span = new ClassificationSpan(snapshot, m_Type), Priority = 300
                };
                classifications.Add(priorClassification);
            }
            return(classifications);
        }
Beispiel #5
0
        public List <PrioritiesClassificationSpan> Parse(SnapshotSpan span)
        {
            List <PrioritiesClassificationSpan> classifications = new List <PrioritiesClassificationSpan>();

            bool isInsideOfComment = false;

            for (int i = m_MultiLineComments.Count - 1; i >= 0; i--)
            {
                var comment   = m_MultiLineComments[i];
                var multiSpan = comment.Tracking.GetSpan(span.Snapshot);
                if (multiSpan.Length == 0)
                {
                    m_MultiLineComments.RemoveAt(i);
                    continue;
                }

                if (span.IntersectsWith(multiSpan) == false)
                {
                    continue;
                }

                isInsideOfComment = true;
                if (span.Snapshot.Version == comment.Version)
                {
                    var prioSpan = new PrioritiesClassificationSpan();
                    prioSpan.Span     = new ClassificationSpan(multiSpan, m_Type);
                    prioSpan.Priority = 400;
                    classifications.Add(prioSpan);
                }
                else
                {
                    m_MultiLineComments.RemoveAt(i);
                    ClassificationChanged?.Invoke(this, new ClassificationChangedEventArgs(multiSpan));
                    continue;
                }
            }

            if (isInsideOfComment == false)
            {
                classifications.AddRange(ParseMultiLine(span));
            }

            string code    = span.GetText();
            var    matches = m_Regex.Matches(code);

            if (matches.Count == 0)
            {
                return(classifications);
            }

            foreach (Match match in matches)
            {
                if (IsMatchInString(match, span))
                {
                    continue;
                }

                Span spanWord = new Span(span.Start.Position + match.Index,
                                         span.GetText().Length - match.Index);
                SnapshotSpan snapshot = new SnapshotSpan(span.Snapshot, spanWord);

                var prioSpan = new PrioritiesClassificationSpan();
                prioSpan.Span     = new ClassificationSpan(snapshot, m_Type);
                prioSpan.Priority = 400;
                classifications.Add(prioSpan);
            }
            return(classifications);
        }