// 1. name and public must be present // public and system must be anyURI internal override int Compile(ValidationEventHandler h, XmlSchema schema) { // If this is already compiled this time, simply skip. if (CompilationId == schema.CompilationId) return 0; if(Name == null) error(h,"Required attribute name must be present"); else if(!XmlSchemaUtil.CheckNCName(this.name)) error(h,"attribute name must be NCName"); else qualifiedName = new XmlQualifiedName(Name, AncestorSchema.TargetNamespace); if(Public==null) error(h,"public must be present"); else if(!XmlSchemaUtil.CheckAnyUri(Public)) error(h,"public must be anyURI"); if(system != null && !XmlSchemaUtil.CheckAnyUri(system)) error(h,"system must be present and of Type anyURI"); XmlSchemaUtil.CompileID(Id,this,schema.IDCollection,h); return errorCount; }
public static void AddToTable (XmlSchemaObjectTable table, XmlSchemaObject obj, XmlQualifiedName qname, ValidationEventHandler h) { if (table.Contains (qname)) { // FIXME: This logic unexpectedly allows // one redefining item and two or more redefining items. // FIXME: redefining item is not simple replacement, // but much more complex stuff. if (obj.isRedefineChild) { // take precedence. if (obj.redefinedObject != null) obj.error (h, String.Format ("Named item {0} was already contained in the schema object table.", qname)); else obj.redefinedObject = table [qname]; table.Set (qname, obj); } else if (table [qname].isRedefineChild) { if (table [qname].redefinedObject != null) obj.error (h, String.Format ("Named item {0} was already contained in the schema object table.", qname)); else table [qname].redefinedObject = obj; return; // never add to the table. } else if (StrictMsCompliant) { table.Set (qname, obj); } else obj.error (h, String.Format ("Named item {0} was already contained in the schema object table. {1}", qname, "Consider setting MONO_STRICT_MS_COMPLIANT to 'yes' to mimic MS implementation.")); } else table.Set (qname, obj); }
public Preprocessor(XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler, XmlSchemaCompilationSettings compilationSettings) : base(nameTable, schemaNames, eventHandler, compilationSettings) { _referenceNamespaces = new Hashtable(); _processedExternals = new Hashtable(); _lockList = new SortedList(); }
public static void Validate( XmlTextReader treader, ValidationEventHandler validationHandler ) { XmlReaderSettings validator = null; try { validator = new XmlReaderSettings(); XmlSchema schema = GetSchema(); validator.Schemas.Add(schema); validator.ValidationType = ValidationType.Schema; if (validationHandler!=null) validator.ValidationEventHandler += validationHandler; else validator.ValidationEventHandler += new ValidationEventHandler(ValidationEvent); XmlReader objXmlReader = XmlReader.Create(treader, validator); while( objXmlReader.Read() ) {} } catch( Exception ex ) { Console.WriteLine(ex.ToString()) ; throw ; } finally { if (validationHandler!=null) validator.ValidationEventHandler -= validationHandler; else validator.ValidationEventHandler -= new ValidationEventHandler(ValidationEvent); } }
/// <summary> /// Parses the xml file into a list of polling venues /// </summary> /// <param name="xDocument">The xml file</param> /// <param name="notifier">Event subscriber if validation of the xml file fails</param> /// <returns>A list of polling venues</returns> private List<PollingVenue> LoadVenues(XDocument xDocument, ValidationEventHandler notifier) { if (!this.ValidateXmlFile(xDocument, notifier)){ var pollingVenuesElements = from n in xDocument.Descendants("PollingVenue") select n; List<PollingVenue> pollingVenues = new List<PollingVenue>(); foreach (var xElement in pollingVenuesElements){ Address pollingVenueAddress = new Address{ Name = xElement.Element("Name").Value, Street = xElement.Element("Street").Value, City = xElement.Element("City").Value }; Address municipalityAddress = new Address{ Name = xElement.Parent.Parent.Element("Name").Value, Street = xElement.Parent.Parent.Element("Street").Value, City = xElement.Parent.Parent.Element("City").Value }; PollingVenue pollingVenue = new PollingVenue{ Persons = this.LoadPersons(xElement), PollingVenueAddress = pollingVenueAddress, MunicipalityAddress = municipalityAddress }; pollingVenues.Add(pollingVenue); } return pollingVenues; } return null; }
public static WebReferenceOptions Read(XmlReader xmlReader, ValidationEventHandler validationEventHandler) { WebReferenceOptions options; XmlValidatingReader reader = new XmlValidatingReader(xmlReader) { ValidationType = ValidationType.Schema }; if (validationEventHandler != null) { reader.ValidationEventHandler += validationEventHandler; } else { reader.ValidationEventHandler += new ValidationEventHandler(WebReferenceOptions.SchemaValidationHandler); } reader.Schemas.Add(Schema); webReferenceOptionsSerializer serializer = new webReferenceOptionsSerializer(); try { options = (WebReferenceOptions) serializer.Deserialize(reader); } catch (Exception exception) { throw exception; } finally { reader.Close(); } return options; }
/// <summary> /// Reads an XML Schema from the supplied TextReader. /// </summary> /// <param name="reader">The TextReader containing the XML Schema to read.</param> /// <param name="validationEventHandler">The validation event handler that receives information about the XML Schema syntax errors.</param> /// <returns>The XmlSchema object representing the XML Schema.</returns> public static new XmlSchema Read(TextReader reader, ValidationEventHandler validationEventHandler) { using (XmlReader xr = XmlReader.Create(reader, SafeXmlSchema.defaultSettings)) { return XmlSchema.Read(xr, validationEventHandler); } }
internal override int Compile(ValidationEventHandler h, XmlSchema schema) { // If this is already compiled this time, simply skip. if (CompilationId == schema.CompilationId) return 0; XmlSchemaUtil.CompileID(Id, this, schema.IDCollection, h); CompileOccurence (h, schema); if (Items.Count == 0) this.warn (h, "Empty choice is unsatisfiable if minOccurs not equals to 0"); foreach(XmlSchemaObject obj in Items) { if(obj is XmlSchemaElement || obj is XmlSchemaGroupRef || obj is XmlSchemaChoice || obj is XmlSchemaSequence || obj is XmlSchemaAny) { errorCount += obj.Compile(h,schema); } else error(h, "Invalid schema object was specified in the particles of the choice model group."); } this.CompilationId = schema.CompilationId; return errorCount; }
public override bool CheckValidity(XmlSchemaSet schemas, ValidationEventHandler validationEventHandler) { XmlDocument source; if (this.source.NodeType == XmlNodeType.Document) { source = (XmlDocument) this.source; } else { source = this.source.OwnerDocument; if (schemas != null) { throw new ArgumentException(Res.GetString("XPathDocument_SchemaSetNotAllowed", (object[]) null)); } } if ((schemas == null) && (source != null)) { schemas = source.Schemas; } if ((schemas == null) || (schemas.Count == 0)) { throw new InvalidOperationException(Res.GetString("XmlDocument_NoSchemaInfo")); } DocumentSchemaValidator validator = new DocumentSchemaValidator(source, schemas, validationEventHandler) { PsviAugmentation = false }; return validator.Validate(this.source); }
public Boolean Validate() { XmlTextReader txtreader = null; try { txtreader = new XmlTextReader(fileName); XmlDocument doc = new XmlDocument(); doc.Load(txtreader); ValidationEventHandler eventHandler = new ValidationEventHandler(ValidationEventHandler); doc.Validate(eventHandler); } catch (IOException e) { LogBookController.Instance.addLogLine("Error accessing chapter files. Probably doesn't exist. \n" + e, LogMessageCategories.Error); return false; } catch (XmlException e) { LogBookController.Instance.addLogLine("Error inside chapters XML file, trying again.\n" + e, LogMessageCategories.Error); return false; } finally { txtreader.Close(); } return true; }
///<remarks> /// 1. Content must be present and one of restriction or extention ///</remarks> internal override int Compile(ValidationEventHandler h, XmlSchema schema) { // If this is already compiled this time, simply skip. if (CompilationId == schema.CompilationId) return 0; if(Content == null) { error(h, "Content must be present in a simpleContent"); } else { if(Content is XmlSchemaSimpleContentRestriction) { XmlSchemaSimpleContentRestriction xscr = (XmlSchemaSimpleContentRestriction) Content; errorCount += xscr.Compile(h, schema); } else if(Content is XmlSchemaSimpleContentExtension) { XmlSchemaSimpleContentExtension xsce = (XmlSchemaSimpleContentExtension) Content; errorCount += xsce.Compile(h, schema); } else error(h,"simpleContent can't have any value other than restriction or extention"); } XmlSchemaUtil.CompileID(Id,this, schema.IDCollection,h); this.CompilationId = schema.CompilationId; return errorCount; }
: this(nameTable, schemaNames, eventHandler, new XmlSchemaCompilationSettings()) {} //Use the default for XmlSchemaCollection public BaseProcessor(XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler, XmlSchemaCompilationSettings compilationSettings) { Debug.Assert(nameTable != null); this.nameTable = nameTable; this.schemaNames = schemaNames; this.eventHandler = eventHandler; this.compilationSettings = compilationSettings; NsXml = nameTable.Add(XmlReservedNs.NsXml); }
/// <summary> /// Initializes the type generator /// </summary> /// <param name="useXmlSerializerImporter">if set to <c>true</c> [use XML serializer importer].</param> /// <param name="targetNamespace">The target namespace.</param> public XmlSchemaTypeGenerator(bool useXmlSerializerImporter, string targetNamespace) { Guard.ArgumentNotNull(targetNamespace, "targetNamespace"); this.validationEventHandler = new ValidationEventHandler(OnSchemasValidation); this.useXmlSerializerImporter = useXmlSerializerImporter; this.targetNamespace = targetNamespace; }
public static WebReferenceOptions Read(TextReader reader, ValidationEventHandler validationEventHandler) { XmlTextReader xmlReader = new XmlTextReader(reader) { XmlResolver = null, DtdProcessing = DtdProcessing.Prohibit }; return Read(xmlReader, validationEventHandler); }
public BaseProcessor(XmlNameTable nameTable, System.Xml.Schema.SchemaNames schemaNames, ValidationEventHandler eventHandler, XmlSchemaCompilationSettings compilationSettings) { this.nameTable = nameTable; this.schemaNames = schemaNames; this.eventHandler = eventHandler; this.compilationSettings = compilationSettings; this.NsXml = nameTable.Add("http://www.w3.org/XML/1998/namespace"); }
/// <summary> /// Validate gbxml file against the 6.01 schema XSD /// </summary> private void ValidategbXML_601() { XmlDocument xml = new XmlDocument(); xml.Load(@"data/TestgbXML.xml"); xml.Schemas.Add(null, @"data/GreenBuildingXML_Ver6.01.xsd"); ValidationEventHandler eventHandler = new ValidationEventHandler(ValidationEventHandler); xml.Validate(eventHandler); }
internal override int Compile(ValidationEventHandler h, XmlSchema schema) { // If this is already compiled this time, simply skip. if (CompilationId == schema.CompilationId) return 0; this.CompilationId = schema.CompilationId; return 0; }
static XmlReader CreateValidatingReader(Stream stream, XmlSchemaSet schemas, ValidationEventHandler eventHandler) { XmlReaderSettings settings = new XmlReaderSettings(); settings.Schemas.Add(schemas); settings.ValidationType = ValidationType.Schema; if (eventHandler != null) settings.ValidationEventHandler += eventHandler; return XmlReader.Create(stream, settings); }
public Parser(SchemaType schemaType, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler) { this.schemaType = schemaType; this.nameTable = nameTable; this.schemaNames = schemaNames; this.eventHandler = eventHandler; this.xmlResolver = System.Xml.XmlConfiguration.XmlReaderSection.CreateDefaultResolver(); processMarkup = true; dummyDocument = new XmlDocument(); }
public static void ValidateXmlDoc(System.Xml.XmlDocument xmlDocument, string[] sSchemaFiles) { foreach (string sSchema in sSchemaFiles) { xmlDocument.Schemas.Add(null, sSchema); } System.Xml.Schema.ValidationEventHandler validationHandler = new ValidationEventHandler(ValidationEvent); xmlDocument.Validate(validationHandler); }
/// <summary> /// Can you load this xml file, and parse it to a list of polling venues? /// </summary> /// <param name="path">The path of the file</param> /// <param name="notifier">Event subscriber if validation of the xml file fails</param> /// <returns>A list of polling venues</returns> public List<PollingVenue> GetPollingVenues(string path, ValidationEventHandler notifier) { Contract.Requires(path != null); Contract.Requires(notifier != null); Contract.Requires(File.Exists(path)); Contract.Requires(Path.GetExtension(path).Equals(".xml")); return this.LoadVenues(XDocument.Load(path), notifier); }
static XmlReader CreateValidatingReader (Stream stream, XmlSchemaCollection schemas, ValidationEventHandler eventHandler) { XmlValidatingReader reader = new XmlValidatingReader (new XmlTextReader (stream)); reader.Schemas.Add (schemas); reader.ValidationType = ValidationType.Schema; if (eventHandler != null) reader.ValidationEventHandler += eventHandler; return reader; }
public Parser(SchemaType schemaType, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler) { this.schemaType = schemaType; this.nameTable = nameTable; this.schemaNames = schemaNames; this.eventHandler = eventHandler; this.xmlResolver = new XmlUrlResolver(); processMarkup = true; dummyDocument = new XmlDocument(); }
public BaseValidator(XmlValidatingReaderImpl reader, XmlSchemaCollection schemaCollection, ValidationEventHandler eventHandler) { Debug.Assert(schemaCollection == null || schemaCollection.NameTable == reader.NameTable); this.reader = reader; this.schemaCollection = schemaCollection; this.eventHandler = eventHandler; nameTable = reader.NameTable; positionInfo = PositionInfo.GetPositionInfo(reader); elementName = new XmlQualifiedName(); }
//<documentation // source = anyURI // xml:lang = language> // Content: ({any})* //</documentation> internal static XmlSchemaDocumentation Read(XmlSchemaReader reader, ValidationEventHandler h, out bool skip) { skip = false; XmlSchemaDocumentation doc = new XmlSchemaDocumentation(); reader.MoveToElement(); if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != "documentation") { error(h,"Should not happen :1: XmlSchemaDocumentation.Read, name="+reader.Name,null); reader.Skip(); return null; } doc.LineNumber = reader.LineNumber; doc.LinePosition = reader.LinePosition; doc.SourceUri = reader.BaseURI; while(reader.MoveToNextAttribute()) { if(reader.Name == "source") { doc.source = reader.Value; } else if(reader.Name == "xml:lang") { doc.language = reader.Value; } else { error(h,reader.Name + " is not a valid attribute for documentation",null); } } reader.MoveToElement(); if(reader.IsEmptyElement) { doc.Markup = new XmlNode[0]; return doc; } //Content {any}* XmlDocument xmldoc = new XmlDocument(); xmldoc.AppendChild(xmldoc.ReadNode(reader)); XmlNode root = xmldoc.FirstChild; if(root != null && root.ChildNodes != null) { doc.Markup = new XmlNode[root.ChildNodes.Count]; for(int i=0;i<root.ChildNodes.Count;i++) { doc.Markup[i] = root.ChildNodes[i]; } } if(reader.NodeType == XmlNodeType.Element || reader.NodeType == XmlNodeType.EndElement) skip = true; return doc; }
public Parser(SchemaType schemaType, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler) { _schemaType = schemaType; _nameTable = nameTable; _schemaNames = schemaNames; _eventHandler = eventHandler; _xmlResolver = null; _processMarkup = true; _dummyDocument = new XmlDocument(); }
public XmlSchemaReader(XmlReader reader,ValidationEventHandler handler) { this.reader = reader; this.handler = handler; if(reader is IXmlLineInfo) { IXmlLineInfo info = (IXmlLineInfo)reader; hasLineInfo = info.HasLineInfo(); } }
public BaseValidator(BaseValidator other) { reader = other.reader; schemaCollection = other.schemaCollection; eventHandler = other.eventHandler; nameTable = other.nameTable; schemaNames = other.schemaNames; positionInfo = other.positionInfo; xmlResolver = other.xmlResolver; baseUri = other.baseUri; elementName = other.elementName; }
public void Compile (string nss, ValidationEventHandler h, XmlSchema schema) { if (SkipCompile) return; // used by XmlSchemaAny.AnyTypeContent. Reset (); int nscount = 0; string actualNamespace = nss == null ? "##any" : nss; string[] nslist = XmlSchemaUtil.SplitList(actualNamespace); for (int i = 0; i < nslist.Length; i++) { string ns = nslist [i]; switch(ns) { case "##any": if (HasValueAny) xsobj.error (h, "Multiple specification of ##any was found."); nscount |= 1; HasValueAny = true; break; case "##other": if (HasValueOther) xsobj.error (h, "Multiple specification of ##other was found."); nscount |= 2; HasValueOther = true; break; case "##targetNamespace": if (HasValueTargetNamespace) xsobj.error (h, "Multiple specification of ##targetNamespace was found."); nscount |= 4; HasValueTargetNamespace = true; break; case "##local": if (HasValueLocal) xsobj.error (h, "Multiple specification of ##local was found."); nscount |= 8; HasValueLocal = true; break; default: if(!XmlSchemaUtil.CheckAnyUri(ns)) xsobj.error(h,"the namespace is not a valid anyURI"); else if (ResolvedNamespaces.Contains (ns)) xsobj.error (h, "Multiple specification of '" + ns + "' was found."); else { nscount |= 16; ResolvedNamespaces.Add (ns); } break; } } if((nscount&1) == 1 && nscount != 1) xsobj.error (h, "##any if present must be the only namespace attribute"); if((nscount&2) == 2 && nscount != 2) xsobj.error (h, "##other if present must be the only namespace attribute"); }
/// <remarks> /// 1. name must be present /// 2. selector and field must be present /// 3. refer must be present /// </remarks> internal override int Compile(ValidationEventHandler h, XmlSchema schema) { base.Compile(h, schema); if(refer == null || refer.IsEmpty) error(h,"refer must be present"); else if(!XmlSchemaUtil.CheckQName(refer)) error(h,"Refer is not a valid XmlQualifiedName"); return errorCount; }
public void Compile(ValidationEventHandler validationEventHandler, System.Xml.XmlResolver resolver) { }
internal override void CheckRecursion(Stack stack, ValidationEventHandler h, XmlSchema schema) { // do nothing }
/// <include file='doc\XmlSchemas.uex' path='docs/doc[@for="XmlSchemas.Compile"]/*' /> public void Compile(ValidationEventHandler handler, bool fullCompile) { if (isCompiled) { return; } foreach (XmlSchema s in delayedSchemas.Values) { Merge(s); } delayedSchemas.Clear(); if (fullCompile) { schemaSet = new XmlSchemaSet(); schemaSet.XmlResolver = null; schemaSet.ValidationEventHandler += handler; foreach (XmlSchema s in References.Values) { schemaSet.Add(s); } int schemaCount = schemaSet.Count; foreach (XmlSchema s in List) { if (!SchemaSet.Contains(s)) { schemaSet.Add(s); schemaCount++; } } if (!SchemaSet.Contains(XmlSchema.Namespace)) { AddReference(XsdSchema); schemaSet.Add(XsdSchema); schemaCount++; } if (!SchemaSet.Contains(XmlReservedNs.NsXml)) { AddReference(XmlSchema); schemaSet.Add(XmlSchema); schemaCount++; } schemaSet.Compile(); schemaSet.ValidationEventHandler -= handler; isCompiled = schemaSet.IsCompiled && schemaCount == schemaSet.Count; } else { try { XmlNameTable nameTable = new System.Xml.NameTable(); Preprocessor prep = new Preprocessor(nameTable, new SchemaNames(nameTable), null); prep.XmlResolver = null; prep.SchemaLocations = new Hashtable(); prep.ChameleonSchemas = new Hashtable(); foreach (XmlSchema schema in SchemaSet.Schemas()) { prep.Execute(schema, schema.TargetNamespace, true); } } catch (XmlSchemaException e) { throw CreateValidationException(e, e.Message); } } }
/// <summary> /// Loads the RSS feedlist from the given URL and validates it against the schema. /// </summary> /// <param name="feedListUrl">The URL of the feedlist</param> /// <param name="veh">The event handler that should be invoked on the client if validation errors occur</param> /// <exception cref="XmlException">XmlException thrown if XML is not well-formed</exception> private void LoadFeedlist(string feedListUrl, ValidationEventHandler veh) { LoadFeedlist(SyncWebRequest.GetResponseStream(feedListUrl, null, UserAgent, Proxy), veh); SearchHandler.CheckIndex(); }
//<fractionDigits // fixed = boolean : false // id = ID // value = nonNegativeInteger // {any attributes with non-schema namespace . . .}> // Content: (annotation?) //</fractionDigits> internal static XmlSchemaFractionDigitsFacet Read(XmlSchemaReader reader, ValidationEventHandler h) { XmlSchemaFractionDigitsFacet fraction = new XmlSchemaFractionDigitsFacet(); reader.MoveToElement(); if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname) { error(h, "Should not happen :1: XmlSchemaFractionDigitsFacet.Read, name=" + reader.Name, null); reader.Skip(); return(null); } fraction.LineNumber = reader.LineNumber; fraction.LinePosition = reader.LinePosition; fraction.SourceUri = reader.BaseURI; while (reader.MoveToNextAttribute()) { if (reader.Name == "id") { fraction.Id = reader.Value; } else if (reader.Name == "fixed") { Exception innerex; fraction.IsFixed = XmlSchemaUtil.ReadBoolAttribute(reader, out innerex); if (innerex != null) { error(h, reader.Value + " is not a valid value for fixed attribute", innerex); } } else if (reader.Name == "value") { fraction.Value = reader.Value; } else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace) { error(h, reader.Name + " is not a valid attribute for " + xmlname, null); } else { XmlSchemaUtil.ReadUnhandledAttribute(reader, fraction); } } reader.MoveToElement(); if (reader.IsEmptyElement) { return(fraction); } // Content: (annotation?) int level = 1; while (reader.ReadNextElement()) { if (reader.NodeType == XmlNodeType.EndElement) { if (reader.LocalName != xmlname) { error(h, "Should not happen :2: XmlSchemaFractionDigitsFacet.Read, name=" + reader.Name, null); } break; } if (level <= 1 && reader.LocalName == "annotation") { level = 2; //Only one annotation XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h); if (annotation != null) { fraction.Annotation = annotation; } continue; } reader.RaiseInvalidElementError(); } return(fraction); }
internal bool ValidateSeqRecurseMapSumCommon(XmlSchemaGroupBase baseGroup, ValidationEventHandler h, XmlSchema schema, bool isLax, bool isMapAndSum, bool raiseError) { int index = 0; int baseIndex = 0; decimal baseOccured = 0; if (baseGroup.CompiledItems.Count == 0 && this.CompiledItems.Count > 0) { if (raiseError) { error(h, "Invalid particle derivation by restriction was found. base particle does not contain particles."); } return(false); } for (int i = 0; i < CompiledItems.Count; i++) { // get non-empty derived particle XmlSchemaParticle pd = null; while (this.CompiledItems.Count > index) { pd = ((XmlSchemaParticle)this.CompiledItems [index]); //.GetOptimizedParticle (false); if (pd != XmlSchemaParticle.Empty) // && pd.ValidatedMaxOccurs > 0) { break; } else { index++; } } if (index >= CompiledItems.Count) { if (raiseError) { error(h, "Invalid particle derivation by restriction was found. Cannot be mapped to base particle."); } return(false); } // get non-empty base particle XmlSchemaParticle pb = null; while (baseGroup.CompiledItems.Count > baseIndex) { pb = ((XmlSchemaParticle)baseGroup.CompiledItems [baseIndex]);//.GetOptimizedParticle (false); if (pb == XmlSchemaParticle.Empty && pb.ValidatedMaxOccurs > 0) { continue; } if (!pd.ValidateDerivationByRestriction(pb, h, schema, false)) { if (!isLax && !isMapAndSum && pb.MinOccurs > baseOccured && !pb.ValidateIsEmptiable()) { if (raiseError) { error(h, "Invalid particle derivation by restriction was found. Invalid sub-particle derivation was found."); } return(false); } else { baseOccured = 0; baseIndex++; } } else { baseOccured += pb.ValidatedMinOccurs; if (baseOccured >= baseGroup.ValidatedMaxOccurs) { baseOccured = 0; baseIndex++; } index++; break; } } } if (this.CompiledItems.Count > 0 && index != this.CompiledItems.Count) { if (raiseError) { error(h, "Invalid particle derivation by restriction was found. Extraneous derived particle was found."); } return(false); } if (!isLax && !isMapAndSum) { if (baseOccured > 0) { baseIndex++; } for (int i = baseIndex; i < baseGroup.CompiledItems.Count; i++) { XmlSchemaParticle p = baseGroup.CompiledItems [i] as XmlSchemaParticle; if (!p.ValidateIsEmptiable()) { if (raiseError) { error(h, "Invalid particle derivation by restriction was found. There is a base particle which does not have mapped derived particle and is not emptiable."); } return(false); } } } return(true); }
internal static XmlSchemaRedefine Read(XmlSchemaReader reader, ValidationEventHandler h) { XmlSchemaRedefine xmlSchemaRedefine = new XmlSchemaRedefine(); reader.MoveToElement(); if (reader.NamespaceURI != "http://www.w3.org/2001/XMLSchema" || reader.LocalName != "redefine") { XmlSchemaObject.error(h, "Should not happen :1: XmlSchemaRedefine.Read, name=" + reader.Name, null); reader.Skip(); return(null); } xmlSchemaRedefine.LineNumber = reader.LineNumber; xmlSchemaRedefine.LinePosition = reader.LinePosition; xmlSchemaRedefine.SourceUri = reader.BaseURI; while (reader.MoveToNextAttribute()) { if (reader.Name == "id") { xmlSchemaRedefine.Id = reader.Value; } else if (reader.Name == "schemaLocation") { xmlSchemaRedefine.SchemaLocation = reader.Value; } else if ((reader.NamespaceURI == string.Empty && reader.Name != "xmlns") || reader.NamespaceURI == "http://www.w3.org/2001/XMLSchema") { XmlSchemaObject.error(h, reader.Name + " is not a valid attribute for redefine", null); } else { XmlSchemaUtil.ReadUnhandledAttribute(reader, xmlSchemaRedefine); } } reader.MoveToElement(); if (reader.IsEmptyElement) { return(xmlSchemaRedefine); } while (reader.ReadNextElement()) { if (reader.NodeType == XmlNodeType.EndElement) { if (reader.LocalName != "redefine") { XmlSchemaObject.error(h, "Should not happen :2: XmlSchemaRedefine.Read, name=" + reader.Name, null); } break; } if (reader.LocalName == "annotation") { XmlSchemaAnnotation xmlSchemaAnnotation = XmlSchemaAnnotation.Read(reader, h); if (xmlSchemaAnnotation != null) { xmlSchemaRedefine.items.Add(xmlSchemaAnnotation); } } else if (reader.LocalName == "simpleType") { XmlSchemaSimpleType xmlSchemaSimpleType = XmlSchemaSimpleType.Read(reader, h); if (xmlSchemaSimpleType != null) { xmlSchemaRedefine.items.Add(xmlSchemaSimpleType); } } else if (reader.LocalName == "complexType") { XmlSchemaComplexType xmlSchemaComplexType = XmlSchemaComplexType.Read(reader, h); if (xmlSchemaComplexType != null) { xmlSchemaRedefine.items.Add(xmlSchemaComplexType); } } else if (reader.LocalName == "group") { XmlSchemaGroup xmlSchemaGroup = XmlSchemaGroup.Read(reader, h); if (xmlSchemaGroup != null) { xmlSchemaRedefine.items.Add(xmlSchemaGroup); } } else if (reader.LocalName == "attributeGroup") { XmlSchemaAttributeGroup xmlSchemaAttributeGroup = XmlSchemaAttributeGroup.Read(reader, h); if (xmlSchemaAttributeGroup != null) { xmlSchemaRedefine.items.Add(xmlSchemaAttributeGroup); } } else { reader.RaiseInvalidElementError(); } } return(xmlSchemaRedefine); }
public static void Validate(this XElement source, XmlSchemaObject partialValidationType, XmlSchemaSet schemas, ValidationEventHandler validationEventHandler, bool addSchemaInfo) { throw new NotImplementedException(); }
public static void Validate(this XAttribute source, XmlSchemaObject partialValidationType, XmlSchemaSet schemas, ValidationEventHandler validationEventHandler) { Validate(source, partialValidationType, schemas, validationEventHandler, false); }
/// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Read1"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public static XmlSchema Read(Stream stream, ValidationEventHandler validationEventHandler) { return(Read(new XmlTextReader(stream), validationEventHandler)); }
//<complexContent // id = ID // mixed = boolean // {any attributes with non-schema namespace . . .}> // Content: (annotation?, (restriction | extension)) //</complexContent> internal static XmlSchemaComplexContent Read(XmlSchemaReader reader, ValidationEventHandler h) { XmlSchemaComplexContent complex = new XmlSchemaComplexContent(); reader.MoveToElement(); if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname) { error(h, "Should not happen :1: XmlSchemaComplexContent.Read, name=" + reader.Name, null); reader.Skip(); return(null); } complex.LineNumber = reader.LineNumber; complex.LinePosition = reader.LinePosition; complex.SourceUri = reader.BaseURI; while (reader.MoveToNextAttribute()) { if (reader.Name == "id") { complex.Id = reader.Value; } else if (reader.Name == "mixed") { Exception innerex; complex.isMixed = XmlSchemaUtil.ReadBoolAttribute(reader, out innerex); if (innerex != null) { error(h, reader.Value + " is an invalid value for mixed", innerex); } } else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace) { error(h, reader.Name + " is not a valid attribute for complexContent", null); } else { XmlSchemaUtil.ReadUnhandledAttribute(reader, complex); } } reader.MoveToElement(); if (reader.IsEmptyElement) { return(complex); } //Content: (annotation?, (restriction | extension)) int level = 1; while (reader.ReadNextElement()) { if (reader.NodeType == XmlNodeType.EndElement) { if (reader.LocalName != xmlname) { error(h, "Should not happen :2: XmlSchemaComplexContent.Read, name=" + reader.Name, null); } break; } if (level <= 1 && reader.LocalName == "annotation") { level = 2; //Only one annotation XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h); if (annotation != null) { complex.Annotation = annotation; } continue; } if (level <= 2) { if (reader.LocalName == "restriction") { level = 3; XmlSchemaComplexContentRestriction restriction = XmlSchemaComplexContentRestriction.Read(reader, h); if (restriction != null) { complex.content = restriction; } continue; } if (reader.LocalName == "extension") { level = 3; XmlSchemaComplexContentExtension extension = XmlSchemaComplexContentExtension.Read(reader, h); if (extension != null) { complex.content = extension; } continue; } } reader.RaiseInvalidElementError(); } return(complex); }
/// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Read"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public static XmlSchema Read(TextReader reader, ValidationEventHandler validationEventHandler) { return(Read(new XmlTextReader(reader), validationEventHandler)); }
#pragma warning disable 618 internal bool CompileSchema(XmlSchemaCollection xsc, XmlResolver resolver, SchemaInfo schemaInfo, string ns, ValidationEventHandler validationEventHandler, XmlNameTable nameTable, bool CompileContentModel) { //Need to lock here to prevent multi-threading problems when same schema is added to set and compiled lock (this) { //Preprocessing SchemaCollectionPreprocessor prep = new SchemaCollectionPreprocessor(nameTable, null, validationEventHandler); prep.XmlResolver = resolver; if (!prep.Execute(this, ns, true, xsc)) { return(false); } //Compilation SchemaCollectionCompiler compiler = new SchemaCollectionCompiler(nameTable, validationEventHandler); _isCompiled = compiler.Execute(this, schemaInfo, CompileContentModel); this.SetIsCompiled(_isCompiled); return(_isCompiled); } }
/* * internal new void error(ValidationEventHandler handle, string message) * { * errorCount++; * ValidationHandler.RaiseValidationError(handle, this, message); * } */ //<key // id = ID // name = NCName // refer = QName // {any attributes with non-schema namespace . . .}> // Content: (annotation?, (selector, field+)) //</key> internal static XmlSchemaKeyref Read(XmlSchemaReader reader, ValidationEventHandler h) { XmlSchemaKeyref keyref = new XmlSchemaKeyref(); reader.MoveToElement(); if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname) { error(h, "Should not happen :1: XmlSchemaKeyref.Read, name=" + reader.Name, null); reader.Skip(); return(null); } keyref.LineNumber = reader.LineNumber; keyref.LinePosition = reader.LinePosition; keyref.SourceUri = reader.BaseURI; while (reader.MoveToNextAttribute()) { if (reader.Name == "id") { keyref.Id = reader.Value; } else if (reader.Name == "name") { keyref.Name = reader.Value; } else if (reader.Name == "refer") { Exception innerex; keyref.refer = XmlSchemaUtil.ReadQNameAttribute(reader, out innerex); if (innerex != null) { error(h, reader.Value + " is not a valid value for refer attribute", innerex); } } else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace) { error(h, reader.Name + " is not a valid attribute for keyref", null); } else { XmlSchemaUtil.ReadUnhandledAttribute(reader, keyref); } } reader.MoveToElement(); if (reader.IsEmptyElement) { return(keyref); } // Content: annotation?, selector, field+ int level = 1; while (reader.ReadNextElement()) { if (reader.NodeType == XmlNodeType.EndElement) { if (reader.LocalName != xmlname) { error(h, "Should not happen :2: XmlSchemaKeyref.Read, name=" + reader.Name, null); } break; } if (level <= 1 && reader.LocalName == "annotation") { level = 2; //Only one annotation XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h); if (annotation != null) { keyref.Annotation = annotation; } continue; } if (level <= 2 && reader.LocalName == "selector") { level = 3; XmlSchemaXPath selector = XmlSchemaXPath.Read(reader, h, "selector"); if (selector != null) { keyref.Selector = selector; } continue; } if (level <= 3 && reader.LocalName == "field") { level = 3; if (keyref.Selector == null) { error(h, "selector must be defined before field declarations", null); } XmlSchemaXPath field = XmlSchemaXPath.Read(reader, h, "field"); if (field != null) { keyref.Fields.Add(field); } continue; } reader.RaiseInvalidElementError(); } return(keyref); }
public void Compile(ValidationEventHandler validationEventHandler) { }
public static void Validate(this XAttribute source, XmlSchemaObject partialValidationType, XmlSchemaSet schemas, ValidationEventHandler validationEventHandler, bool addSchemaInfo) { if (source == null) { throw new ArgumentNullException("source"); } if (schemas == null) { throw new ArgumentNullException("schemas"); } var nsmgr = new XmlNamespaceManager(new NameTable()); var v = new XmlSchemaValidator(nsmgr.NameTable, schemas, nsmgr, XmlSchemaValidationFlags.None); if (validationEventHandler != null) { v.ValidationEventHandler += validationEventHandler; } if (partialValidationType != null) { v.Initialize(partialValidationType); } else { v.Initialize(); } var xi = addSchemaInfo ? new XmlSchemaInfo() : null; v.ValidateAttribute(source.Name.LocalName, source.Name.NamespaceName, source.Value, xi); }
public static XmlSchema Read(System.IO.Stream stream, ValidationEventHandler validationEventHandler) { }
public static void Validate(this XDocument source, XmlSchemaSet schemas, ValidationEventHandler validationEventHandler) { Validate(source, schemas, validationEventHandler, false); }
internal bool ValidateRecurse(XmlSchemaGroupBase baseGroup, ValidationEventHandler h, XmlSchema schema, bool raiseError) { return(ValidateSeqRecurseMapSumCommon(baseGroup, h, schema, false, false, raiseError)); }
// <group // id = ID // ref = QName // minOccurs = ? : 1 // maxOccurs = ? : 1> // Content: (annotation?) // </group> internal static XmlSchemaGroupRef Read(XmlSchemaReader reader, ValidationEventHandler h) { XmlSchemaGroupRef groupref = new XmlSchemaGroupRef(); reader.MoveToElement(); if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname) { error(h, "Should not happen :1: XmlSchemaGroup.Read, name=" + reader.Name, null); reader.Skip(); return(null); } groupref.LineNumber = reader.LineNumber; groupref.LinePosition = reader.LinePosition; groupref.SourceUri = reader.BaseURI; while (reader.MoveToNextAttribute()) { if (reader.Name == "id") { groupref.Id = reader.Value; } else if (reader.Name == "ref") { Exception innerex; groupref.refName = XmlSchemaUtil.ReadQNameAttribute(reader, out innerex); if (innerex != null) { error(h, reader.Value + " is not a valid value for ref attribute", innerex); } } else if (reader.Name == "maxOccurs") { try { groupref.MaxOccursString = reader.Value; } catch (Exception e) { error(h, reader.Value + " is an invalid value for maxOccurs", e); } } else if (reader.Name == "minOccurs") { try { groupref.MinOccursString = reader.Value; } catch (Exception e) { error(h, reader.Value + " is an invalid value for minOccurs", e); } } else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace) { error(h, reader.Name + " is not a valid attribute for group", null); } else { XmlSchemaUtil.ReadUnhandledAttribute(reader, groupref); } } reader.MoveToElement(); if (reader.IsEmptyElement) { return(groupref); } // Content: (annotation?) int level = 1; while (reader.ReadNextElement()) { if (reader.NodeType == XmlNodeType.EndElement) { if (reader.LocalName != xmlname) { error(h, "Should not happen :2: XmlSchemaGroupRef.Read, name=" + reader.Name, null); } break; } if (level <= 1 && reader.LocalName == "annotation") { level = 2; //Only one annotation XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h); if (annotation != null) { groupref.Annotation = annotation; } continue; } reader.RaiseInvalidElementError(); } return(groupref); }
/// <summary> /// Loads the RSS feedlist from the given URL and validates it against the schema. /// </summary> /// <param name="xmlStream">The XML Stream of a feedlist to load</param> /// <param name="veh">The event handler that should be invoked on the client if validation errors occur. NOT USED.</param> /// <exception cref="XmlException">XmlException thrown if XML is not well-formed</exception> private void LoadFeedlist(Stream xmlStream, ValidationEventHandler veh) { var context = new XmlParserContext(null, new RssBanditXmlNamespaceResolver(), null, XmlSpace.None); XmlReader reader = new RssBanditXmlReader(xmlStream, XmlNodeType.Document, context); validationErrorOccured = false; //convert XML to objects XmlSerializer serializer = XmlHelper.SerializerCache.GetSerializer(typeof(feeds)); var myFeeds = (feeds)serializer.Deserialize(reader); reader.Close(); // reset migration properties dictionary: MigrationProperties.Clear(); //copy over category info if we are importing a new feed if (myFeeds.categories != null) { foreach (var cat in myFeeds.categories) { string cat_trimmed = cat.Value.Trim(); if (!categories.ContainsKey(cat_trimmed)) { cat.Value = cat_trimmed; categories.Add(cat_trimmed, cat); } } } //copy feeds over if we are importing a new feed if (myFeeds.feed != null) { foreach (var f in myFeeds.feed) { if (feedsTable.ContainsKey(f.link) == false) { Uri uri; if (Uri.TryCreate(f.link, UriKind.Absolute, out uri)) { // CLR 2.0 Uri does not like "news:" scheme, so we // switch it to "nntp:" (see http://msdn2.microsoft.com/en-us/library/system.uri.scheme.aspx) if (NntpWebRequest.NewsUriScheme.Equals(uri.Scheme)) { f.link = NntpWebRequest.NntpUriScheme + uri.CanonicalizedUri().Substring(uri.Scheme.Length); } else { f.link = uri.CanonicalizedUri(); } } else { // bad uri: continue; } // test again: we may have changed to Uri above: if (feedsTable.ContainsKey(f.link) == false) { f.owner = this; feedsTable.Add(f.link, f); //add category if needed if (f.category != null) { string cat_trimmed = f.category = f.category.Trim(); if (!categories.ContainsKey(cat_trimmed)) { AddCategory(cat_trimmed); } } } } } } ////copy over layout info if we are importing a new feed //if (myFeeds.listviewLayouts != null) //{ // foreach (var layout in myFeeds.listviewLayouts) // { // string layout_trimmed = layout.ID.Trim(); // if (!layouts.ContainsKey(layout_trimmed)) // { // layouts.Add(layout_trimmed, layout.FeedColumnLayout); // } // } //} /* * props. set by configuration/static, but required for migration: */ if (MigrateProperties) { //copy user-identities over if we are migrating if (myFeeds.identities != null) { MigrationProperties.Add("UserIdentity", myFeeds.identities); } //copy nntp-server defs. over if we are migrating if (myFeeds.nntpservers != null) { foreach (var sd in myFeeds.nntpservers) { // using the public property will initiate a load: if (NntpServers.ContainsKey(sd.Name) == false) { NntpServers.Add(sd.Name, sd); } } } //if refresh rate in imported feed then use that if (myFeeds.refreshrateSpecified) { MigrationProperties.Add("RefreshRate", myFeeds.refreshrate); } //if stylesheet specified in imported feed then use that if (!string.IsNullOrEmpty(myFeeds.stylesheet)) { MigrationProperties.Add("Stylesheet", myFeeds.stylesheet); //this.stylesheet = myFeeds.stylesheet; } //if download enclosures specified in imported feed then use that if (myFeeds.downloadenclosuresSpecified) { MigrationProperties.Add("DownloadEnclosures", myFeeds.downloadenclosures); } //if maximum enclosure cache size specified in imported feed then use that if (myFeeds.enclosurecachesizeSpecified) { MigrationProperties.Add("EnclosureCacheSize", myFeeds.enclosurecachesize); //this.enclosurecachesize = myFeeds.enclosurecachesize; } //if maximum number of enclosures to download on a new feed specified in imported feed then use that if (myFeeds.numtodownloadonnewfeedSpecified) { MigrationProperties.Add("NumEnclosuresToDownloadOnNewFeed", myFeeds.numtodownloadonnewfeed); //this.numtodownloadonnewfeed = myFeeds.numtodownloadonnewfeed; } //if cause alert on enclosures specified in imported feed then use that if (myFeeds.enclosurealertSpecified) { MigrationProperties.Add("EnclosureAlert", myFeeds.enclosurealert); //this.enclosurealert = myFeeds.enclosurealert; } //if create subfolders for enclosures specified in imported feed then use that if (myFeeds.createsubfoldersforenclosuresSpecified) { MigrationProperties.Add("CreateSubfoldersForEnclosures", myFeeds.createsubfoldersforenclosures); //this.createsubfoldersforenclosures = myFeeds.createsubfoldersforenclosures; } //if marking items as read on exit specified in imported feed then use that if (myFeeds.markitemsreadonexitSpecified) { MigrationProperties.Add("MarkItemsReadOnExit", myFeeds.markitemsreadonexit); //this.markitemsreadonexit = myFeeds.markitemsreadonexit; } //if enclosure folder specified in imported feed then use that if (!string.IsNullOrEmpty(myFeeds.enclosurefolder)) { MigrationProperties.Add("EnclosureFolder", myFeeds.enclosurefolder); } //if podcast folder specified in imported feed then use that if (!string.IsNullOrEmpty(myFeeds.podcastfolder)) { MigrationProperties.Add("PodcastFolder", myFeeds.podcastfolder); } //if podcast file extensions specified in imported feed then use that if (!string.IsNullOrEmpty(myFeeds.podcastfileexts)) { MigrationProperties.Add("PodcastFileExtensions", myFeeds.podcastfileexts); } ////if listview layout specified in imported feed then use that //if (!string.IsNullOrEmpty(myFeeds.listviewlayout)) //{ // FeedColumnLayout = myFeeds.listviewlayout; //} //if max item age in imported feed then use that try { if (!string.IsNullOrEmpty(myFeeds.maxitemage)) { MigrationProperties.Add("MaxItemAge", myFeeds.maxitemage); //this.maxitemage = XmlConvert.ToTimeSpan(myFeeds.maxitemage); } } catch (FormatException fe) { Trace("Error occured while parsing maximum item age from feed list: {0}", fe.ToDescriptiveString()); } } //if(FeedSource.MigrateProperties){ }
internal override void ValidateUniqueTypeAttribution(XmlSchemaObjectTable labels, ValidationEventHandler h, XmlSchema schema) { // do nothing }
internal XmlReader Validate(XmlReader reader, XmlResolver resolver, XmlSchemaSet schemaSet, ValidationEventHandler valEventHandler) { if (schemaSet != null) { XmlReaderSettings readerSettings = new XmlReaderSettings(); readerSettings.ValidationType = ValidationType.Schema; readerSettings.Schemas = schemaSet; readerSettings.ValidationEventHandler += valEventHandler; return(new XsdValidatingReader(reader, resolver, readerSettings, this)); } return(null); }
protected static void ProcessEntity(System.Xml.Schema.SchemaInfo sinfo, string name, object sender, ValidationEventHandler eventhandler, string baseUri, int lineNumber, int linePosition) { SchemaEntity entity; XmlSchemaException ex = null; if (!sinfo.GeneralEntities.TryGetValue(new XmlQualifiedName(name), out entity)) { ex = new XmlSchemaException("Sch_UndeclaredEntity", name, baseUri, lineNumber, linePosition); } else if (entity.NData.IsEmpty) { ex = new XmlSchemaException("Sch_UnparsedEntityRef", name, baseUri, lineNumber, linePosition); } if (ex != null) { if (eventhandler == null) { throw ex; } eventhandler(sender, new ValidationEventArgs(ex)); } }
public static int Main(string[] args) { ThisAssembly = Assembly.GetExecutingAssembly(); XmlSchemaSet set = new XmlSchemaSet(); ValidationEventHandler veh = new ValidationEventHandler(ValidationCallback); set.ValidationEventHandler += veh; string csFileName = string.Empty; string configFileName = null; string assemblyName = string.Empty; bool fSourceNameProvided = false; bool xmlSerializable = false; bool nameMangler2 = false; if (args.Length == 0) { PrintHelp(); return(0); } for (int i = 0; i < args.Length; i++) { string arg = args[i]; string value = string.Empty; bool argument = false; if (arg.StartsWith("/") || arg.StartsWith("-")) { argument = true; int colonPos = arg.IndexOf(":"); if (colonPos != -1) { value = arg.Substring(colonPos + 1); arg = arg.Substring(0, colonPos); } } arg = arg.ToLower(CultureInfo.InvariantCulture); if (!argument) { try { set.Add(null, CreateReader(arg)); } catch (Exception e) { PrintErrorMessage(e.ToString()); return(1); } if (csFileName == string.Empty) { csFileName = Path.ChangeExtension(arg, "cs"); } } else if (ArgumentMatch(arg, "?") || ArgumentMatch(arg, "help")) { PrintHelp(); return(0); } else if (ArgumentMatch(arg, "config")) { configFileName = value; } else if (ArgumentMatch(arg, "filename")) { csFileName = value; fSourceNameProvided = true; } else if (ArgumentMatch(arg, "enableservicereference")) { xmlSerializable = true; } else if (ArgumentMatch(arg, "lib")) { assemblyName = value; } else if (ArgumentMatch(arg, "namemangler2")) { nameMangler2 = true; } } if (assemblyName != string.Empty && !fSourceNameProvided) { //only generate assembly csFileName = string.Empty; } set.Compile(); set.ValidationEventHandler -= veh; if (set.Count > 0 && set.IsCompiled) { /* * GenerateXObjects( * set, csFileName, configFileName, assemblyName, xmlSerializable, nameMangler2); */ try { GenerateXObjects( set, csFileName, configFileName, assemblyName, xmlSerializable, nameMangler2); } catch (Exception e) { PrintErrorMessage(e.ToString()); return(1); } } return(0); }
public Parser(SchemaType schemaType, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler) { _schemaType = schemaType; _nameTable = nameTable; _schemaNames = schemaNames; _eventHandler = eventHandler; _xmlResolver = null; _processMarkup = true; _dummyDocument = new XmlDocument(); }
internal override void ValidateUniqueParticleAttribution(XmlSchemaObjectTable qnames, ArrayList nsNames, ValidationEventHandler h, XmlSchema schema) { // do nothing }
// Methods public static XmlSchema Read(System.IO.TextReader reader, ValidationEventHandler validationEventHandler) { }
//<all // id = ID // maxOccurs = 1 : 1 // minOccurs = (0 | 1) : 1 // {any attributes with non-schema namespace . . .}> // Content: (annotation?, element*) //</all> internal static XmlSchemaAll Read(XmlSchemaReader reader, ValidationEventHandler h) { XmlSchemaAll all = new XmlSchemaAll(); reader.MoveToElement(); if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname) { error(h, "Should not happen :1: XmlSchemaAll.Read, name=" + reader.Name, null); reader.SkipToEnd(); return(null); } all.LineNumber = reader.LineNumber; all.LinePosition = reader.LinePosition; all.SourceUri = reader.BaseURI; //Read Attributes while (reader.MoveToNextAttribute()) { if (reader.Name == "id") { all.Id = reader.Value; } else if (reader.Name == "maxOccurs") { try { all.MaxOccursString = reader.Value; } catch (Exception e) { error(h, reader.Value + " is an invalid value for maxOccurs", e); } } else if (reader.Name == "minOccurs") { try { all.MinOccursString = reader.Value; } catch (Exception e) { error(h, reader.Value + " is an invalid value for minOccurs", e); } } else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace) { error(h, reader.Name + " is not a valid attribute for all", null); } else { XmlSchemaUtil.ReadUnhandledAttribute(reader, all); } } reader.MoveToElement(); if (reader.IsEmptyElement) { return(all); } //Content: (annotation?, element*) int level = 1; while (reader.ReadNextElement()) { if (reader.NodeType == XmlNodeType.EndElement) { if (reader.LocalName != xmlname) { error(h, "Should not happen :2: XmlSchemaAll.Read, name=" + reader.Name, null); } break; } if (level <= 1 && reader.LocalName == "annotation") { level = 2; //Only one annotation #if NOT_PFX XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h); if (annotation != null) { all.Annotation = annotation; } #endif continue; } if (level <= 2 && reader.LocalName == "element") { level = 2; XmlSchemaElement element = XmlSchemaElement.Read(reader, h); if (element != null) { all.items.Add(element); } continue; } reader.RaiseInvalidElementError(); } return(all); }
/// <summary> /// Validates the xml against known schemas. /// </summary> public static XmlDocument ValidateXml(IProgressMonitor monitor, string xml, string fileName) { monitor.BeginTask(GettextCatalog.GetString("Validating XML..."), 1); bool error = false; XmlDocument doc = null; StringReader stringReader = new StringReader(xml); XmlReaderSettings settings = new XmlReaderSettings(); settings.ValidationFlags = XmlSchemaValidationFlags.ProcessIdentityConstraints | XmlSchemaValidationFlags.ProcessInlineSchema | XmlSchemaValidationFlags.ProcessSchemaLocation | XmlSchemaValidationFlags.ReportValidationWarnings; settings.ValidationType = ValidationType.Schema; settings.ProhibitDtd = false; ValidationEventHandler validationHandler = delegate(object sender, System.Xml.Schema.ValidationEventArgs args) { if (args.Severity == XmlSeverityType.Warning) { monitor.Log.WriteLine(args.Message); AddTask(fileName, args.Exception.Message, args.Exception.LinePosition, args.Exception.LineNumber, TaskSeverity.Warning); } else { AddTask(fileName, args.Exception.Message, args.Exception.LinePosition, args.Exception.LineNumber, TaskSeverity.Error); monitor.Log.WriteLine(args.Message); error = true; } }; settings.ValidationEventHandler += validationHandler; try { foreach (XmlSchemaCompletionData sd in XmlSchemaManager.SchemaCompletionDataItems) { settings.Schemas.Add(sd.Schema); } settings.Schemas.Compile(); XmlReader reader = XmlReader.Create(stringReader, settings); doc = new XmlDocument(); doc.Load(reader); } catch (XmlSchemaException ex) { monitor.ReportError(ex.Message, ex); AddTask(fileName, ex.Message, ex.LinePosition, ex.LineNumber, TaskSeverity.Error); error = true; } catch (XmlException ex) { monitor.ReportError(ex.Message, ex); AddTask(fileName, ex.Message, ex.LinePosition, ex.LineNumber, TaskSeverity.Error); error = true; } finally { if (stringReader != null) { stringReader.Dispose(); } settings.ValidationEventHandler -= validationHandler; } if (error) { monitor.Log.WriteLine(GettextCatalog.GetString("Validation failed.")); TaskService.ShowErrors(); } else { monitor.Log.WriteLine(GettextCatalog.GetString("XML is valid.")); } monitor.EndTask(); return(error? null: doc); }