internal static IType GetTypeId(XamlParserContext parserContext, ITextLocation lineInformation, XmlNamespace xmlNamespace, string typeName, bool inMarkupExtension) { if (string.IsNullOrEmpty(typeName)) { parserContext.ReportError(XamlParseErrors.MissingTypeName(lineInformation)); return((IType)null); } if (typeName.IndexOf('.') >= 0) { parserContext.ReportError(XamlParseErrors.InnerTypesNotSupported(lineInformation, typeName)); return((IType)null); } IType typeId = XamlTypeHelper.GetTypeId(parserContext.TypeResolver, parserContext.DocumentNamespaces, xmlNamespace, typeName, true, inMarkupExtension); if (typeId != null && typeId.IsResolvable) { if (!parserContext.TypeResolver.InTargetAssembly(typeId) && !TypeHelper.IsSet(MemberAccessTypes.Public, typeId.Access)) { parserContext.ReportError(XamlParseErrors.InaccessibleType(lineInformation, typeName)); return((IType)null); } } else if (xmlNamespace == XmlNamespace.AvalonXmlNamespace || xmlNamespace == XmlNamespace.XamlXmlNamespace) { parserContext.ReportError(XamlParseErrors.UnrecognizedPlatformTypeName(lineInformation, !parserContext.TypeResolver.IsCapabilitySet(PlatformCapability.IsWpf), typeName)); } else { parserContext.ReportError(XamlParseErrors.UnrecognizedTypeName(lineInformation, xmlNamespace, typeName)); } return(typeId); }
public static XamlParseError MismatchedVersionSDKType(ITextLocation lineInformation, IType childType, FrameworkName frameworkName) { string str = (string)(frameworkName.Identifier == "Silverlight" ? (object)frameworkName.Identifier : (object)"Windows Presentation Framework") + (object)" " + (string)(object)frameworkName.Version.Major; string messageFormat = string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.MismatchedVersionSDKType, (object)childType.Name, (object)childType.RuntimeAssembly.Name, (object)str); return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.MismatchedType, lineInformation, messageFormat)); }
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); }
internal static void ParsePropertyPathParameters(XamlParserContext parserContext, ITextLocation lineInformation, IXmlNamespaceResolver xmlNamespaceResolver, string path, out string propertyPath, out IList <IProperty> pathParameters) { pathParameters = (IList <IProperty>) new List <IProperty>(); StringBuilder stringBuilder = new StringBuilder(); int startIndex; int num1; int num2; for (startIndex = 0; (num1 = path.IndexOf('(', startIndex)) >= 0; startIndex = num2 + 1) { num2 = path.IndexOf(')', num1 + 1); if (num2 < 0) { parserContext.ReportError(XamlParseErrors.InvalidPropertyPathSyntax(lineInformation, path)); startIndex = path.Length; break; } string prefixAndTypeName = path.Substring(num1 + 1, num2 - num1 - 1); if (prefixAndTypeName.IndexOf('.') >= 0) { stringBuilder.Append(path.Substring(startIndex, num1 - startIndex)); stringBuilder.Append('('); stringBuilder.Append(pathParameters.Count); stringBuilder.Append(')'); IProperty property = (IProperty)null; XmlnsPrefix prefix; string typeName; if (XamlTypeHelper.SplitTypeName(parserContext, lineInformation, prefixAndTypeName, out prefix, out typeName)) { XmlNamespace xmlNamespace = parserContext.GetXmlNamespace(lineInformation, xmlNamespaceResolver, prefix); MemberType memberTypes = MemberType.Property | MemberType.Field; if (parserContext.TypeResolver.IsCapabilitySet(PlatformCapability.IncompleteAttachedPropertiesInMarkupExtensions)) { memberTypes |= MemberType.IncompleteAttachedProperty; } IMember member = (IMember)XamlTypeHelper.GetPropertyKey(parserContext, lineInformation, xmlNamespace, typeName, (XmlNamespace)null, (IType)null, memberTypes, MemberType.AttachedProperty, false); if (member != null) { property = MarkupExtensionParser.VerifyMemberIsDependencyProperty(parserContext, lineInformation, member); } } pathParameters.Add(property); } else { stringBuilder.Append(path.Substring(startIndex, num2 - startIndex + 1)); } } stringBuilder.Append(path.Substring(startIndex)); propertyPath = stringBuilder.ToString(); }
public XmlNamespace GetXmlNamespace(ITextLocation lineInformation, IXmlNamespaceResolver xmlNamespaceResolver, XmlnsPrefix prefix) { XmlNamespace xmlNamespace = xmlNamespaceResolver.GetXmlNamespace(prefix, XmlNamespace.GetNamespaceCanonicalization(this.TypeResolver)); if (xmlNamespace != null) { return(xmlNamespace); } if (prefix == XmlnsPrefix.EmptyPrefix) { this.ReportError(XamlParseErrors.NoDefaultNamespace(lineInformation)); } else { this.ReportError(XamlParseErrors.UnrecognizedXmlnsPrefix(lineInformation, prefix)); } return(XmlNamespace.AvalonXmlNamespace); }
internal static bool SplitMemberName(XamlParserContext parserContext, ITextLocation lineInformation, string typeAndMemberName, out string typeName, out string memberName) { typeName = (string)null; memberName = (string)null; int length = typeAndMemberName.LastIndexOf('.'); if (length >= 0) { if (length == 0 || length == typeAndMemberName.Length - 1) { parserContext.ReportError(XamlParseErrors.InvalidTypeQualifiedMemberName(lineInformation, typeAndMemberName)); return(false); } typeName = typeAndMemberName.Substring(0, length); memberName = typeAndMemberName.Substring(length + 1); return(true); } memberName = typeAndMemberName; return(true); }
internal static bool SplitTypeName(XamlParserContext parserContext, ITextLocation lineInformation, string prefixAndTypeName, out XmlnsPrefix prefix, out string typeName) { int length = prefixAndTypeName.IndexOf(':'); if (length >= 0) { if (length == 0 || length == prefixAndTypeName.Length - 1) { parserContext.ReportError(XamlParseErrors.InvalidPrefixQualifiedTypeName(lineInformation, prefixAndTypeName)); prefix = (XmlnsPrefix)null; typeName = (string)null; return(false); } prefix = XmlnsPrefix.ToPrefix(prefixAndTypeName.Substring(0, length)); typeName = prefixAndTypeName.Substring(length + 1); return(true); } prefix = XmlnsPrefix.EmptyPrefix; typeName = prefixAndTypeName; return(true); }
public static bool GetTypeAndMemberName(XamlParserContext parserContext, ITextLocation lineInformation, IXmlNamespaceResolver xmlNamespaceResolver, string fullMemberName, IType targetTypeId, out IType typeId, out string memberName) { typeId = (IType)null; memberName = (string)null; XmlnsPrefix prefix; string typeName1; if (XamlTypeHelper.SplitTypeName(parserContext, lineInformation, fullMemberName, out prefix, out typeName1)) { XmlNamespace xmlNamespace = parserContext.GetXmlNamespace(lineInformation, xmlNamespaceResolver, prefix); string typeName2; if (XamlTypeHelper.SplitMemberName(parserContext, lineInformation, typeName1, out typeName2, out memberName)) { typeId = typeName2 == null ? targetTypeId : XamlTypeHelper.GetTypeId(parserContext, lineInformation, xmlNamespace, typeName2); if (typeId != null) { return(true); } parserContext.ReportError(XamlParseErrors.CannotDetermineMemberTargetType(lineInformation, memberName)); } } return(false); }
private static IProperty VerifyMemberIsDependencyProperty(XamlParserContext parserContext, ITextLocation lineInformation, IMember member) { IDependencyProperty dependencyProperty = member as IDependencyProperty; if (dependencyProperty != null) { return((IProperty)dependencyProperty); } if (member.IsResolvable) { IType declaringType = member.DeclaringType; Exception initializationException = declaringType.InitializationException; if (initializationException != null) { parserContext.ReportError(XamlParseErrors.TypeInitializationException(lineInformation, (ITypeId)declaringType, initializationException.Message)); } else { parserContext.ReportError(XamlParseErrors.MemberNotDependencyProperty(lineInformation, (IMemberId)member)); } } return((IProperty)null); }
private static IEvent VerifyMemberIsRoutedEvent(XamlParserContext parserContext, ITextLocation lineInformation, IMember member) { IEvent @event = member as IEvent; if (@event != null && @event.IncludesRoutedEvent) { return(@event); } if (member.IsResolvable) { IType declaringType = member.DeclaringType; Exception initializationException = declaringType.InitializationException; if (initializationException != null) { parserContext.ReportError(XamlParseErrors.TypeInitializationException(lineInformation, (ITypeId)declaringType, initializationException.Message)); } else { parserContext.ReportError(XamlParseErrors.MemberNotRoutedEvent(lineInformation, (IMemberId)member)); } } return((IEvent)null); }
public static XamlParseError InvalidMarkupExtensionArguments(ITextLocation lineInformation, string markupExtensionName) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.InvalidMarkupExtensionArguments, lineInformation, StringTable.ParserInvalidMarkupExtensionArguments, markupExtensionName)); }
public static XamlParseError UnknownError(ITextLocation lineInformation) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.UnknownError, lineInformation, StringTable.ParserUnknownError)); }
public static XamlParseError PropertyIsNotWritable(ITextLocation lineInformation, IPropertyId propertyKey) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.PropertyIsNotWritable, lineInformation, StringTable.ParserPropertyIsNotWritable, propertyKey.Name)); }
public static XamlParseError NestedPropertiesNotSupported(ITextLocation lineInformation, string propertyName) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.NestedPropertiesNotSupported, lineInformation, StringTable.ParserNestedPropertiesNotSupported, propertyName)); }
public static XamlParseError InaccessibleType(ITextLocation lineInformation, string typeName) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.InaccessibleType, lineInformation, StringTable.ParserInaccessibleType, typeName)); }
public static XamlParseError UnrecognizedPlatformTypeName(ITextLocation lineInformation, bool isSilverlightProject, string typeName) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.UnrecognizedTypeName, lineInformation, StringTable.ParserUnrecognizedPlatformTypeName, isSilverlightProject ? StringTable.ParserSilverlightPlatformName : StringTable.ParserWPFPlatformName, typeName)); }
public static XamlParseError InvalidClassName(ITextLocation lineInformation, string typeName) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Warning, XamlErrorCode.InvalidClassName, lineInformation, StringTable.ParserInvalidClassName, typeName)); }
public static XamlParseError MultipleRootElements(ITextLocation lineInformation) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.MultipleRootElements, lineInformation, StringTable.ParserMultipleRootElements)); }
public static XamlParseError NoDefaultNamespace(ITextLocation lineInformation) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.NoDefaultNamespace, lineInformation, StringTable.ParserNoDefaultNamespace)); }
public static XamlParseError UnexpectedCharacter(ITextLocation lineInformation, char c) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.UnexpectedCharacter, lineInformation, StringTable.ParserUnexpectedCharacter, c.ToString())); }
public static XamlParseError DuplicateXmlnsPrefix(ITextLocation lineInformation, XmlnsPrefix prefix) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.DuplicateXmlnsPrefix, lineInformation, StringTable.ParserDuplicateXmlnsPrefix, prefix.Value)); }
public static XamlParseError InvalidPropertyPathSyntax(ITextLocation lineInformation, string propertyPath) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.InvalidPropertyPathSyntax, lineInformation, StringTable.ParserInvalidPropertyPathSyntax, propertyPath)); }
public static XamlParseError UnrecognizedTypeName(ITextLocation lineInformation, XmlNamespace xmlNamespace, string typeName) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.UnrecognizedTypeName, lineInformation, StringTable.ParserUnrecognizedTypeName, xmlNamespace.Value, typeName)); }
public static XamlParseError InvalidClrNamespaceUri(ITextLocation lineInformation, string uriValue) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.InvalidClrNamespaceUri, lineInformation, StringTable.ParserInvalidClrNamespaceUri, uriValue)); }
public static XamlParseError InnerTypesNotSupported(ITextLocation lineInformation, string typeName) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.InnerTypesNotSupported, lineInformation, StringTable.ParserInnerTypesNotSupported, typeName)); }
public static XamlParseError InvalidXmlSpace(ITextLocation lineInformation, string value) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.InvalidXmlSpace, lineInformation, StringTable.ParserInvalidXmlSpace, value)); }
public static XamlParseError UnrecognizedOrInaccessibleMember(ITextLocation lineInformation, string memberName) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.UnrecognizedOrInaccessibleMember, lineInformation, StringTable.ParserUnrecognizedOrInaccessibleMember, memberName)); }
public static XamlParseError UnexpectedRootType(ITextLocation lineInformation, ITypeId expectedType) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.UnexpectedRootType, lineInformation, StringTable.ParserUnexpectedRootType, expectedType.Name)); }
public static XamlParseError CannotDetermineMemberTargetType(ITextLocation lineInformation, string memberName) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.CannotDetermineMemberTargetType, lineInformation, StringTable.ParserCannotDetermineMemberTargetType, memberName)); }
public static XamlParseError CDataNotSupported(ITextLocation lineInformation) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.CDataNotSupported, lineInformation, StringTable.ParserCDataNotSupported)); }