public NvdlFilteredXmlReader (XmlReader reader,
			NvdlValidateInterp validate)
		{
			this.reader = reader;
			reader_as_line_info = reader as IXmlLineInfo;
			this.validate = validate;
		}
 public XPathDocumentBuilder(XPathDocument doc, IXmlLineInfo lineInfo, string baseUri, XPathDocument.LoadFlags flags)
 {
     this.nodePageFact.Init(0x100);
     this.nmspPageFact.Init(0x10);
     this.stkNmsp = new Stack<XPathNodeRef>();
     this.Initialize(doc, lineInfo, baseUri, flags);
 }
Пример #3
0
 static Exception Error(IXmlLineInfo lineInfo, string message)
 {
     if (lineInfo != null)
         return new HighlightingDefinitionInvalidException(HighlightingLoader.FormatExceptionMessage(message, lineInfo.LineNumber, lineInfo.LinePosition));
     else
         return new HighlightingDefinitionInvalidException(message);
 }
Пример #4
0
 private void ConfigError (IXmlLineInfo lineInfo, string message, params object [] args)
 {
     Console.Error.WriteLine ("Analyzer Configuration Error: {0} ({1}:{2},{3})",
         String.Format (message, args), configuration_path,
         lineInfo.LineNumber, lineInfo.LinePosition);
     throw new Exception ();
 }
Пример #5
0
 internal XmlException(string res, string[] args,  IXmlLineInfo lineInfo) {
     HResult = HResults.Xml;
     this.res = res;
     this.args = args;
     this.lineNumber = null == lineInfo ? 0 : lineInfo.LineNumber;
     this.linePosition = null == lineInfo ? 0 : lineInfo.LinePosition;
 }
Пример #6
0
		private NvdlReader (XmlReader reader)
		{
			// FIXME: use .rnc validation.
			this.reader = reader;
			this.lineInfo = reader as IXmlLineInfo;
			reader.MoveToContent ();
		}
Пример #7
0
		// Return false if there is already the same key.
		public bool SetIdentityField (object identity, bool isXsiNil, XsdAnySimpleType type, int depth, IXmlLineInfo li)
		{
			FieldFoundDepth = depth;
			Identity = identity;
			IsXsiNil = isXsiNil;
			FieldFound |= isXsiNil;
			FieldType = type;
			Consuming = false;
			Consumed = true;
			if (li != null && li.HasLineInfo ()) {
				FieldHasLineInfo = true;
				FieldLineNumber = li.LineNumber;
				FieldLinePosition = li.LinePosition;
			}

			if (!(this.entry.OwnerSequence.SourceSchemaIdentity is XmlSchemaKeyref)) {
				for (int i = 0; i < entry.OwnerSequence.FinishedEntries.Count; i++) {
					XsdKeyEntry other = (XsdKeyEntry) entry.OwnerSequence.FinishedEntries [i];
					if (this.entry.CompareIdentity (other))
						return false;
				}
			}

			return true;
		}
Пример #8
0
      protected virtual Exception CreateParseException(IXmlLineInfo lineInfo, string format, params object[] args) {

         if (lineInfo != null && lineInfo.HasLineInfo())
            return new HttpParseException(String.Format(CultureInfo.InvariantCulture, format, args), null, this.VirtualPath, null, lineInfo.LineNumber);
         else
            return new HttpParseException(String.Format(CultureInfo.InvariantCulture, format, args));
      }
Пример #9
0
        static Color? ParseColor(IXmlLineInfo lineInfo, string color)
        {
            if (string.IsNullOrEmpty(color))
                return null;

            return ColorConverter.ConvertFromString(color);
        }
 private void SetLineInfo(IXmlLineInfo lineInfo, SearchResult searchResult)
 {
     if(lineInfo.HasLineInfo())
     {
         searchResult.LineNumber = lineInfo.LineNumber;
         searchResult.LinePosition = lineInfo.LinePosition;
     }
 }
Пример #11
0
        private static string WrapMessage(IXmlLineInfo lineInfo, string message, Exception innerException)
        {
            if (innerException == null)
                return string.Format("{0} (line: {1}, col: {2})", message, lineInfo.LineNumber, lineInfo.LinePosition);

            return string.Format("{0} (line: {1}, col: {2}): [{3}] {4}", message, lineInfo.LineNumber,
                                 lineInfo.LinePosition, innerException.GetType().Name, innerException.Message);
        }
//Constructor
        internal XsdCachingReader(XmlReader reader, IXmlLineInfo lineInfo, CachingEventHandler handlerMethod) {
            this.coreReader = reader;
            this.lineInfo = lineInfo;
            this.cacheHandler = handlerMethod;
            attributeEvents = new ValidatingReaderNodeData[InitialAttributeCount];
            contentEvents = new ValidatingReaderNodeData[InitialContentCount];
            Init();
        }
Пример #13
0
        public Attribute(string name, IXmlLineInfo lineInfo)
        {
            this.name = name;

            _hasLineInfo = lineInfo.HasLineInfo();
            _lineNumber = lineInfo.LineNumber;
            _linePosition = lineInfo.LinePosition;
        }
Пример #14
0
 internal PositionXmlAttribute(string prefix, string localName, string namespaceURI, XmlDocument doc, IXmlLineInfo lineInfo)
     : base(prefix, localName, namespaceURI, doc)
 {
     if (lineInfo != null) {
         this.lineNumber = lineInfo.LineNumber;
         this.linePosition = lineInfo.LinePosition;
         this.hasLineInfo = true;
     }
 }
Пример #15
0
 internal static SystemColorHighlightingBrush GetSystemColorBrush(IXmlLineInfo lineInfo, string name)
 {
     Debug.Assert(name.StartsWith("SystemColors.", StringComparison.Ordinal));
     string shortName = name.Substring(13);
     var property = typeof(SystemColors).GetProperty(shortName + "Brush");
     if (property == null)
         throw Error(lineInfo, "Cannot find '" + name + "'.");
     return new SystemColorHighlightingBrush(property);
 }
 private static string AddLineInfo(string message, IXmlLineInfo lineInfo)
 {
     if (lineInfo != null)
     {
         string[] args = new string[] { lineInfo.LineNumber.ToString(CultureInfo.InvariantCulture), lineInfo.LinePosition.ToString(CultureInfo.InvariantCulture) };
         message = message + " " + Res.GetString("Xml_ErrorPosition", args);
     }
     return message;
 }
