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 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());
}
internal static bool FindArrayBounds(GapList <AttachedPropertyMetadata> properties, string assemblyName, string namespaceName, string typeName, out int hi, out int lo)
{
return(OrderedListExtensions.GetHiLoBounds((IList <AttachedPropertyMetadata>)properties, new
{
AssemblyName = assemblyName,
NamespaceName = namespaceName,
TypeName = typeName
}, (searchCriteria, property) =>
{
int num = string.CompareOrdinal(searchCriteria.AssemblyName, AttachedPropertiesMetadata.AttachedPropertyMetadataBackgroundWorker.GetAssemblyName(property.OwnerType));
if (num == 0 && searchCriteria.NamespaceName != null)
{
num = string.CompareOrdinal(searchCriteria.NamespaceName, property.OwnerType.Namespace ?? string.Empty);
if (num == 0 && searchCriteria.TypeName != null)
{
num = string.CompareOrdinal(searchCriteria.TypeName, property.OwnerType.Name);
}
}
return num;
}, out hi, out lo));
}
public override CategoryBase FindOrCreateCategory(string categoryName, Type selectedType)
{
CategoryLocalizationHelper.CategoryName canonicalCategoryName = CategoryLocalizationHelper.GetCanonicalCategoryName(categoryName);
if (canonicalCategoryName != CategoryLocalizationHelper.CategoryName.Unknown)
{
categoryName = CategoryLocalizationHelper.GetLocalizedCategoryName(canonicalCategoryName);
}
int index = OrderedListExtensions.GenericBinarySearch <CategoryBase, CategoryLocalizationHelper.CategoryName>(this.Categories, canonicalCategoryName, (Func <CategoryLocalizationHelper.CategoryName, CategoryBase, int>)((canonicalName, category) =>
{
SceneNodeCategory sceneNodeCategory = (SceneNodeCategory)category;
return(canonicalName.CompareTo((object)sceneNodeCategory.CanonicalName));
}));
if (index >= 0)
{
return(this.Categories[index]);
}
CategoryBase category1 = this.CreateCategory(categoryName, selectedType);
this.Categories.Insert(~index, category1);
return(category1);
}
private bool FindSpans(int position, out int previousSpanIndex, out int currentSpanIndex)
{
int num = OrderedListExtensions.GenericBinarySearch <ClassificationSpan, int>(this.cachedClassificationSpans, position, (Func <int, ClassificationSpan, int>)((pos, classSpan) => pos.CompareTo(classSpan.Span.Start)));
if (num < 0)
{
int index = ~num - 1;
if (index == -1)
{
currentSpanIndex = -1;
previousSpanIndex = -1;
}
else if (this.cachedClassificationSpans[index].Span.Contains(position))
{
currentSpanIndex = index;
previousSpanIndex = -1;
}
else
{
if (index == this.cachedClassificationSpans.Count - 1)
{
previousSpanIndex = index;
currentSpanIndex = -1;
return(true);
}
currentSpanIndex = -1;
previousSpanIndex = index;
}
return(false);
}
currentSpanIndex = num;
previousSpanIndex = num > 0 ? num - 1 : -1;
if (previousSpanIndex >= 0 && this.cachedClassificationSpans[previousSpanIndex].Span.End < position)
{
previousSpanIndex = -1;
}
return(true);
}
public XamlNameDecomposition GetNameAtPosition(SnapshotPoint position)
{
IList <ClassificationSpan> classificationSpans = this.statefulClassifier.GetClassificationSpans(position.GetContainingLine().ExtentIncludingLineBreak);
int index = OrderedListExtensions.GenericBinarySearch <ClassificationSpan, int>(classificationSpans, position.Position, (Func <int, ClassificationSpan, int>)((pos, span) => pos - span.Span.Start));
if (index < 0)
{
index = Math.Max(0, ~index - 1);
}
if (this.CursorIsInSpanGap(classificationSpans, index, position.Position))
{
return((XamlNameDecomposition)null);
}
while (index > 0 && (classificationSpans[index].Span.Start == classificationSpans[index - 1].Span.End && XamlAnalyzer.IsPartOfName(classificationSpans[index - 1].ClassificationType)))
{
--index;
}
if (classificationSpans[index].ClassificationType == XamlAnalyzer.ClassTagNameIdentifier || classificationSpans[index].ClassificationType == XamlAnalyzer.ClassAttrNameIdentifier)
{
return(new XamlNameDecomposition(classificationSpans, index));
}
return((XamlNameDecomposition)null);
}
private ClassificationPosition CreateClassificationPosition(SnapshotPoint position)
{
SnapshotSpan spanToTokenize = this.statefulClassifier.GetSpanToTokenize(position);
XamlAnalyzer.LineState state = this.statefulClassifier.GetState(spanToTokenize.Snapshot, spanToTokenize.Start);
IList <ClassificationSpan> list = (IList <ClassificationSpan>) new List <ClassificationSpan>();
IList <XamlAnalyzer.LineState> stateSpans = (IList <XamlAnalyzer.LineState>) new List <XamlAnalyzer.LineState>();
XamlAnalyzer.LineState endState;
this.classificationScanner.GetClassificationSpansWorker(spanToTokenize, list, stateSpans, state, out endState);
int num = OrderedListExtensions.GenericBinarySearch <ClassificationSpan, SnapshotPoint>(list, position, (Func <SnapshotPoint, ClassificationSpan, int>)((pos, span) => pos.Position - span.Span.Start));
if (num < 0)
{
num = ~num - 1;
}
return(new ClassificationPosition()
{
CurrentLine = spanToTokenize,
CurrentSpanList = list,
CurrentSpanIndex = num
});
}
internal XamlNameDecomposition GetPreviousTagName(SnapshotPoint position)
{
SnapshotSpan spanToTokenize = this.statefulClassifier.GetSpanToTokenize(position);
XamlAnalyzer.LineState state1 = this.statefulClassifier.GetState(spanToTokenize.Snapshot, spanToTokenize.Start);
IList <ClassificationSpan> list = (IList <ClassificationSpan>) new List <ClassificationSpan>();
IList <XamlAnalyzer.LineState> stateSpans = (IList <XamlAnalyzer.LineState>) new List <XamlAnalyzer.LineState>();
XamlAnalyzer.LineState endState;
this.classificationScanner.GetClassificationSpansWorker(spanToTokenize, list, stateSpans, state1, out endState);
int num1 = OrderedListExtensions.GenericBinarySearch <ClassificationSpan, SnapshotPoint>(list, position, (Func <SnapshotPoint, ClassificationSpan, int>)((pos, span) => pos.Position - span.Span.Start));
if (num1 < 0)
{
num1 = ~num1;
}
int index = num1 - 1;
XamlAnalyzer.ParseState state2;
if (index < 0)
{
state2 = state1.ParseState;
}
else
{
state2 = stateSpans[index].ParseState;
switch (state2)
{
case XamlAnalyzer.ParseState.EmptyTagEnd:
case XamlAnalyzer.ParseState.TagEnd:
if (list[index].Span.IntersectsWith(new Span(position.Position, 0)))
{
state2 = index != 0 ? stateSpans[index - 1].ParseState : stateSpans[index].ParseState;
break;
}
break;
}
}
int num2 = -1;
if (XamlAnalyzer.IsInsideTag(state2))
{
foreach (ClassificationPosition classificationPosition in this.statefulClassifier.ScanBackward(new ClassificationPosition()
{
CurrentLine = spanToTokenize,
CurrentSpanList = list,
CurrentSpanIndex = index
}))
{
if (classificationPosition.CurrentSpan.ClassificationType == XamlAnalyzer.ClassStartTag)
{
num2 = classificationPosition.CurrentSpan.Span.Start;
break;
}
if (classificationPosition.CurrentSpan.ClassificationType != XamlAnalyzer.ClassStartClosingTag)
{
if (classificationPosition.CurrentSpan.ClassificationType != XamlAnalyzer.ClassEndEmptyTag)
{
if (classificationPosition.CurrentSpan.ClassificationType == XamlAnalyzer.ClassEndTag)
{
break;
}
}
else
{
break;
}
}
else
{
break;
}
}
}
if (num2 == -1)
{
return((XamlNameDecomposition)null);
}
return(this.GetNameAtPosition(new SnapshotPoint(position.Snapshot, num2 + 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());
}
internal int FindCategoryForName(string categoryName)
{
return(OrderedListExtensions.GenericBinarySearch <SceneNodeCategory, string>(this.Items, categoryName, (Func <string, SceneNodeCategory, int>)((name, category) => name.CompareTo(category.CategoryName))));
}
private IEnumerable <IType> AllXamlRelevantTypesInAssembly(IAssembly assembly)
{
IProjectContext project = this.ProjectContext;
bool supportInternal = assembly.Equals((object)project.ProjectAssembly);
Type[] assemblyTypes = Type.EmptyTypes;
try
{
assemblyTypes = AssemblyHelper.GetTypes(assembly);
}
catch (ReflectionTypeLoadException ex)
{
assemblyTypes = Type.EmptyTypes;
}
IAttachedPropertiesProvider attachedPropertiesProvider = this.AttachedPropertiesProvider;
if (attachedPropertiesProvider == null)
{
throw new NotSupportedException();
}
Type[] allTypesWithAttachedProperties = (Type[])null;
using (IAttachedPropertiesAccessToken token = attachedPropertiesProvider.AttachedProperties.Access())
{
CodeAidProvider.EnsurePreloadKnownAttachedProperties(token, project);
allTypesWithAttachedProperties = Enumerable.ToArray <Type>(Enumerable.Select <IGrouping <Type, IAttachedPropertyMetadata>, Type>(Enumerable.GroupBy <IAttachedPropertyMetadata, Type>((IEnumerable <IAttachedPropertyMetadata>)token.AttachedPropertiesForAssembly(assembly.Name), (Func <IAttachedPropertyMetadata, Type>)(property => property.OwnerType)), (Func <IGrouping <Type, IAttachedPropertyMetadata>, Type>)(type => type.Key)));
}
foreach (Type type3 in assemblyTypes)
{
IType yieldedTypeId = (IType)null;
try
{
if (!type3.IsGenericType)
{
if (type3.IsVisible)
{
if (!type3.IsNested)
{
if (!typeof(Attribute).IsAssignableFrom(type3))
{
if (!typeof(Exception).IsAssignableFrom(type3))
{
if (type3.IsPublic)
{
if (TypeUtilities.HasDefaultConstructor(type3, supportInternal) && TypeUtilities.CanCreateTypeInXaml((ITypeResolver)project, type3))
{
IType type1 = project.GetType(type3);
if (JoltHelper.TypeSupported((ITypeResolver)project, (ITypeId)type1))
{
yieldedTypeId = type1;
}
}
else if (allTypesWithAttachedProperties != null)
{
if (OrderedListExtensions.GenericBinarySearch <Type, Type>(allTypesWithAttachedProperties, type3, (Func <Type, Type, int>)((type1, type2) => type1.Name.CompareTo(type2.Name))) >= 0)
{
yieldedTypeId = project.GetType(type3);
}
}
}
}
}
}
}
}
}
catch (FileNotFoundException ex)
{
}
if (yieldedTypeId != null)
{
yield return(yieldedTypeId);
}
}
}
