public IEnumerable <ClassificationPosition> Tokens(SnapshotSpan spanToTokenize)
{
if (!spanToTokenize.IsEmpty)
{
SnapshotSpan startTagLine = this.statefulClassifier.GetSpanToTokenize(spanToTokenize);
IList <ClassificationSpan> spans = this.statefulClassifier.GetClassificationSpans(startTagLine);
int startTagStartSpanIndex = OrderedListExtensions.GenericBinarySearch <ClassificationSpan, int>(spans, spanToTokenize.Start, (Func <int, ClassificationSpan, int>)((pos, span) => pos - span.Span.Start));
if (startTagStartSpanIndex >= 0 && spans[startTagStartSpanIndex].ClassificationType == XamlAnalyzer.ClassStartTag)
{
int startTagEndSpanIndex = OrderedListExtensions.GenericBinarySearch <ClassificationSpan, int>(spans, spanToTokenize.End, (Func <int, ClassificationSpan, int>)((pos, span) => pos - span.Span.Start));
if (startTagEndSpanIndex < 0)
{
startTagEndSpanIndex = ~startTagEndSpanIndex;
}
ClassificationPosition interestingPosition = new ClassificationPosition()
{
CurrentLine = startTagLine,
CurrentSpanList = spans,
CurrentSpanIndex = startTagStartSpanIndex
};
foreach (ClassificationPosition classificationPosition in this.statefulClassifier.ScanForward(interestingPosition))
{
if (classificationPosition.CurrentSpan.Span.Start >= spanToTokenize.Span.End)
{
break;
}
yield return(classificationPosition);
}
}
}
}
public IEnumerable <ClassificationPosition> BackwardClassificationPositions(SnapshotPoint position, bool includeStartPosition)
{
ClassificationPosition startPosition = this.CreateClassificationPosition(position);
if (includeStartPosition)
{
yield return(startPosition);
}
foreach (ClassificationPosition classificationPosition in this.statefulClassifier.ScanBackward(startPosition))
{
yield return(classificationPosition);
}
}
public SnapshotSpan GetMatchingEndTag(SnapshotSpan startTagSpan)
{
SnapshotSpan spanToTokenize = this.statefulClassifier.GetSpanToTokenize(startTagSpan);
IList <ClassificationSpan> classificationSpans = this.statefulClassifier.GetClassificationSpans(spanToTokenize);
int index = OrderedListExtensions.GenericBinarySearch <ClassificationSpan, int>(classificationSpans, startTagSpan.Start, (Func <int, ClassificationSpan, int>)((pos, span) => pos - span.Span.Start));
if (index < 0 || classificationSpans[index].ClassificationType != XamlAnalyzer.ClassStartTag)
{
return(new SnapshotSpan());
}
int num1 = OrderedListExtensions.GenericBinarySearch <ClassificationSpan, int>(classificationSpans, startTagSpan.End, (Func <int, ClassificationSpan, int>)((pos, span) => pos - span.Span.Start));
if (num1 < 0)
{
num1 = ~num1;
}
ClassificationPosition startPosition = new ClassificationPosition()
{
CurrentLine = spanToTokenize,
CurrentSpanList = classificationSpans,
CurrentSpanIndex = num1
};
int num2 = 1;
int start = -1;
foreach (ClassificationPosition classificationPosition in this.statefulClassifier.ScanForward(startPosition))
{
num2 += XamlAnalyzer.TagDepthDelta(true, classificationPosition.CurrentSpan.ClassificationType);
if (num2 == 0)
{
start = classificationPosition.CurrentSpan.Span.Start;
startPosition = classificationPosition;
break;
}
}
if (start >= 0)
{
foreach (ClassificationPosition classificationPosition in this.statefulClassifier.ScanForward(startPosition))
{
if (classificationPosition.CurrentSpan.ClassificationType == XamlAnalyzer.ClassEndTag)
{
return(new SnapshotSpan(classificationPosition.Snapshot, new Span(start, classificationPosition.CurrentSpan.Span.End - start)));
}
}
}
return(new SnapshotSpan());
}
public IEnumerable <ClassificationPosition> ScanForward(ClassificationPosition startPosition)
{
ClassificationPosition currentPosition = startPosition;
while (!currentPosition.CurrentLine.IsEmpty)
{
for (; currentPosition.CurrentSpanIndex < currentPosition.CurrentSpanList.Count; ++currentPosition.CurrentSpanIndex)
{
yield return(currentPosition);
}
currentPosition.CurrentLine = this.GetNextSpanToTokenize(currentPosition.Snapshot, currentPosition.CurrentLine.End);
if (!currentPosition.CurrentLine.IsEmpty)
{
currentPosition.CurrentSpanList = this.GetClassificationSpans(currentPosition.CurrentLine);
currentPosition.CurrentSpanIndex = 0;
}
}
}
public IEnumerable <ClassificationPosition> ScanBackward(ClassificationPosition startPosition)
{
ClassificationPosition currentPosition = startPosition;
--currentPosition.CurrentSpanIndex;
while (!currentPosition.CurrentLine.IsEmpty)
{
for (; currentPosition.CurrentSpanIndex >= 0; --currentPosition.CurrentSpanIndex)
{
yield return(currentPosition);
}
currentPosition.CurrentLine = this.GetPreviousSpanToTokenize(currentPosition.Snapshot, currentPosition.CurrentLine.Start);
if (!currentPosition.CurrentLine.IsEmpty)
{
currentPosition.CurrentSpanList = this.GetClassificationSpans(currentPosition.CurrentLine);
currentPosition.CurrentSpanIndex = currentPosition.CurrentSpanList.Count - 1;
}
}
}
private SnapshotSpan GetContainingTag(SnapshotPoint position, bool shouldReturnCloseTagSpan, out bool isInCloseTag, bool returnEmptySpanOnContent)
{
isInCloseTag = false;
SnapshotSpan spanToTokenize = this.statefulClassifier.GetSpanToTokenize(position);
XamlAnalyzer.LineState state1 = this.statefulClassifier.GetState(spanToTokenize.Snapshot, spanToTokenize.Start);
IList <ClassificationSpan> list1 = (IList <ClassificationSpan>) new List <ClassificationSpan>();
IList <XamlAnalyzer.LineState> list2 = (IList <XamlAnalyzer.LineState>) new List <XamlAnalyzer.LineState>();
XamlAnalyzer.LineState endState;
this.classificationScanner.GetClassificationSpansWorker(spanToTokenize, list1, list2, state1, out endState);
int num1 = OrderedListExtensions.GenericBinarySearch <ClassificationSpan, SnapshotPoint>(list1, position, (Func <SnapshotPoint, ClassificationSpan, int>)((pos, span) => pos.Position - span.Span.Start));
if (num1 < 0)
{
num1 = ~num1;
}
int startSpanIndex = num1 - 1;
XamlAnalyzer.ParseState state2 = startSpanIndex >= 0 ? list2[startSpanIndex].ParseState : state1.ParseState;
if (XamlAnalyzer.IsInsideClosingTag(list2, startSpanIndex))
{
isInCloseTag = true;
ClassificationPosition startPosition = new ClassificationPosition()
{
CurrentLine = spanToTokenize,
CurrentSpanList = list1,
CurrentSpanIndex = startSpanIndex
};
int currentSpanIndex = startPosition.CurrentSpanIndex;
if (startSpanIndex >= 0 && startPosition.CurrentSpan.ClassificationType != XamlAnalyzer.ClassStartClosingTag)
{
foreach (ClassificationPosition classificationPosition in this.statefulClassifier.ScanBackward(startPosition))
{
if (classificationPosition.CurrentSpan.ClassificationType == XamlAnalyzer.ClassStartClosingTag)
{
startPosition = classificationPosition;
currentSpanIndex = classificationPosition.CurrentSpanIndex;
break;
}
}
}
if (shouldReturnCloseTagSpan)
{
int start = startPosition.CurrentSpanList[Math.Max(0, currentSpanIndex)].Span.Start;
int end = startPosition.CurrentSpanList[Math.Max(0, currentSpanIndex)].Span.End;
for (int index = currentSpanIndex + 1; index < startPosition.CurrentSpanList.Count && XamlAnalyzer.IsTokenValidInCloseTag(startPosition.CurrentSpanList[index].ClassificationType); ++index)
{
end = startPosition.CurrentSpanList[index].Span.End;
}
return(new SnapshotSpan(startPosition.Snapshot, start, end - start));
}
int num2 = 1;
foreach (ClassificationPosition classificationPosition in this.statefulClassifier.ScanBackward(startPosition))
{
num2 += XamlAnalyzer.TagDepthDelta(false, classificationPosition.CurrentSpan.ClassificationType);
if (num2 == 0)
{
startPosition = classificationPosition;
break;
}
}
if (num2 != 0)
{
return(new SnapshotSpan());
}
int start1 = startPosition.CurrentSpan.Span.Start;
foreach (ClassificationPosition classificationPosition in this.statefulClassifier.ScanForward(startPosition))
{
if (classificationPosition.CurrentSpan.ClassificationType == XamlAnalyzer.ClassEndTag || classificationPosition.CurrentSpan.ClassificationType == XamlAnalyzer.ClassEndEmptyTag)
{
return(new SnapshotSpan(classificationPosition.Snapshot, new Span(start1, classificationPosition.CurrentSpan.Span.End - start1)));
}
if (classificationPosition.CurrentSpan.Span != startPosition.CurrentSpan.Span && (classificationPosition.CurrentSpan.ClassificationType == XamlAnalyzer.ClassStartTag || classificationPosition.CurrentSpan.ClassificationType == XamlAnalyzer.ClassStartClosingTag))
{
return(new SnapshotSpan(classificationPosition.Snapshot, new Span(start1, classificationPosition.CurrentSpan.Span.Start - start1)));
}
}
}
else if (XamlAnalyzer.IsInsideTag(state2))
{
ClassificationPosition startPosition = new ClassificationPosition()
{
CurrentLine = spanToTokenize,
CurrentSpanList = list1,
CurrentSpanIndex = startSpanIndex
};
int start = -1;
if (startPosition.CurrentSpan.ClassificationType == XamlAnalyzer.ClassStartTag)
{
start = startPosition.CurrentSpan.Span.Start;
}
else
{
foreach (ClassificationPosition classificationPosition in this.statefulClassifier.ScanBackward(startPosition))
{
if (classificationPosition.CurrentSpan.ClassificationType == XamlAnalyzer.ClassStartTag)
{
start = classificationPosition.CurrentSpan.Span.Start;
break;
}
}
}
int num2 = startPosition.Snapshot.Length;
foreach (ClassificationPosition classificationPosition in this.statefulClassifier.ScanForward(startPosition))
{
if (classificationPosition.CurrentSpan.ClassificationType == XamlAnalyzer.ClassEndEmptyTag || classificationPosition.CurrentSpan.ClassificationType == XamlAnalyzer.ClassEndTag)
{
num2 = classificationPosition.CurrentSpan.Span.End;
break;
}
if (classificationPosition.CurrentSpan.Span != startPosition.CurrentSpan.Span && (classificationPosition.CurrentSpan.ClassificationType == XamlAnalyzer.ClassStartTag || classificationPosition.CurrentSpan.ClassificationType == XamlAnalyzer.ClassStartClosingTag))
{
num2 = classificationPosition.CurrentSpan.Span.Start;
break;
}
}
if (start >= 0 && num2 > start)
{
return(new SnapshotSpan(startPosition.Snapshot, new Span(start, num2 - start)));
}
}
else
{
if (returnEmptySpanOnContent)
{
return(new SnapshotSpan());
}
int num2 = state2 == XamlAnalyzer.ParseState.EmptyTagEnd ? 2 : 1;
ClassificationPosition startPosition = new ClassificationPosition()
{
CurrentLine = spanToTokenize,
CurrentSpanList = list1,
CurrentSpanIndex = startSpanIndex
};
foreach (ClassificationPosition classificationPosition in this.statefulClassifier.ScanBackward(startPosition))
{
num2 += XamlAnalyzer.TagDepthDelta(false, classificationPosition.CurrentSpan.ClassificationType);
if (num2 == 0)
{
startPosition = classificationPosition;
break;
}
}
if (num2 != 0)
{
return(new SnapshotSpan());
}
int start = startPosition.CurrentSpan.Span.Start;
foreach (ClassificationPosition classificationPosition in this.statefulClassifier.ScanForward(startPosition))
{
if (classificationPosition.CurrentSpan.ClassificationType == XamlAnalyzer.ClassEndTag)
{
return(new SnapshotSpan(classificationPosition.Snapshot, new Span(start, classificationPosition.CurrentSpan.Span.End - start)));
}
}
}
return(new SnapshotSpan());
}