Пример #17
0
		static string BuildMessage (string message, IXmlLineInfo li, string sourceUri)
		{
			if (li != null && li.HasLineInfo ()) {
				message = String.Format ("{0}. Location: {1} ({2}, {3}).", message, sourceUri, li.LineNumber, li.LinePosition);
			}
			else if (sourceUri != null)
				message = String.Format ("{0}. Location: {1}", message, sourceUri);
			return message;
		}
Пример #18
0
        public XmlReaderProxy(XmlReader xmlreader, Uri baseUri, IXmlLineInfo lineNumberService)
        {
            Debug.Assert(xmlreader != null, "xmlreader != null");
            Debug.Assert(baseUri != null, "baseUri != null");

            _proxy = xmlreader;
            _baseUri = baseUri;
            _lineNumberService = lineNumberService;
        }
Пример #19
0
		/// <summary>
		/// Loads the XML document from the specified <see cref="XmlReader"/>.
		/// </summary>
		public override void Load(XmlReader reader)
		{
			lineInfo = reader as IXmlLineInfo;
			try {
				base.Load(reader);
			} finally {
				lineInfo = null;
			}
		}
Пример #20
0
        public override void Load(XmlReader reader)
        {
            if (reader is IXmlLineInfo)
                lineInfo = (IXmlLineInfo)reader;

            base.Load(reader);

            lineInfo = null;
        }
 internal XsdCachingReader(XmlReader reader, IXmlLineInfo lineInfo, CachingEventHandler handlerMethod)
 {
     this.coreReader = reader;
     this.lineInfo = lineInfo;
     this.cacheHandler = handlerMethod;
     this.attributeEvents = new ValidatingReaderNodeData[8];
     this.contentEvents = new ValidatingReaderNodeData[4];
     this.Init();
 }
Пример #22
0
        /// <summary>
        /// Create a new XPathDocumentBuilder which creates nodes in "doc".
        /// </summary>
        public XPathDocumentBuilder(XPathDocument doc, IXmlLineInfo lineInfo, string baseUri, XPathDocument.LoadFlags flags) {
            // Allocate the initial node (for non-namespaces) page, and the initial namespace page
            this.nodePageFact.Init(256);
            this.nmspPageFact.Init(16);

            this.stkNmsp = new Stack<XPathNodeRef>();

            Initialize(doc, lineInfo, baseUri, flags);
        }
Пример #23
0
 protected internal ParseErrorEventArgs(string message, IXmlLineInfo lineInfo)
 {
     this._message = message;
     if (lineInfo != null) {
         this._hasLineInfo = lineInfo.HasLineInfo();
         this._lineNumber = lineInfo.LineNumber;
         this._linePosition = lineInfo.LinePosition;
     }
 }
        /// <summary>
        ///     A default mapping (property "Foo" maps by convention to column "Foo"), if allowed, has the lowest precedence.
        ///     A mapping for a specific type (EntityType="Bar") takes precedence over a mapping for a hierarchy (EntityType="IsTypeOf(Bar)"))
        ///     If there are two hierarchy mappings, the most specific mapping takes precedence.
        ///     For instance, given the types Base, Derived1 : Base, and Derived2 : Derived1,
        ///     w.r.t. Derived1 "IsTypeOf(Derived1)" takes precedence over "IsTypeOf(Base)" when you ask for the rename of Derived1
        /// </summary>
        /// <param name="lineInfo"> Empty for default rename mapping. </param>
        internal string GetRename(EdmType type, out IXmlLineInfo lineInfo)
        {
            DebugCheck.NotNull(type);

            Debug.Assert(type is StructuralType, "we can only rename structural type");

            var rename = _renameCache.Evaluate(type as StructuralType);
            lineInfo = rename.LineInfo;
            return rename.ColumnName;
        }
 protected XPathNavigatorReader(XPathNavigator navToRead, IXmlLineInfo xli, IXmlSchemaInfo xsi)
 {
     this.navToRead = navToRead;
     this.lineInfo = xli;
     this.schemaInfo = xsi;
     this.nav = XmlEmptyNavigator.Singleton;
     this.state = State.Initial;
     this.depth = 0;
     this.nodeType = ToXmlNodeType(this.nav.NodeType);
 }
Пример #26
0
		public SubtreeXmlReader (XmlReader reader)
		{
			this.Reader = reader;
			li = reader as IXmlLineInfo;
			nsResolver = reader as IXmlNamespaceResolver;
			initial = true;
			startDepth = reader.Depth;
			if (reader.ReadState == ReadState.Initial)
				startDepth = -1; // end == the reader's end
		}
        /// <summary>
        /// A default mapping (property "Foo" maps by convention to column "Foo"), if allowed, has the lowest precedence.
        /// A mapping for a specific type (EntityType="Bar") takes precedence over a mapping for a hierarchy (EntityType="IsTypeOf(Bar)"))
        /// If there are two hierarchy mappings, the most specific mapping takes precedence. 
        /// For instance, given the types Base, Derived1 : Base, and Derived2 : Derived1, 
        /// w.r.t. Derived1 "IsTypeOf(Derived1)" takes precedence over "IsTypeOf(Base)" when you ask for the rename of Derived1
        /// </summary>
        /// <param name="lineInfo">Empty for default rename mapping.</param>
        internal string GetRename(EdmType type, out IXmlLineInfo lineInfo)
        {
            //Contract.Requires(type != null);

            Debug.Assert(type is StructuralType, "we can only rename structural type");

            var rename = _renameCache.Evaluate(type as StructuralType);
            lineInfo = rename.LineInfo;
            return rename.ColumnName;
        }
