internal static bool IsInsideTag(XamlAnalyzer.ParseState state)
{
if (state != XamlAnalyzer.ParseState.Content && state != XamlAnalyzer.ParseState.Error && state != XamlAnalyzer.ParseState.TagEnd)
{
return(state != XamlAnalyzer.ParseState.EmptyTagEnd);
}
return(false);
}
internal static bool IsAfterTagName(XamlAnalyzer.ParseState state)
{
if (state != XamlAnalyzer.ParseState.AfterTagName && state != XamlAnalyzer.ParseState.AttrEquals && state != XamlAnalyzer.ParseState.AttrNamePart)
{
return(state == XamlAnalyzer.ParseState.AttrPrefixColon);
}
return(true);
}
private static bool IsInsideClosingTag(IList <XamlAnalyzer.LineState> spans, int startSpanIndex)
{
for (int index = startSpanIndex; index >= 0; --index)
{
XamlAnalyzer.ParseState parseState1 = spans[index].ParseState;
XamlAnalyzer.ParseState parseState2 = spans[Math.Max(0, index - 1)].ParseState;
if (parseState1 == XamlAnalyzer.ParseState.ClosingTagStart)
{
return(true);
}
if (parseState1 == XamlAnalyzer.ParseState.TagEnd || parseState1 == XamlAnalyzer.ParseState.EmptyTagEnd || parseState1 == XamlAnalyzer.ParseState.TagStart)
{
return(false);
}
if (parseState2 == XamlAnalyzer.ParseState.ClosingTagStart && parseState1 == XamlAnalyzer.ParseState.ClosingTagNamePart)
{
return(true);
}
}
return(false);
}
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());
}
internal static bool IsStartTag(XamlAnalyzer.ParseState state)
{
return((state & XamlAnalyzer.ParseState.IsClosingTag) != XamlAnalyzer.ParseState.IsClosingTag);
}
internal static bool Transition(Token token, bool wasWhitespaceSkipped, XamlAnalyzer.ParseState currentState, out XamlAnalyzer.ParseState newState, out IClassificationType classType)
{
if (wasWhitespaceSkipped && (currentState == XamlAnalyzer.ParseState.TagNamePart || currentState == XamlAnalyzer.ParseState.TagPrefixColon))
{
currentState = XamlAnalyzer.ParseState.AfterTagName;
}
switch (token)
{
case Token.Assign:
newState = XamlAnalyzer.ParseState.AttrEquals;
classType = XamlAnalyzer.ClassAttrEquals;
return(true);
case Token.Colon:
newState = currentState != XamlAnalyzer.ParseState.TagNamePart ? (currentState != XamlAnalyzer.ParseState.ClosingTagNamePart ? XamlAnalyzer.ParseState.AttrPrefixColon : XamlAnalyzer.ParseState.ClosingTagPrefixColon) : XamlAnalyzer.ParseState.TagPrefixColon;
classType = XamlAnalyzer.ClassNameColon;
return(true);
case Token.Comment:
newState = currentState;
classType = XamlAnalyzer.ClassComment;
return(true);
case Token.EndOfLine:
newState = currentState == XamlAnalyzer.ParseState.TagNamePart || currentState == XamlAnalyzer.ParseState.TagPrefixColon ? XamlAnalyzer.ParseState.AfterTagName : currentState;
classType = XamlAnalyzer.ClassUnknown;
return(false);
case Token.EndOfTag:
newState = XamlAnalyzer.ParseState.TagEnd;
classType = XamlAnalyzer.ClassEndTag;
return(true);
case Token.EndOfSimpleTag:
newState = XamlAnalyzer.ParseState.EmptyTagEnd;
classType = XamlAnalyzer.ClassEndEmptyTag;
return(true);
case Token.Identifier:
if (XamlAnalyzer.IsAfterTagName(currentState) || currentState == XamlAnalyzer.ParseState.TagNamePart)
{
newState = XamlAnalyzer.ParseState.AttrNamePart;
classType = XamlAnalyzer.ClassAttrNameIdentifier;
}
else if (XamlAnalyzer.IsInsideTag(currentState))
{
bool flag = false;
if ((currentState & XamlAnalyzer.ParseState.IsClosingTag) == XamlAnalyzer.ParseState.IsClosingTag)
{
flag = true;
}
newState = flag ? XamlAnalyzer.ParseState.ClosingTagNamePart : XamlAnalyzer.ParseState.TagNamePart;
classType = XamlAnalyzer.ClassTagNameIdentifier;
}
else
{
newState = currentState;
classType = XamlAnalyzer.ClassUnknown;
}
return(true);
case Token.LiteralContentString:
newState = XamlAnalyzer.ParseState.Content;
classType = XamlAnalyzer.ClassNonTagContent;
return(true);
case Token.StartOfClosingTag:
newState = XamlAnalyzer.ParseState.ClosingTagStart;
classType = XamlAnalyzer.ClassStartClosingTag;
return(true);
case Token.StartOfTag:
newState = XamlAnalyzer.ParseState.TagStart;
classType = XamlAnalyzer.ClassStartTag;
return(true);
case Token.StringLiteral:
newState = XamlAnalyzer.ParseState.AfterTagName;
classType = XamlAnalyzer.ClassAttrValue;
return(true);
default:
newState = currentState;
classType = XamlAnalyzer.ClassUnknown;
return(false);
}
}
