private static string GetRequiredMarkupExtensionArgument(XamlParserContext parserContext, ITextLocation lineInformation, MarkupExtensionDescription description, string propertyName)
{
if (description.PositionalArguments.Count == 1 && description.NamedArguments.Count == 0)
{
return(description.PositionalArguments[0]);
}
if (description.PositionalArguments.Count == 0 && description.NamedArguments.Count == 1 && description.NamedArguments[0].Key == propertyName)
{
return(description.NamedArguments[0].Value);
}
parserContext.ReportError(XamlParseErrors.InvalidMarkupExtensionArguments(lineInformation, description.Name));
return((string)null);
}
public static DocumentNode ParseMarkupExtension(XamlParserContext parserContext, ITextLocation lineInformation, IDocumentNodeReference nodeReference, IXmlNamespaceResolver xmlNamespaceResolver, IType valueType, string text)
{
MarkupExtensionDescription description = MarkupExtensionParser.Tokenize(parserContext, lineInformation, text);
if (description != null)
{
IType typeId1 = XamlTypeHelper.GetTypeId(parserContext, lineInformation, xmlNamespaceResolver, description.Name, true);
if (typeId1 != null)
{
if (parserContext.PlatformMetadata.KnownTypes.NullExtension.Equals((object)typeId1))
{
if (description.PositionalArguments.Count > 0 || description.NamedArguments.Count > 0)
{
parserContext.ReportError(XamlParseErrors.InvalidMarkupExtensionArguments(lineInformation, description.Name));
}
if (valueType.SupportsNullValues)
{
return((DocumentNode)parserContext.DocumentContext.CreateNode((ITypeId)valueType, (IDocumentNodeValue)null));
}
parserContext.ReportError(XamlParseErrors.TypeIsNotNullable(lineInformation, (ITypeId)valueType));
return((DocumentNode)null);
}
if (parserContext.PlatformMetadata.KnownTypes.TypeExtension.IsAssignableFrom((ITypeId)typeId1))
{
string extensionArgument = MarkupExtensionParser.GetRequiredMarkupExtensionArgument(parserContext, lineInformation, description, parserContext.PlatformMetadata.KnownProperties.TypeExtensionTypeName.Name);
if (extensionArgument != null)
{
IType typeId2 = XamlTypeHelper.GetTypeId(parserContext, lineInformation, xmlNamespaceResolver, extensionArgument, true);
if (typeId2 != null)
{
return((DocumentNode)parserContext.DocumentContext.CreateNode(parserContext.PlatformMetadata.KnownTypes.Type, (IDocumentNodeValue) new DocumentNodeMemberValue((IMember)typeId2)));
}
}
}
else if (parserContext.PlatformMetadata.KnownTypes.StaticExtension.IsAssignableFrom((ITypeId)typeId1))
{
string extensionArgument = MarkupExtensionParser.GetRequiredMarkupExtensionArgument(parserContext, lineInformation, description, parserContext.PlatformMetadata.KnownProperties.StaticExtensionMember.Name);
if (extensionArgument != null)
{
IType typeId2;
string memberName;
if (MarkupExtensionParser.GetTypeAndMemberName(parserContext, lineInformation, xmlNamespaceResolver, extensionArgument, (IType)null, out typeId2, out memberName))
{
MemberAccessTypes allowableMemberAccess = TypeHelper.GetAllowableMemberAccess(parserContext.TypeResolver, typeId2);
MemberType memberTypes = MemberType.LocalProperty | MemberType.Field;
if (parserContext.TypeResolver.IsCapabilitySet(PlatformCapability.IncompleteAttachedPropertiesInMarkupExtensions))
{
memberTypes |= MemberType.IncompleteAttachedProperty;
}
IMember memberId = (IMember)typeId2.GetMember(memberTypes, memberName, allowableMemberAccess) ?? XamlTypeHelper.AddMemberIfPossible(parserContext.PlatformMetadata, typeId2, MemberType.LocalProperty, memberName);
if (memberId != null)
{
return((DocumentNode)DocumentNodeHelper.NewStaticNode(parserContext.DocumentContext, memberId));
}
parserContext.ReportError(XamlParseErrors.UnrecognizedOrInaccessibleMember(lineInformation, memberName));
}
return((DocumentNode)null);
}
}
else
{
if (!parserContext.TypeResolver.PlatformMetadata.KnownTypes.Binding.Equals((object)typeId1) || description.PositionalArguments.Count != 1)
{
return(MarkupExtensionParser.ParseMarkupExtension(parserContext, lineInformation, nodeReference, xmlNamespaceResolver, typeId1, description));
}
description.NamedArguments.Insert(0, new KeyValuePair <string, string>(parserContext.TypeResolver.PlatformMetadata.KnownProperties.BindingPath.Name, description.PositionalArguments[0]));
description.PositionalArguments.Clear();
return(MarkupExtensionParser.ParseMarkupExtension(parserContext, lineInformation, nodeReference, xmlNamespaceResolver, typeId1, description));
}
}
}
return((DocumentNode)null);
}
private static DocumentNode ParseMarkupExtension(XamlParserContext parserContext, ITextLocation lineInformation, IDocumentNodeReference nodeReference, IXmlNamespaceResolver xmlNamespaceResolver, IType typeId, MarkupExtensionDescription description)
{
int count = description.PositionalArguments.Count;
DocumentCompositeNode node = parserContext.DocumentContext.CreateNode((ITypeId)typeId);
IDocumentNodeReference documentNodeReference = (IDocumentNodeReference) new DocumentCompositeNodeReference(nodeReference, node);
IConstructor constructor1 = (IConstructor)null;
if (typeId.IsResolvable)
{
IList <IConstructor> constructors = typeId.GetConstructors();
if (constructors.Count > 0)
{
int num = 0;
foreach (IConstructor constructor2 in (IEnumerable <IConstructor>)constructors)
{
if (constructor2.Parameters.Count == count)
{
if (num == 0)
{
constructor1 = constructor2;
}
++num;
}
}
if (num == 0)
{
parserContext.ReportError(XamlParseErrors.IncorrectNumberOfConstructorArguments(lineInformation, (ITypeId)typeId));
}
else if (num <= 1)
{
;
}
}
else
{
parserContext.ReportError(XamlParseErrors.NoAccessibleConstructor(lineInformation, (ITypeId)typeId));
}
}
DocumentNode[] documentNodeArray = constructor1 != null ? new DocumentNode[constructor1.Parameters.Count] : (DocumentNode[])null;
IConstructorArgumentProperties argumentProperties = typeId.GetConstructorArgumentProperties();
if (count > 0)
{
for (int index = 0; index < count; ++index)
{
string str = description.PositionalArguments[index];
bool flag = constructor1 != null && index < constructor1.Parameters.Count;
IType type = parserContext.TypeResolver.ResolveType(parserContext.TypeResolver.PlatformMetadata.KnownTypes.Object);
if (flag)
{
IParameter parameter = constructor1.Parameters[index];
type = parserContext.TypeResolver.ResolveType((ITypeId)parameter.ParameterType);
IProperty property = argumentProperties[parameter.Name];
if (property != null && !property.PropertyType.IsAssignableFrom((ITypeId)type))
{
flag = false;
parserContext.ReportError(XamlParseErrors.ConstructorArgumentDeclaredTypeDoesNotMatchProperty(lineInformation, (IPropertyId)property));
}
}
TypeConverter typeConverter = type.TypeConverter;
DocumentNode propertyValue = MarkupExtensionParser.GetPropertyValue(parserContext, lineInformation, documentNodeReference, xmlNamespaceResolver, typeConverter, type, str, true);
if (flag && propertyValue != null)
{
documentNodeArray[index] = XamlParser.CanAssignTo(parserContext, lineInformation, type, propertyValue) ? propertyValue : (DocumentNode)null;
}
}
}
node.SetConstructor(constructor1, (IList <DocumentNode>)documentNodeArray);
int num1 = 0;
foreach (KeyValuePair <string, string> keyValuePair in (IEnumerable <KeyValuePair <string, string> >)description.NamedArguments)
{
string key = keyValuePair.Key;
MemberType memberTypes = MemberType.LocalProperty | MemberType.AttachedProperty | MemberType.Field;
if (parserContext.TypeResolver.IsCapabilitySet(PlatformCapability.IncompleteAttachedPropertiesInMarkupExtensions))
{
memberTypes |= MemberType.IncompleteAttachedProperty;
}
IProperty propertyKey = XamlTypeHelper.GetPropertyKey(parserContext, lineInformation, xmlNamespaceResolver, key, (XmlNamespace)null, typeId, memberTypes, MemberType.LocalProperty, false);
if (propertyKey != null)
{
DocumentNode propertyValue = MarkupExtensionParser.GetPropertyValue(parserContext, lineInformation, documentNodeReference, xmlNamespaceResolver, propertyKey, keyValuePair.Value, true);
if (propertyValue != null && XamlParser.SetProperty(parserContext, lineInformation, new DocumentCompositeNodeReference(documentNodeReference, node), (XamlSourceContext)null, (IPropertyId)propertyKey, propertyValue))
{
propertyValue.ContainerSourceContext = (INodeSourceContext) new MarkupExtensionParser.MinimalSourceContext(num1++);
}
}
}
return((DocumentNode)node);
}
public static MarkupExtensionDescription Tokenize(XamlParserContext parserContext, ITextLocation lineInformation, string text)
{
MarkupExtensionDescription extensionDescription = new MarkupExtensionDescription();
MarkupExtensionParser.ScannerState scannerState = MarkupExtensionParser.ScannerState.Begin;
int startIndex = 0;
int index = 0;
string key = (string)null;
while (index < text.Length)
{
char c = text[index];
++index;
switch (scannerState)
{
case MarkupExtensionParser.ScannerState.Begin:
if ((int)c == 123)
{
scannerState = MarkupExtensionParser.ScannerState.ScanningMarkupExtensionName;
while (index < text.Length && Scanner.IsXmlWhitespace(text[index]))
{
++index;
}
startIndex = index;
continue;
}
if (!Scanner.IsXmlWhitespace(c))
{
parserContext.ReportError(XamlParseErrors.UnexpectedCharacter(lineInformation, c));
return((MarkupExtensionDescription)null);
}
continue;
case MarkupExtensionParser.ScannerState.ScanningMarkupExtensionName:
if ((int)c == 125 || Scanner.IsXmlWhitespace(c))
{
int length = index - startIndex - 1;
string str = MarkupExtensionParser.ReplaceEscapedCharacters(MarkupExtensionParser.TrimOffWhitespace(text.Substring(startIndex, length)));
if (str.Length > 0)
{
extensionDescription.Name = str;
scannerState = (int)c == 125 ? MarkupExtensionParser.ScannerState.End : MarkupExtensionParser.ScannerState.ScanningNameOrValue;
startIndex = index;
continue;
}
parserContext.ReportError(XamlParseErrors.MissingMarkupExtensionName(lineInformation));
return((MarkupExtensionDescription)null);
}
if ((int)c == 123 || (int)c == 44 || (int)c == 61)
{
parserContext.ReportError(XamlParseErrors.UnexpectedCharacter(lineInformation, c));
return((MarkupExtensionDescription)null);
}
continue;
case MarkupExtensionParser.ScannerState.ScanningNameOrValue:
case MarkupExtensionParser.ScannerState.ScanningValue:
switch (c)
{
case '=':
int length1 = index - startIndex - 1;
key = MarkupExtensionParser.ReplaceEscapedCharacters(MarkupExtensionParser.TrimOffQuotes(MarkupExtensionParser.TrimOffWhitespace(text.Substring(startIndex, length1))));
startIndex = index;
if (key.Length > 0)
{
scannerState = MarkupExtensionParser.ScannerState.ScanningValue;
continue;
}
parserContext.ReportError(XamlParseErrors.MissingArgumentName(lineInformation));
return((MarkupExtensionDescription)null);
case '\\':
if (index < text.Length)
{
++index;
continue;
}
continue;
case '{':
int num = 1;
while (index < text.Length)
{
char ch = text[index];
++index;
switch (ch)
{
case '\\':
if (index < text.Length)
{
++index;
break;
}
break;
case '{':
++num;
break;
case '}':
--num;
break;
}
if (num == 0)
{
break;
}
}
if (num != 0)
{
parserContext.ReportError(XamlParseErrors.UnexpectedEnd(lineInformation));
return((MarkupExtensionDescription)null);
}
continue;
case '}':
case ',':
int length2 = index - startIndex - 1;
string argumentName = MarkupExtensionParser.TrimOffQuotes(MarkupExtensionParser.TrimOffWhitespace(text.Substring(startIndex, length2)));
startIndex = index;
if (scannerState == MarkupExtensionParser.ScannerState.ScanningNameOrValue)
{
if (extensionDescription.NamedArguments.Count > 0)
{
parserContext.ReportError(XamlParseErrors.UnexpectedPositionalArgument(lineInformation, argumentName));
return((MarkupExtensionDescription)null);
}
extensionDescription.PositionalArguments.Add(argumentName);
}
else
{
if (string.IsNullOrEmpty(key))
{
parserContext.ReportError(XamlParseErrors.UnexpectedPositionalArgument(lineInformation, argumentName));
return((MarkupExtensionDescription)null);
}
extensionDescription.NamedArguments.Add(new KeyValuePair <string, string>(key, argumentName));
}
scannerState = (int)c != 125 ? MarkupExtensionParser.ScannerState.ScanningNameOrValue : MarkupExtensionParser.ScannerState.End;
continue;
case '"':
case '\'':
char ch1 = c;
while (index < text.Length)
{
char ch2 = text[index];
++index;
if ((int)ch1 == (int)ch2)
{
break;
}
}
continue;
default:
continue;
}
default:
if (!Scanner.IsXmlWhitespace(c))
{
parserContext.ReportError(XamlParseErrors.UnexpectedCharacter(lineInformation, c));
return((MarkupExtensionDescription)null);
}
continue;
}
}
if (scannerState == MarkupExtensionParser.ScannerState.End)
{
return(extensionDescription);
}
parserContext.ReportError(XamlParseErrors.UnexpectedEnd(lineInformation));
return((MarkupExtensionDescription)null);
}