Пример #28
0
		public XmlSimpleDictionaryReader (XmlReader reader,
			XmlDictionary dictionary, OnXmlDictionaryReaderClose onClose)
		{
			this.reader = reader;
			this.onClose = onClose;
			as_line_info = reader as IXmlLineInfo;
			as_dict_reader = reader as XmlDictionaryReader;

			if (dictionary == null)
				dictionary = new XmlDictionary ();
			dict = dictionary;
		}
 internal XamlScanner(XamlParserContext context, XmlReader xmlReader, XamlXmlReaderSettings settings)
 {
     this._xmlReader = xmlReader;
     this._xmlLineInfo = settings.ProvideLineInfo ? (xmlReader as IXmlLineInfo) : null;
     this._parserContext = context;
     this._scannerStack = new XamlScannerStack();
     this._readNodesQueue = new Queue<XamlScannerNode>();
     this._settings = settings;
     if (settings.XmlSpacePreserve)
     {
         this._scannerStack.CurrentXmlSpacePreserve = true;
     }
 }
        internal PropertyTreeXmlReader(XmlReader reader)
        {
            this.reader = reader;
            this.readerLineInfoCache = (reader as IXmlLineInfo) ?? Utility.NullLineInfo;

            if (this.reader.ReadState == XReadState.Interactive) {
                this.state = PTXReaderState.ChooseState(reader);
                this.state.Accept(this, reader);

            } else {
                this.state = PTXReaderState.Initial;
            }
        }
Пример #31
0
        static bool TryAddToResourceDictionary(ResourceDictionary resourceDictionary, object value, string xKey, IXmlLineInfo lineInfo, out Exception exception)
        {
            exception = null;

            if (resourceDictionary == null)
            {
                return(false);
            }

            if (xKey != null)
            {
                resourceDictionary.Add(xKey, value);
            }
            else if (value is Style)
            {
                resourceDictionary.Add((Style)value);
            }
            else if (value is ResourceDictionary)
            {
                resourceDictionary.Add((ResourceDictionary)value);
            }
            else
            {
                exception = new XamlParseException("resources in ResourceDictionary require a x:Key attribute", lineInfo);
                return(false);
            }
            return(true);
        }
Пример #32
0
 internal XmlException(int res, string[] args, IXmlLineInfo lineInfo)
     : this(res, args, lineInfo, (string)null)
 {
 }
Пример #33
0
 internal XmlException(int res, string arg, IXmlLineInfo lineInfo)
     : this(res, new string[1] {
     arg
 }, lineInfo, (string)null)
 {
 }
Пример #34
0
        public static void SetPropertyValue(object xamlelement, XmlName propertyName, object value, object rootElement, INode node, HydrationContext context, IXmlLineInfo lineInfo)
        {
            var       localName       = propertyName.LocalName;
            var       serviceProvider = new XamlServiceProvider(node, context);
            Exception xpe             = null;
            var       xKey            = node is IElementNode && ((IElementNode)node).Properties.ContainsKey(XmlName.xKey) ? ((ValueNode)((IElementNode)node).Properties[XmlName.xKey]).Value as string : null;


            //If it's an attached BP, update elementType and propertyName
            var bpOwnerType = xamlelement.GetType();
            var attached    = GetRealNameAndType(ref bpOwnerType, propertyName.NamespaceURI, ref localName, context, lineInfo);
            var property    = GetBindableProperty(bpOwnerType, localName, lineInfo, false);

            //If the target is an event, connect
            if (xpe == null && TryConnectEvent(xamlelement, localName, value, rootElement, lineInfo, out xpe))
            {
                return;
            }

            //If Value is DynamicResource and it's a BP, SetDynamicResource
            if (xpe == null && TrySetDynamicResource(xamlelement, property, value, lineInfo, out xpe))
            {
                return;
            }

            //If value is BindingBase, SetBinding
            if (xpe == null && TrySetBinding(xamlelement, property, localName, value, lineInfo, out xpe))
            {
                return;
            }

            //If it's a BindableProberty, SetValue
            if (xpe == null && TrySetValue(xamlelement, property, attached, value, lineInfo, serviceProvider, out xpe))
            {
                return;
            }

            //If we can assign that value to a normal property, let's do it
            if (xpe == null && TrySetProperty(xamlelement, localName, value, lineInfo, serviceProvider, context, out xpe))
            {
                return;
            }

            //If it's an already initialized property, add to it
            if (xpe == null && TryAddToProperty(xamlelement, propertyName, value, xKey, lineInfo, serviceProvider, context, out xpe))
            {
                return;
            }

            xpe = xpe ?? new XamlParseException($"Cannot assign property \"{localName}\": Property does not exists, or is not assignable, or mismatching type between value and property", lineInfo);
            if (context.ExceptionHandler != null)
            {
                context.ExceptionHandler(xpe);
            }
            else
            {
                throw xpe;
            }
        }
Пример #35
0
        static bool TryConnectEvent(object element, string localName, object value, object rootElement, IXmlLineInfo lineInfo, out Exception exception)
        {
            exception = null;

            var elementType = element.GetType();
            var eventInfo   = elementType.GetRuntimeEvent(localName);
            var stringValue = value as string;

            if (eventInfo == null || IsNullOrEmpty(stringValue))
            {
                return(false);
            }

            var methodInfo = rootElement.GetType().GetRuntimeMethods().FirstOrDefault(mi => mi.Name == (string)value);

            if (methodInfo == null)
            {
                exception = new XamlParseException($"No method {value} found on type {rootElement.GetType()}", lineInfo);
                return(false);
            }

            try {
                eventInfo.AddEventHandler(element, methodInfo.CreateDelegate(eventInfo.EventHandlerType, rootElement));
                return(true);
            } catch (ArgumentException ae) {
                exception = new XamlParseException($"Method {stringValue} does not have the correct signature", lineInfo, ae);
            }
            return(false);
        }
