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); }
private static void ExtractRangeLastTokenText( ITextLocation <TokenTextPoint> location, string token, bool wholeToken, string endMarker, StringBuilder sb) { if (location.B.At > 0) { // add token left portion sb.Append(token, 0, location.B.Run); // if we must get the whole token get also its right portion // and add markers if any if (wholeToken) { if (!string.IsNullOrEmpty(endMarker)) { sb.Append(endMarker); } if (location.B.At - 1 + location.B.Run < token.Length) { sb.Append(token, location.B.At - 1 + location.B.Run, token.Length - location.B.At - 1 + location.B.Run); } } } // not a partial token, just copy it else { sb.Append(token); } }
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)); }
public static DocumentNode GetPropertyValue(XamlParserContext parserContext, ITextLocation lineInformation, IDocumentNodeReference nodeReference, IXmlNamespaceResolver xmlNamespaceResolver, TypeConverter typeConverter, IType valueTypeId, string value, bool removeEscapeCharacters) { bool flag = false; if (value.StartsWith("{", StringComparison.Ordinal)) { if (value.StartsWith("{}", StringComparison.Ordinal)) { value = value.Substring(2); } else { flag = true; } } if (removeEscapeCharacters) { value = MarkupExtensionParser.ReplaceEscapedCharacters(value); } if (flag) { return(MarkupExtensionParser.ParseMarkupExtension(parserContext, lineInformation, nodeReference, xmlNamespaceResolver, valueTypeId, value)); } return(MarkupExtensionParser.CreateNodeFromTextValue(parserContext, lineInformation, nodeReference, xmlNamespaceResolver, typeConverter, (ITypeId)valueTypeId, value)); }
internal XamlParseError(XamlErrorSeverity severity, int errorCode, ITextLocation lineInformation, string messageFormat, params string[] parameters) { this.severity = severity; this.errorCode = errorCode; this.lineInformation = lineInformation != null ? lineInformation : (ITextLocation) new TextLocation(0, 0); this.messageFormat = messageFormat; this.parameters = new List <string>((IEnumerable <string>)parameters); }
public override bool Equals(object obj) { if (this == obj) { return(true); } ITextLocation textLocation = obj as ITextLocation; if (textLocation != null && this.Line == textLocation.Line) { return(this.Column == textLocation.Column); } return(false); }
internal static IType GetTypeId(XamlParserContext parserContext, ITextLocation lineInformation, IXmlNamespaceResolver xmlNamespaceResolver, string fullTypeName, bool inMarkupExtension) { XmlnsPrefix prefix; string typeName; if (XamlTypeHelper.SplitTypeName(parserContext, lineInformation, fullTypeName, out prefix, out typeName)) { XmlNamespace xmlNamespace = parserContext.GetXmlNamespace(lineInformation, xmlNamespaceResolver, prefix); if (xmlNamespace != null) { return(XamlTypeHelper.GetTypeId(parserContext, lineInformation, xmlNamespace, typeName, inMarkupExtension)); } } return((IType)null); }
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); }
internal static IProperty GetPropertyKey(XamlParserContext parserContext, ITextLocation lineInformation, IXmlNamespaceResolver xmlElementReference, string fullPropertyName, XmlNamespace targetTypeNamespace, IType targetTypeId, MemberType memberTypes, MemberType defaultType, bool allowProtectedPropertiesOnTargetType) { XmlnsPrefix prefix; string typeName; if (!XamlTypeHelper.SplitTypeName(parserContext, lineInformation, fullPropertyName, out prefix, out typeName)) { return((IProperty)null); } XmlNamespace xmlNamespace = (XmlNamespace)null; if (prefix != XmlnsPrefix.EmptyPrefix || typeName.IndexOf('.') >= 0) { xmlNamespace = parserContext.GetXmlNamespace(lineInformation, xmlElementReference, prefix); if (xmlNamespace == null) { return((IProperty)null); } } return(XamlTypeHelper.GetPropertyKey(parserContext, lineInformation, xmlNamespace, typeName, targetTypeNamespace, targetTypeId, memberTypes, defaultType, allowProtectedPropertiesOnTargetType)); }
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); }
public static XamlParseError NestedPropertiesNotSupported(ITextLocation lineInformation, string propertyName) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.NestedPropertiesNotSupported, lineInformation, StringTable.ParserNestedPropertiesNotSupported, propertyName)); }
public static XamlParseError InnerTypesNotSupported(ITextLocation lineInformation, string typeName) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.InnerTypesNotSupported, lineInformation, StringTable.ParserInnerTypesNotSupported, typeName)); }
public static XamlParseError InaccessibleType(ITextLocation lineInformation, string typeName) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.InaccessibleType, lineInformation, StringTable.ParserInaccessibleType, typeName)); }
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 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 DuplicateXmlnsPrefix(ITextLocation lineInformation, XmlnsPrefix prefix) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.DuplicateXmlnsPrefix, lineInformation, StringTable.ParserDuplicateXmlnsPrefix, prefix.Value)); }
public static XamlParseError InvalidXmlSpace(ITextLocation lineInformation, string value) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.InvalidXmlSpace, lineInformation, StringTable.ParserInvalidXmlSpace, value)); }
public static XamlParseError NoDefaultNamespace(ITextLocation lineInformation) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.NoDefaultNamespace, lineInformation, StringTable.ParserNoDefaultNamespace)); }
public static XamlParseError InvalidPropertyPathSyntax(ITextLocation lineInformation, string propertyPath) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.InvalidPropertyPathSyntax, lineInformation, StringTable.ParserInvalidPropertyPathSyntax, propertyPath)); }
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)); }
public static XamlParseError UnexpectedRootType(ITextLocation lineInformation, ITypeId expectedType) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.UnexpectedRootType, lineInformation, StringTable.ParserUnexpectedRootType, expectedType.Name)); }
public static XamlParseError UnrecognizedOrInaccessibleMember(ITextLocation lineInformation, string memberName) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.UnrecognizedOrInaccessibleMember, lineInformation, StringTable.ParserUnrecognizedOrInaccessibleMember, memberName)); }
public static XamlParseError InvalidClassName(ITextLocation lineInformation, string typeName) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Warning, XamlErrorCode.InvalidClassName, lineInformation, StringTable.ParserInvalidClassName, typeName)); }
public static XamlParseError PropertyIsNotWritable(ITextLocation lineInformation, IPropertyId propertyKey) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.PropertyIsNotWritable, lineInformation, StringTable.ParserPropertyIsNotWritable, propertyKey.Name)); }
public static XamlParseError InvalidClrNamespaceUri(ITextLocation lineInformation, string uriValue) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.InvalidClrNamespaceUri, lineInformation, StringTable.ParserInvalidClrNamespaceUri, uriValue)); }
public static XamlParseError UnknownError(ITextLocation lineInformation) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.UnknownError, lineInformation, StringTable.ParserUnknownError)); }
public static XamlParseError MultipleRootElements(ITextLocation lineInformation) { return(XamlParseErrors.NewParseError(XamlErrorSeverity.Error, XamlErrorCode.MultipleRootElements, lineInformation, StringTable.ParserMultipleRootElements)); }