Пример #36
0
        static bool TrySetBinding(object element, BindableProperty property, string localName, object value, IXmlLineInfo lineInfo, out Exception exception)
        {
            exception = null;

            var elementType          = element.GetType();
            var binding              = value.ConvertTo(typeof(BindingBase), pinfoRetriever: null, serviceProvider: null) as BindingBase;
            var bindable             = element as BindableObject;
            var nativeBindingService = DependencyService.Get <INativeBindingService>();

            if (binding == null)
            {
                return(false);
            }

            if (bindable != null && property != null)
            {
                bindable.SetBinding(property, binding);
                return(true);
            }

            if (nativeBindingService != null && property != null && nativeBindingService.TrySetBinding(element, property, binding))
            {
                return(true);
            }

            if (nativeBindingService != null && nativeBindingService.TrySetBinding(element, localName, binding))
            {
                return(true);
            }

            if (property != null)
            {
                exception = new XamlParseException($"{elementType.Name} is not a BindableObject or does not support native bindings", lineInfo);
            }

            return(false);
        }
Пример #37
0
        static bool TryGetValue(object element, BindableProperty property, bool attached, out object value, IXmlLineInfo lineInfo, out Exception exception, out object targetProperty)
        {
            exception      = null;
            value          = null;
            targetProperty = property;
            var elementType = element.GetType();
            var bindable    = element as BindableObject;

            if (property == null)
            {
                return(false);
            }

            if (bindable == null)
            {
                return(false);
            }

            value = bindable.GetValue(property);
            return(true);
        }
Пример #38
0
 public XmlNodeException(string message, XmlNode node)
     : base(message)
 {
     this.lineInfo = node as IXmlLineInfo;
     this.document = node.OwnerDocument as XmlFileInfoDocument;
 }
Пример #39
0
 /// <summary>
 ///     Initializes a new instance of the <see cref="YAXCannotAddObjectToCollection" /> class.
 /// </summary>
 /// <param name="propName">Name of the property.</param>
 /// <param name="obj">The object that could not be added to the collection.</param>
 /// <param name="lineInfo">IXmlLineInfo derived object, e.g. XElement, XAttribute containing line info</param>
 public YAXCannotAddObjectToCollection(string propName, object obj, IXmlLineInfo lineInfo) :
     base(lineInfo)
 {
     PropertyName = propName;
     ObjectToAdd  = obj;
 }
Пример #40
0
 public static TypeReference GetTypeReference(string namespaceURI, string typename, ModuleDefinition module, IXmlLineInfo xmlInfo)
 {
     return(new XmlType(namespaceURI, typename, null).GetTypeReference(module, xmlInfo));
 }
Пример #41
0
        public static TypeReference GetTypeReference(this XmlType xmlType, ModuleDefinition module, IXmlLineInfo xmlInfo, bool fromAllAssembly = false)
        {
            if (s_xmlnsDefinitions == null)
            {
                GatherXmlnsDefinitionAttributes();
            }

            var namespaceURI  = xmlType.NamespaceUri;
            var elementName   = xmlType.Name;
            var typeArguments = xmlType.TypeArguments;

            if (elementName.Contains("-"))
            {
                elementName = elementName.Replace('-', '+');
            }

            var lookupAssemblies = new List <XmlnsDefinitionAttribute>();

            var lookupNames = new List <string>();

            if (true == fromAllAssembly)
            {
                foreach (var xmlnsDef in s_xmlnsDefinitions)
                {
                    lookupAssemblies.Add(xmlnsDef);
                }
            }
            else
            {
                foreach (var xmlnsDef in s_xmlnsDefinitions)
                {
                    if (xmlnsDef.XmlNamespace != namespaceURI)
                    {
                        continue;
                    }
                    lookupAssemblies.Add(xmlnsDef);
                }
            }

            if (lookupAssemblies.Count == 0)
            {
                string ns;
                string typename;
                string asmstring;
                string targetPlatform;

                XmlnsHelper.ParseXmlns(namespaceURI, out typename, out ns, out asmstring, out targetPlatform);
                asmstring = asmstring ?? module.Assembly.Name.Name;
                if (ns != null)
                {
                    lookupAssemblies.Add(new XmlnsDefinitionAttribute(namespaceURI, ns, 0)
                    {
                        AssemblyName = asmstring
                    });
                }
            }

            lookupNames.Add(elementName);
            lookupNames.Add(elementName + "Extension");

            for (var i = 0; i < lookupNames.Count; i++)
            {
                var name = lookupNames[i];
                if (name.Contains(":"))
                {
                    name = name.Substring(name.LastIndexOf(':') + 1);
                }
                if (typeArguments != null)
                {
                    name += "`" + typeArguments.Count; //this will return an open generic Type
                }
                lookupNames[i] = name;
            }

            TypeReference type = null;

            foreach (var asm in lookupAssemblies)
            {
                if (type != null)
                {
                    break;
                }
                foreach (var name in lookupNames)
                {
                    if (type != null)
                    {
                        break;
                    }

                    var clrNamespace = asm.ClrNamespace;
                    var typeName     = name.Replace('+', '/'); //Nested types
                    var idx          = typeName.LastIndexOf('.');
                    if (idx >= 0)
                    {
                        clrNamespace += '.' + typeName.Substring(0, typeName.LastIndexOf('.'));
                        typeName      = typeName.Substring(typeName.LastIndexOf('.') + 1);
                    }
                    type = module.GetTypeDefinition((asm.AssemblyName, clrNamespace, typeName));
                }
            }

            if (type != null && typeArguments != null && type.HasGenericParameters)
            {
                type =
                    module.ImportReference(type)
                    .MakeGenericInstanceType(typeArguments.Select(x => GetTypeReference(x, module, xmlInfo)).ToArray());
            }

            if (type == null)
            {
                throw new XamlParseException(string.Format("Type {0} not found in xmlns {1}", elementName, namespaceURI), xmlInfo);
            }

            return(module.ImportReference(type));
        }
Пример #42
0
 public static bool IsInRange(this IXmlLineInfo item, TextLocation begin, TextLocation end)
 {
     return(IsInRange(item, begin.Line, begin.Column, end.Line, end.Column));
 }
Пример #43
0
        static bool TryAddToProperty(object element, XmlName propertyName, object value, string xKey, IXmlLineInfo lineInfo, XamlServiceProvider serviceProvider, HydrationContext context, out Exception exception)
        {
            exception = null;

            object targetProperty;
            var    collection = GetPropertyValue(element, propertyName, context, lineInfo, out targetProperty) as IEnumerable;

            if (collection == null)
            {
                return(false);
            }

            if (exception == null && TryAddToResourceDictionary(collection as ResourceDictionary, value, xKey, lineInfo, out exception))
            {
                return(true);
            }

            if (exception != null)
            {
                return(false);
            }

            var addMethod = collection.GetType().GetRuntimeMethods().First(mi => mi.Name == "Add" && mi.GetParameters().Length == 1);

            if (addMethod == null)
            {
                return(false);
            }

            if (serviceProvider != null)
            {
                ((XamlValueTargetProvider)serviceProvider.IProvideValueTarget).TargetProperty = targetProperty;
            }

            addMethod.Invoke(collection, new [] { value.ConvertTo(addMethod.GetParameters() [0].ParameterType, (Func <TypeConverter>)null, serviceProvider) });
            return(true);
        }
Пример #44
0
 internal XmlException(int res, string arg, Exception innerException, IXmlLineInfo lineInfo)
     : this(res, new string[1] {
     arg
 }, innerException, lineInfo == null ? 0 : lineInfo.LineNumber, lineInfo == null ? 0 : lineInfo.LinePosition, (string)null)
 {
 }
Пример #45
0
        static bool TryGetProperty(object element, string localName, out object value, IXmlLineInfo lineInfo, HydrationContext context, out Exception exception, out object targetProperty)
        {
            exception = null;
            value     = null;
            var          elementType  = element.GetType();
            PropertyInfo propertyInfo = null;

            try {
                propertyInfo = elementType.GetRuntimeProperty(localName);
            } catch (AmbiguousMatchException) {
                // Get most derived instance of property
                foreach (var property in elementType.GetRuntimeProperties().Where(prop => prop.Name == localName))
                {
                    if (propertyInfo == null || propertyInfo.DeclaringType.IsAssignableFrom(property.DeclaringType))
                    {
                        propertyInfo = property;
                    }
                }
            }
            MethodInfo getter;

            targetProperty = propertyInfo;
            if (propertyInfo == null || !propertyInfo.CanRead || (getter = propertyInfo.GetMethod) == null)
            {
                return(false);
            }

            if (!IsVisibleFrom(getter, context.RootElement))
            {
                return(false);
            }

            value = getter.Invoke(element, new object[] { });
            return(true);
        }
Пример #46
0
 public XmlNodeException(Exception innerException, XmlNode node)
     : base(innerException.Message, innerException)
 {
     this.lineInfo = node as IXmlLineInfo;
     this.document = node.OwnerDocument as XmlFileInfoDocument;
 }
Пример #47
0
        static bool TrySetValue(object element, BindableProperty property, bool attached, object value, IXmlLineInfo lineInfo, XamlServiceProvider serviceProvider, out Exception exception)
        {
            exception = null;

            var elementType          = element.GetType();
            var bindable             = element as BindableObject;
            var nativeBindingService = DependencyService.Get <INativeBindingService>();

            if (property == null)
            {
                return(false);
            }

            if (serviceProvider != null && serviceProvider.IProvideValueTarget != null)
            {
                ((XamlValueTargetProvider)serviceProvider.IProvideValueTarget).TargetProperty = property;
            }

            Func <MemberInfo> minforetriever;

            if (attached)
            {
                minforetriever = () => property.DeclaringType.GetRuntimeMethod("Get" + property.PropertyName, new [] { typeof(BindableObject) });
            }
            else
            {
                minforetriever = () => property.DeclaringType.GetRuntimeProperty(property.PropertyName);
            }
            var convertedValue = value.ConvertTo(property.ReturnType, minforetriever, serviceProvider);

            if (bindable != null)
            {
                //SetValue doesn't throw on mismatching type, so check before to get a chance to try the property setting or the collection adding
                var nullable = property.ReturnTypeInfo.IsGenericType &&
                               property.ReturnTypeInfo.GetGenericTypeDefinition() == typeof(Nullable <>);
                if ((convertedValue == null && (!property.ReturnTypeInfo.IsValueType || nullable)) ||
                    (property.ReturnType.IsInstanceOfType(convertedValue)))
                {
                    bindable.SetValue(property, convertedValue);
                    return(true);
                }
                return(false);
            }

            if (nativeBindingService != null && nativeBindingService.TrySetValue(element, property, convertedValue))
            {
                return(true);
            }

            exception = new XamlParseException($"{elementType.Name} is not a BindableObject or does not support setting native BindableProperties", lineInfo);
            return(false);
        }
Пример #48
0
 /// <summary>
 ///     Initializes a new instance of the <see cref="YAXAttributeMissingException" /> class.
 /// </summary>
 /// <param name="elementName">Name of the element.</param>
 /// <param name="lineInfo">IXmlLineInfo derived object, e.g. XElement, XAttribute containing line info</param>
 public YAXElementValueMissingException(string elementName, IXmlLineInfo lineInfo)
     : base(lineInfo)
 {
     ElementName = elementName;
 }
Пример #49
0
        static bool TrySetDynamicResource(object element, BindableProperty property, object value, IXmlLineInfo lineInfo, out Exception exception)
        {
            exception = null;

            var elementType     = element.GetType();
            var dynamicResource = value as DynamicResource;
            var bindable        = element as BindableObject;

            if (dynamicResource == null || property == null)
            {
                return(false);
            }

            if (bindable == null)
            {
                exception = new XamlParseException($"{elementType.Name} is not a BindableObject", lineInfo);
                return(false);
            }

            bindable.SetDynamicResource(property, dynamicResource.Key);
            return(true);
        }
Пример #50
0
        static Instruction PushParsedEnum(TypeReference enumRef, string value, IXmlLineInfo lineInfo)
        {
            var enumDef = enumRef.ResolveCached();

            if (!enumDef.IsEnum)
            {
                throw new InvalidOperationException();
            }

            // The approved types for an enum are byte, sbyte, short, ushort, int, uint, long, or ulong.
            // https://msdn.microsoft.com/en-us/library/sbbt4032.aspx
            byte          b = 0; sbyte sb = 0; short s = 0; ushort us = 0;
            int           i = 0; uint ui = 0; long l = 0; ulong ul = 0;
            bool          found   = false;
            TypeReference typeRef = null;

            foreach (var field in enumDef.Fields)
            {
                if (field.Name == "value__")
                {
                    typeRef = field.FieldType;
                }
            }

            if (typeRef == null)
            {
                throw new ArgumentException();
            }

            foreach (var v in value.Split(','))
            {
                foreach (var field in enumDef.Fields)
                {
                    if (field.Name == "value__")
                    {
                        continue;
                    }
                    if (field.Name == v.Trim())
                    {
                        switch (typeRef.FullName)
                        {
                        case "System.Byte":
                            b |= (byte)field.Constant;
                            break;

                        case "System.SByte":
                            if (found)
                            {
                                throw new XamlParseException($"Multi-valued enums are not valid on sbyte enum types", lineInfo);
                            }
                            sb = (sbyte)field.Constant;
                            break;

                        case "System.Int16":
                            s |= (short)field.Constant;
                            break;

                        case "System.UInt16":
                            us |= (ushort)field.Constant;
                            break;

                        case "System.Int32":
                            i |= (int)field.Constant;
                            break;

                        case "System.UInt32":
                            ui |= (uint)field.Constant;
                            break;

                        case "System.Int64":
                            l |= (long)field.Constant;
                            break;

                        case "System.UInt64":
                            ul |= (ulong)field.Constant;
                            break;
                        }
                        found = true;
                    }
                }
            }

            if (!found)
            {
                throw new XamlParseException($"Enum value not found for {value}", lineInfo);
            }

            switch (typeRef.FullName)
            {
            case "System.Byte":
                return(Instruction.Create(OpCodes.Ldc_I4, (int)b));

            case "System.SByte":
                return(Instruction.Create(OpCodes.Ldc_I4, (int)sb));

            case "System.Int16":
                return(Instruction.Create(OpCodes.Ldc_I4, (int)s));

            case "System.UInt16":
                return(Instruction.Create(OpCodes.Ldc_I4, (int)us));

            case "System.Int32":
                return(Instruction.Create(OpCodes.Ldc_I4, (int)i));

            case "System.UInt32":
                return(Instruction.Create(OpCodes.Ldc_I4, (uint)ui));

            case "System.Int64":
                return(Instruction.Create(OpCodes.Ldc_I4, (long)l));

            case "System.UInt64":
                return(Instruction.Create(OpCodes.Ldc_I4, (ulong)ul));

            default:
                throw new XamlParseException($"Enum value not found for {value}", lineInfo);
            }
        }
Пример #51
0
        public static object GetPropertyValue(object xamlElement, XmlName propertyName, HydrationContext context, IXmlLineInfo lineInfo, out object targetProperty)
        {
            var       localName = propertyName.LocalName;
            Exception xpe       = null;
            object    value;

            targetProperty = null;

            //If it's an attached BP, update elementType and propertyName
            var bpOwnerType = xamlElement.GetType();
            var attached    = GetRealNameAndType(ref bpOwnerType, propertyName.NamespaceURI, ref localName, context, lineInfo);
            var property    = GetBindableProperty(bpOwnerType, localName, lineInfo, false);

            //If it's a BindableProberty, GetValue
            if (xpe == null && TryGetValue(xamlElement, property, attached, out value, lineInfo, out xpe, out targetProperty))
            {
                return(value);
            }

            //If it's a normal property, get it
            if (xpe == null && TryGetProperty(xamlElement, localName, out value, lineInfo, context, out xpe, out targetProperty))
            {
                return(value);
            }

            xpe = xpe ?? new XamlParseException($"Property {localName} is not found or does not have an accessible getter", lineInfo);
            if (context.ExceptionHandler != null)
            {
                context.ExceptionHandler(xpe);
            }
            else
            {
                throw xpe;
            }

            return(null);
        }
Пример #52
0
 internal static XmlContext CreateFrom(IXmlLineInfo lineInfo)
 {
     return(new XmlContext {
         LineInfo = lineInfo
     });
 }
Пример #53
0
        static object GetTargetProperty(object xamlelement, XmlName propertyName, HydrationContext context, IXmlLineInfo lineInfo)
        {
            var localName = propertyName.LocalName;
            //If it's an attached BP, update elementType and propertyName
            var bpOwnerType = xamlelement.GetType();

            GetRealNameAndType(ref bpOwnerType, propertyName.NamespaceURI, ref localName, context, lineInfo);
            var property = GetBindableProperty(bpOwnerType, localName, lineInfo, false);

            if (property != null)
            {
                return(property);
            }

            var elementType  = xamlelement.GetType();
            var propertyInfo = elementType.GetRuntimeProperties().FirstOrDefault(p => p.Name == localName);

            return(propertyInfo);
        }
Пример #54
0
        internal void ReadContentFrom(XmlReader r, LoadOptions o)
        {
            if ((o & (LoadOptions.SetBaseUri | LoadOptions.SetLineInfo)) == 0)
            {
                ReadContentFrom(r);
                return;
            }
            if (r.ReadState != ReadState.Interactive)
            {
                throw new InvalidOperationException(SR.InvalidOperation_ExpectedInteractive);
            }
            XContainer     c       = this;
            XNode          n       = null;
            NamespaceCache eCache  = new NamespaceCache();
            NamespaceCache aCache  = new NamespaceCache();
            string         baseUri = (o & LoadOptions.SetBaseUri) != 0 ? r.BaseURI : null;
            IXmlLineInfo   li      = (o & LoadOptions.SetLineInfo) != 0 ? r as IXmlLineInfo : null;

            do
            {
                string uri = r.BaseURI;
                switch (r.NodeType)
                {
                case XmlNodeType.Element:
                {
                    XElement e = new XElement(eCache.Get(r.NamespaceURI).GetName(r.LocalName));
                    if (baseUri != null && baseUri != uri)
                    {
                        e.SetBaseUri(uri);
                    }
                    if (li != null && li.HasLineInfo())
                    {
                        e.SetLineInfo(li.LineNumber, li.LinePosition);
                    }
                    if (r.MoveToFirstAttribute())
                    {
                        do
                        {
                            XAttribute a = new XAttribute(aCache.Get(r.Prefix.Length == 0 ? string.Empty : r.NamespaceURI).GetName(r.LocalName), r.Value);
                            if (li != null && li.HasLineInfo())
                            {
                                a.SetLineInfo(li.LineNumber, li.LinePosition);
                            }
                            e.AppendAttributeSkipNotify(a);
                        } while (r.MoveToNextAttribute());
                        r.MoveToElement();
                    }
                    c.AddNodeSkipNotify(e);
                    if (!r.IsEmptyElement)
                    {
                        c = e;
                        if (baseUri != null)
                        {
                            baseUri = uri;
                        }
                    }
                    break;
                }

                case XmlNodeType.EndElement:
                {
                    if (c.content == null)
                    {
                        c.content = string.Empty;
                    }
                    // Store the line info of the end element tag.
                    // Note that since we've got EndElement the current container must be an XElement
                    XElement e = c as XElement;
                    Debug.Assert(e != null, "EndElement received but the current container is not an element.");
                    if (e != null && li != null && li.HasLineInfo())
                    {
                        e.SetEndElementLineInfo(li.LineNumber, li.LinePosition);
                    }
                    if (c == this)
                    {
                        return;
                    }
                    if (baseUri != null && c.HasBaseUri)
                    {
                        baseUri = c.parent.BaseUri;
                    }
                    c = c.parent;
                    break;
                }

                case XmlNodeType.Text:
                case XmlNodeType.SignificantWhitespace:
                case XmlNodeType.Whitespace:
                    if ((baseUri != null && baseUri != uri) ||
                        (li != null && li.HasLineInfo()))
                    {
                        n = new XText(r.Value);
                    }
                    else
                    {
                        c.AddStringSkipNotify(r.Value);
                    }
                    break;

                case XmlNodeType.CDATA:
                    n = new XCData(r.Value);
                    break;

                case XmlNodeType.Comment:
                    n = new XComment(r.Value);
                    break;

                case XmlNodeType.ProcessingInstruction:
                    n = new XProcessingInstruction(r.Name, r.Value);
                    break;

                case XmlNodeType.DocumentType:
                    n = new XDocumentType(r.LocalName, r.GetAttribute("PUBLIC"), r.GetAttribute("SYSTEM"), r.Value);
                    break;

                case XmlNodeType.EntityReference:
                    if (!r.CanResolveEntity)
                    {
                        throw new InvalidOperationException(SR.InvalidOperation_UnresolvedEntityReference);
                    }
                    r.ResolveEntity();
                    break;

                case XmlNodeType.EndEntity:
                    break;

                default:
                    throw new InvalidOperationException(SR.Format(SR.InvalidOperation_UnexpectedNodeType, r.NodeType));
                }
                if (n != null)
                {
                    if (baseUri != null && baseUri != uri)
                    {
                        n.SetBaseUri(uri);
                    }
                    if (li != null && li.HasLineInfo())
                    {
                        n.SetLineInfo(li.LineNumber, li.LinePosition);
                    }
                    c.AddNodeSkipNotify(n);
                    n = null;
                }
            } while (r.Read());
        }
Пример #55
0
        static BindableProperty GetBindableProperty(Type elementType, string localName, IXmlLineInfo lineInfo,
                                                    bool throwOnError = false)
        {
            var bindableFieldInfo =
                elementType.GetFields(BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy).FirstOrDefault(fi => fi.Name == localName + "Property");

            Exception exception = null;

            if (exception == null && bindableFieldInfo == null)
            {
                exception =
                    new XamlParseException(
                        Format("BindableProperty {0} not found on {1}", localName + "Property", elementType.Name), lineInfo);
            }

            if (exception == null)
            {
                return(bindableFieldInfo.GetValue(null) as BindableProperty);
            }
            if (throwOnError)
            {
                throw exception;
            }
            return(null);
        }
Пример #56
0
 internal XmlException(int res, string arg, IXmlLineInfo lineInfo, string sourceUri)
     : this(res, new string[1] {
     arg
 }, lineInfo, sourceUri)
 {
 }
Пример #57
0
        private void ProcessAttribute(XPathNavigator nav)
        {
            // skip attributes from non-default namespace
            if (nav.NamespaceURI != string.Empty)
            {
                return;
            }

            string value = nav.Value;

            switch (nav.LocalName)
            {
            case "cdata-section-elements":
                if (value.Length > 0)
                {
                    cdSectsList.AddRange(XslNameUtil.FromListString(value, nav));
                }
                break;

            case "method":
                if (value.Length == 0)
                {
                    break;
                }

                switch (value)
                {
                case "xml":
                    method = OutputMethod.XML;
                    break;

                case "html":
                    omitXmlDeclaration = true;
                    method             = OutputMethod.HTML;
                    break;

                case "text":
                    omitXmlDeclaration = true;
                    method             = OutputMethod.Text;
                    break;

                default:
                    method       = OutputMethod.Custom;
                    customMethod = XslNameUtil.FromString(value, nav);
                    if (customMethod.Namespace == String.Empty)
                    {
                        IXmlLineInfo li = nav as IXmlLineInfo;
                        throw new XsltCompileException(new ArgumentException(
                                                           "Invalid output method value: '" + value + "'. It" +
                                                           " must be either 'xml' or 'html' or 'text' or QName."),
                                                       nav.BaseURI,
                                                       li != null ? li.LineNumber : 0,
                                                       li != null ? li.LinePosition : 0);
                    }
                    break;
                }
                break;

            case "version":
                if (value.Length > 0)
                {
                    this.version = value;
                }
                break;

            case "encoding":
                if (value.Length > 0)
                {
                    try {
                        this.encoding = System.Text.Encoding.GetEncoding(value);
                    } catch (ArgumentException) {
                        // MS.NET just leaves the default encoding when encoding is unknown
                    } catch (NotSupportedException) {
                        // Workaround for a bug in System.Text, it throws invalid exception
                    }
                }
                break;

            case "standalone":
                switch (value)
                {
                case "yes":
                    this.standalone = StandaloneType.YES;
                    break;

                case "no":
                    this.standalone = StandaloneType.NO;
                    break;

                default:
                    if (stylesheetVersion != "1.0")
                    {
                        break;
                    }

                    IXmlLineInfo li = nav as IXmlLineInfo;
                    throw new XsltCompileException(new XsltException(
                                                       "'" + value + "' is an invalid value for 'standalone'" +
                                                       " attribute.", (Exception)null),
                                                   nav.BaseURI,
                                                   li != null ? li.LineNumber : 0,
                                                   li != null ? li.LinePosition : 0);
                }
                break;

            case "doctype-public":
                this.doctypePublic = value;
                break;

            case "doctype-system":
                this.doctypeSystem = value;
                break;

            case "media-type":
                if (value.Length > 0)
                {
                    this.mediaType = value;
                }
                break;

            case "omit-xml-declaration":
                switch (value)
                {
                case "yes":
                    this.omitXmlDeclaration = true;
                    break;

                case "no":
                    this.omitXmlDeclaration = false;
                    break;

                default:
                    if (stylesheetVersion != "1.0")
                    {
                        break;
                    }

                    IXmlLineInfo li = nav as IXmlLineInfo;
                    throw new XsltCompileException(new XsltException(
                                                       "'" + value + "' is an invalid value for 'omit-xml-declaration'" +
                                                       " attribute.", (Exception)null),
                                                   nav.BaseURI,
                                                   li != null ? li.LineNumber : 0,
                                                   li != null ? li.LinePosition : 0);
                }
                break;

            case "indent":
                indent = value;
                if (stylesheetVersion != "1.0")
                {
                    break;
                }
                switch (value)
                {
                case "yes":
                case "no":
                    break;

                default:
                    switch (method)
                    {
                    case OutputMethod.Custom:
                        break;

                    default:
                        throw new XsltCompileException(String.Format("Unexpected 'indent' attribute value in 'output' element: '{0}'", value), null, nav);
                    }
                    break;
                }
                break;

            default:
                if (stylesheetVersion != "1.0")
                {
                    break;
                }

                IXmlLineInfo xli = nav as IXmlLineInfo;
                throw new XsltCompileException(new XsltException(
                                                   "'" + nav.LocalName + "' is an invalid attribute for 'output'" +
                                                   " element.", (Exception)null),
                                               nav.BaseURI,
                                               xli != null ? xli.LineNumber : 0,
                                               xli != null ? xli.LinePosition : 0);
            }
        }
Пример #58
0
 internal XmlException(string res, String arg, IXmlLineInfo lineInfo) :
     this(res, new string[] { arg }, lineInfo)
 {
 }
Пример #59
0
 internal XmlException(int res, string[] args, IXmlLineInfo lineInfo, string sourceUri)
     : this(res, args, (Exception)null, lineInfo == null ? 0 : lineInfo.LineNumber, lineInfo == null ? 0 : lineInfo.LinePosition, sourceUri)
 {
 }
        public object ProvideValue(IServiceProvider serviceProvider)
        {
            if (Android == null &&
                GTK == null &&
                iOS == null &&
                macOS == null &&
                Tizen == null &&
                UWP == null &&
                WPF == null &&
                Default == null)
            {
                var lineInfo = serviceProvider?.GetService <IXmlLineInfoProvider>()?.XmlLineInfo ?? new XmlLineInfo();
                throw new XamlParseException("OnPlatformExtension requires a non-null value to be specified for at least one platform or Default.", lineInfo);
            }

            var valueProvider = serviceProvider?.GetService <IProvideValueTarget>() ?? throw new ArgumentException();

            BindableProperty bp;
            PropertyInfo     pi           = null;
            Type             propertyType = null;

            if (valueProvider.TargetObject is Setter setter)
            {
                bp = setter.Property;
            }
            else
            {
                bp = valueProvider.TargetProperty as BindableProperty;
                pi = valueProvider.TargetProperty as PropertyInfo;
            }
            propertyType = bp?.ReturnType
                           ?? pi?.PropertyType
                           ?? throw new InvalidOperationException("Cannot determine property to provide the value for.");

            var value = GetValue();
            var info  = propertyType.GetTypeInfo();

            if (value == null && info.IsValueType)
            {
                return(Activator.CreateInstance(propertyType));
            }

            if (Converter != null)
            {
                return(Converter.Convert(value, propertyType, ConverterParameter, CultureInfo.CurrentUICulture));
            }

            var converterProvider = serviceProvider?.GetService <IValueConverterProvider>();

            if (converterProvider != null)
            {
                MemberInfo minforetriever()
                {
                    if (pi != null)
                    {
                        return(pi);
                    }

                    MemberInfo minfo = null;

                    try {
                        minfo = bp.DeclaringType.GetRuntimeProperty(bp.PropertyName);
                    }
                    catch (AmbiguousMatchException e) {
                        IXmlLineInfo lineInfo = serviceProvider.GetService(typeof(IXmlLineInfoProvider)) is IXmlLineInfoProvider lineInfoProvider ? lineInfoProvider.XmlLineInfo : new XmlLineInfo();
                        throw new XamlParseException($"Multiple properties with name '{bp.DeclaringType}.{bp.PropertyName}' found.", lineInfo, innerException: e);
                    }
                    if (minfo != null)
                    {
                        return(minfo);
                    }
                    try {
                        return(bp.DeclaringType.GetRuntimeMethod("Get" + bp.PropertyName, new[] { typeof(BindableObject) }));
                    }
                    catch (AmbiguousMatchException e) {
                        IXmlLineInfo lineInfo = serviceProvider.GetService(typeof(IXmlLineInfoProvider)) is IXmlLineInfoProvider lineInfoProvider ? lineInfoProvider.XmlLineInfo : new XmlLineInfo();
                        throw new XamlParseException($"Multiple methods with name '{bp.DeclaringType}.Get{bp.PropertyName}' found.", lineInfo, innerException: e);
                    }
                }

                return(converterProvider.Convert(value, propertyType, minforetriever, serviceProvider));
            }
            return(value.ConvertTo(propertyType, () => pi, serviceProvider));
        }