internal override int Compile(ValidationEventHandler h, XmlSchema schema) { // If this is already compiled this time, simply skip. if (CompilationId == schema.CompilationId) { return(0); } if (nsmgr == null) { nsmgr = new XmlNamespaceManager(new NameTable()); if (Namespaces != null) { foreach (XmlQualifiedName qname in Namespaces.ToArray()) { nsmgr.AddNamespace(qname.Name, qname.Namespace); } } } currentPath = new XsdIdentityPath(); ParseExpression(xpath, h, schema); XmlSchemaUtil.CompileID(Id, this, schema.IDCollection, h); this.CompilationId = schema.CompilationId; return(errorCount); }
/// <remarks> /// 1. One of itemType or a <simpleType> must be present, but not both. /// 2. id must be of type ID /// </remarks> internal override int Compile(ValidationEventHandler h, XmlSchema schema) { // If this is already compiled this time, simply skip. if (CompilationId == schema.CompilationId) { return(0); } errorCount = 0; if (ItemType != null && !ItemTypeName.IsEmpty) { error(h, "both itemType and simpletype can't be present"); } if (ItemType == null && ItemTypeName.IsEmpty) { error(h, "one of itemType or simpletype must be present"); } if (ItemType != null) { errorCount += ItemType.Compile(h, schema); } if (!XmlSchemaUtil.CheckQName(ItemTypeName)) { error(h, "BaseTypeName must be a XmlQualifiedName"); } XmlSchemaUtil.CompileID(Id, this, schema.IDCollection, h); this.CompilationId = schema.CompilationId; return(errorCount); }
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); }
/// <remarks> /// 1. id must be of type ID /// 2. namespace can have one of the following values: /// a) ##any or ##other /// b) list of anyURI and ##targetNamespace and ##local /// </remarks> internal override int Compile(ValidationEventHandler h, XmlSchema schema) { // If this is already compiled this time, simply skip. if (CompilationId == schema.CompilationId) { return(0); } errorCount = 0; wildcard.TargetNamespace = AncestorSchema.TargetNamespace; if (wildcard.TargetNamespace == null) { wildcard.TargetNamespace = ""; } XmlSchemaUtil.CompileID(Id, this, schema.IDCollection, h); wildcard.Compile(Namespace, h, schema); if (processing == XmlSchemaContentProcessing.None) { wildcard.ResolvedProcessing = XmlSchemaContentProcessing.Strict; } else { wildcard.ResolvedProcessing = processing; } this.CompilationId = schema.CompilationId; return(errorCount); }
///<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); }
/// <remarks> /// An Attribute group can only be defined as a child of XmlSchema or in XmlSchemaRedefine. /// The other attributeGroup has type XmlSchemaAttributeGroupRef. /// 1. Name must be present /// </remarks> internal override int Compile(ValidationEventHandler h, XmlSchema schema) { // If this is already compiled this time, simply skip. if (CompilationId == schema.CompilationId) { return(errorCount); } errorCount = 0; if (redefinedObject != null) { errorCount += redefined.Compile(h, schema); if (errorCount == 0) { redefined = (XmlSchemaAttributeGroup)redefinedObject; } } XmlSchemaUtil.CompileID(Id, this, schema.IDCollection, h); if (this.Name == null || this.Name == String.Empty) //1 { error(h, "Name is required in top level simpletype"); } else if (!XmlSchemaUtil.CheckNCName(this.Name)) // b.1.2 { error(h, "name attribute of a simpleType must be NCName"); } else { this.qualifiedName = new XmlQualifiedName(this.Name, AncestorSchema.TargetNamespace); } if (this.AnyAttribute != null) { errorCount += this.AnyAttribute.Compile(h, schema); } foreach (XmlSchemaObject obj in Attributes) { if (obj is XmlSchemaAttribute) { XmlSchemaAttribute attr = (XmlSchemaAttribute)obj; errorCount += attr.Compile(h, schema); } else if (obj is XmlSchemaAttributeGroupRef) { XmlSchemaAttributeGroupRef gref = (XmlSchemaAttributeGroupRef)obj; errorCount += gref.Compile(h, schema); } else { error(h, "invalid type of object in Attributes property"); } } this.CompilationId = schema.CompilationId; return(errorCount); }
// Is some value is read, return it. // If no values return empty. // If exception, return none public static XmlSchemaDerivationMethod ReadDerivationAttribute(XmlReader reader, out Exception innerExcpetion, string name, XmlSchemaDerivationMethod allowed) { innerExcpetion = null; try { string list = reader.Value; string warn = ""; XmlSchemaDerivationMethod val = 0; if (list.IndexOf("#all") != -1 && list.Trim() != "#all") { innerExcpetion = new Exception(list + " is not a valid value for " + name + ". #all if present must be the only value"); return(XmlSchemaDerivationMethod.All); } foreach (string xsdm in XmlSchemaUtil.SplitList(list)) { switch (xsdm) { case "": val = AddFlag(val, XmlSchemaDerivationMethod.Empty, allowed); break; case "#all": val = AddFlag(val, XmlSchemaDerivationMethod.All, allowed); break; case "substitution": val = AddFlag(val, XmlSchemaDerivationMethod.Substitution, allowed); break; case "extension": val = AddFlag(val, XmlSchemaDerivationMethod.Extension, allowed); break; case "restriction": val = AddFlag(val, XmlSchemaDerivationMethod.Restriction, allowed); break; case "list": val = AddFlag(val, XmlSchemaDerivationMethod.List, allowed); break; case "union": val = AddFlag(val, XmlSchemaDerivationMethod.Union, allowed); break; default: warn += xsdm + " "; break; } } if (warn != "") { innerExcpetion = new Exception(warn + "is/are not valid values for " + name); } return(val); } catch (Exception ex) { innerExcpetion = ex; return(XmlSchemaDerivationMethod.None); } }
/// <remarks> /// 1. Circular union type definition is disallowed. (WTH is this?) /// 2. id must be a valid ID /// </remarks> internal override int Compile(ValidationEventHandler h, XmlSchema schema) { // If this is already compiled this time, simply skip. if (CompilationId == schema.CompilationId) { return(0); } errorCount = 0; int count = BaseTypes.Count; foreach (XmlSchemaObject obj in baseTypes) { if (obj != null && obj is XmlSchemaSimpleType) { XmlSchemaSimpleType stype = (XmlSchemaSimpleType)obj; errorCount += stype.Compile(h, schema); } else { error(h, "baseTypes can't have objects other than a simpletype"); } } if (memberTypes != null) { for (int i = 0; i < memberTypes.Length; i++) { if (memberTypes[i] == null || !XmlSchemaUtil.CheckQName(MemberTypes[i])) { error(h, "Invalid membertype"); memberTypes[i] = XmlQualifiedName.Empty; } else { count += MemberTypes.Length; } } } if (count == 0) { error(h, "Atleast one simpletype or membertype must be present"); } XmlSchemaUtil.CompileID(Id, this, schema.IDCollection, h); this.CompilationId = schema.CompilationId; return(errorCount); }
internal override int Validate(ValidationEventHandler h, XmlSchema schema) { if (IsValidated(schema.ValidationId)) { return(errorCount); } // ListItemType XmlSchemaSimpleType type = itemType; if (type == null) { type = schema.FindSchemaType(itemTypeName) as XmlSchemaSimpleType; } if (type != null) { errorCount += type.Validate(h, schema); validatedListItemType = type; } else if (itemTypeName == XmlSchemaComplexType.AnyTypeName) { validatedListItemType = XmlSchemaSimpleType.AnySimpleType; } else if (XmlSchemaUtil.IsBuiltInDatatypeName(itemTypeName)) { validatedListItemType = XmlSchemaDatatype.FromName(itemTypeName); if (validatedListItemType == null) { error(h, "Invalid schema type name was specified: " + itemTypeName); } } // otherwise, it might be missing sub components. else if (!schema.IsNamespaceAbsent(itemTypeName.Namespace)) { error(h, "Referenced base list item schema type " + itemTypeName + " was not found."); } #if NET_2_0 XmlSchemaSimpleType st = validatedListItemType as XmlSchemaSimpleType; if (st == null && validatedListItemType != null) { st = XmlSchemaType.GetBuiltInSimpleType(((XmlSchemaDatatype)validatedListItemType).TypeCode); } validatedListItemSchemaType = st; #endif ValidationId = schema.ValidationId; return(errorCount); }
/// <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); }
// 1. name must be present // 2. MinOccurs & MaxOccurs of the Particle must be absent 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 (Particle == null) { error(h, "Particle is required"); } else { if (Particle.MaxOccursString != null) { Particle.error(h, "MaxOccurs must not be present when the Particle is a child of Group"); } if (Particle.MinOccursString != null) { Particle.error(h, "MinOccurs must not be present when the Particle is a child of Group"); } Particle.Compile(h, schema); } XmlSchemaUtil.CompileID(Id, this, schema.IDCollection, h); this.CompilationId = schema.CompilationId; return(errorCount); }
internal override int Validate(ValidationEventHandler h, XmlSchema schema) { if (IsValidated(schema.ValidationId)) { return(errorCount); } if (baseType != null) { baseType.Validate(h, schema); actualBaseSchemaType = baseType; } else if (baseTypeName != XmlQualifiedName.Empty) { XmlSchemaType st = schema.FindSchemaType(baseTypeName); if (st != null) { st.Validate(h, schema); actualBaseSchemaType = st; } else if (baseTypeName == XmlSchemaComplexType.AnyTypeName) { actualBaseSchemaType = XmlSchemaComplexType.AnyType; } else if (XmlSchemaUtil.IsBuiltInDatatypeName(baseTypeName)) { actualBaseSchemaType = XmlSchemaDatatype.FromName(baseTypeName); if (actualBaseSchemaType == null) { error(h, "Invalid schema datatype name is specified."); } } // otherwise, it might be missing sub components. else if (!schema.IsNamespaceAbsent(baseTypeName.Namespace)) { error(h, "Referenced base schema type " + baseTypeName + " was not found in the corresponding schema."); } } ValidationId = schema.ValidationId; return(errorCount); }
/// <remarks> /// 1. MaxOccurs must be one. (default is also one) /// 2. MinOccurs must be zero or one. /// </remarks> internal override int Compile(ValidationEventHandler h, XmlSchema schema) { // If this is already compiled this time, simply skip. if (CompilationId == schema.CompilationId) { return(0); } this.schema = schema; if (MaxOccurs != Decimal.One) { error(h, "maxOccurs must be 1"); } if (MinOccurs != Decimal.One && MinOccurs != Decimal.Zero) { error(h, "minOccurs must be 0 or 1"); } XmlSchemaUtil.CompileID(Id, this, schema.IDCollection, h); CompileOccurence(h, schema); foreach (XmlSchemaObject obj in Items) { XmlSchemaElement elem = obj as XmlSchemaElement; if (elem != null) { if (elem.ValidatedMaxOccurs != Decimal.One && elem.ValidatedMaxOccurs != Decimal.Zero) { elem.error(h, "The {max occurs} of all the elements of 'all' must be 0 or 1. "); } errorCount += elem.Compile(h, schema); } else { error(h, "XmlSchemaAll can only contain Items of type Element"); } } this.CompilationId = schema.CompilationId; return(errorCount); }
// 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); }
internal override int Validate(ValidationEventHandler h, XmlSchema schema) { if (IsValidated(schema.CompilationId)) { return(errorCount); } if (redefined == null && redefinedObject != null) { redefinedObject.Compile(h, schema); redefined = (XmlSchemaAttributeGroup)redefinedObject; redefined.Validate(h, schema); } XmlSchemaObjectCollection actualAttributes = null; /* * if (this.redefined != null) { * actualAttributes = new XmlSchemaObjectCollection (); * foreach (XmlSchemaObject obj in Attributes) { * XmlSchemaAttributeGroupRef grp = obj as XmlSchemaAttributeGroupRef; * if (grp != null && grp.QualifiedName == this.QualifiedName) * actualAttributes.Add (redefined); * else * actualAttributes.Add (obj); * } * } * else */ actualAttributes = Attributes; attributeUses = new XmlSchemaObjectTable(); errorCount += XmlSchemaUtil.ValidateAttributesResolved(attributeUses, h, schema, actualAttributes, AnyAttribute, ref anyAttributeUse, redefined, false); ValidationId = schema.ValidationId; return(errorCount); }
/// <remarks> /// 1. ref must be present /// </remarks> internal override int Compile(ValidationEventHandler h, XmlSchema schema) { // If this is already compiled this time, simply skip. if (CompilationId == schema.CompilationId) { return(0); } errorCount = 0; if (RefName == null || RefName.IsEmpty) { error(h, "ref must be present"); } else if (!XmlSchemaUtil.CheckQName(RefName)) { error(h, "ref must be a valid qname"); } XmlSchemaUtil.CompileID(Id, this, schema.IDCollection, h); this.CompilationId = schema.CompilationId; return(errorCount); }
//<enumeration // id = ID // value = anySimpleType // {any attributes with non-schema namespace . . .}> // Content: (annotation?) //</enumeration> internal static XmlSchemaEnumerationFacet Read(XmlSchemaReader reader, ValidationEventHandler h) { XmlSchemaEnumerationFacet enumeration = new XmlSchemaEnumerationFacet(); reader.MoveToElement(); if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname) { error(h, "Should not happen :1: XmlSchemaEnumerationFacet.Read, name=" + reader.Name, null); reader.Skip(); return(null); } enumeration.LineNumber = reader.LineNumber; enumeration.LinePosition = reader.LinePosition; enumeration.SourceUri = reader.BaseURI; while (reader.MoveToNextAttribute()) { if (reader.Name == "id") { enumeration.Id = reader.Value; } else if (reader.Name == "value") { enumeration.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, enumeration); } } reader.MoveToElement(); if (reader.IsEmptyElement) { return(enumeration); } // Content: (annotation?) int level = 1; while (reader.ReadNextElement()) { if (reader.NodeType == XmlNodeType.EndElement) { if (reader.LocalName != xmlname) { error(h, "Should not happen :2: XmlSchemaEnumerationFacet.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) { enumeration.Annotation = annotation; } continue; } reader.RaiseInvalidElementError(); } return(enumeration); }
//<choice // id = ID // maxOccurs = (nonNegativeInteger | unbounded) : 1 // minOccurs = nonNegativeInteger : 1 // {any attributes with non-schema namespace . . .}> // Content: (annotation?, (element | group | choice | sequence | any)*) //</choice> internal static XmlSchemaChoice Read(XmlSchemaReader reader, ValidationEventHandler h) { XmlSchemaChoice choice = new XmlSchemaChoice(); reader.MoveToElement(); if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname) { error(h, "Should not happen :1: XmlSchemaChoice.Read, name=" + reader.Name, null); reader.SkipToEnd(); return(null); } choice.LineNumber = reader.LineNumber; choice.LinePosition = reader.LinePosition; choice.SourceUri = reader.BaseURI; while (reader.MoveToNextAttribute()) { if (reader.Name == "id") { choice.Id = reader.Value; } else if (reader.Name == "maxOccurs") { try { choice.MaxOccursString = reader.Value; } catch (Exception e) { error(h, reader.Value + " is an invalid value for maxOccurs", e); } } else if (reader.Name == "minOccurs") { try { choice.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 choice", null); } else { XmlSchemaUtil.ReadUnhandledAttribute(reader, choice); } } reader.MoveToElement(); if (reader.IsEmptyElement) { return(choice); } // Content: (annotation?, (element | group | choice | sequence | any)*) int level = 1; while (reader.ReadNextElement()) { if (reader.NodeType == XmlNodeType.EndElement) { if (reader.LocalName != xmlname) { error(h, "Should not happen :2: XmlSchemaChoice.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) { choice.Annotation = annotation; } continue; } if (level <= 2) { if (reader.LocalName == "element") { level = 2; XmlSchemaElement element = XmlSchemaElement.Read(reader, h); if (element != null) { choice.items.Add(element); } continue; } if (reader.LocalName == "group") { level = 2; XmlSchemaGroupRef group = XmlSchemaGroupRef.Read(reader, h); if (group != null) { choice.items.Add(group); } continue; } if (reader.LocalName == "choice") { level = 2; XmlSchemaChoice ch = XmlSchemaChoice.Read(reader, h); if (ch != null) { choice.items.Add(ch); } continue; } if (reader.LocalName == "sequence") { level = 2; XmlSchemaSequence sequence = XmlSchemaSequence.Read(reader, h); if (sequence != null) { choice.items.Add(sequence); } continue; } if (reader.LocalName == "any") { level = 2; XmlSchemaAny any = XmlSchemaAny.Read(reader, h); if (any != null) { choice.items.Add(any); } continue; } } reader.RaiseInvalidElementError(); } return(choice); }
///<remarks> /// 1. Base must be present and a QName ///</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 (this.isRedefinedComponent) { if (Annotation != null) { Annotation.isRedefinedComponent = true; } if (AnyAttribute != null) { AnyAttribute.isRedefinedComponent = true; } foreach (XmlSchemaObject obj in Attributes) { obj.isRedefinedComponent = true; } } if (BaseTypeName == null || BaseTypeName.IsEmpty) { error(h, "base must be present, as a QName"); } else if (!XmlSchemaUtil.CheckQName(BaseTypeName)) { error(h, "BaseTypeName must be a QName"); } if (this.AnyAttribute != null) { errorCount += AnyAttribute.Compile(h, schema); } foreach (XmlSchemaObject obj in Attributes) { if (obj is XmlSchemaAttribute) { XmlSchemaAttribute attr = (XmlSchemaAttribute)obj; errorCount += attr.Compile(h, schema); } else if (obj is XmlSchemaAttributeGroupRef) { XmlSchemaAttributeGroupRef atgrp = (XmlSchemaAttributeGroupRef)obj; errorCount += atgrp.Compile(h, schema); } else { error(h, obj.GetType() + " is not valid in this place::SimpleConentExtension"); } } XmlSchemaUtil.CompileID(Id, this, schema.IDCollection, h); this.CompilationId = schema.CompilationId; return(errorCount); }
/* * internal new void error(ValidationEventHandler handle, string message) * { * errorCount++; * ValidationHandler.RaiseValidationError(handle, this, message); * } */ //<unique // id = ID // name = NCName // {any attributes with non-schema namespace . . .}> // Content: (annotation?, (selector, field+)) //</unique> internal static XmlSchemaUnique Read(XmlSchemaReader reader, ValidationEventHandler h) { XmlSchemaUnique unique = new XmlSchemaUnique(); reader.MoveToElement(); if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname) { error(h, "Should not happen :1: XmlSchemaUnique.Read, name=" + reader.Name, null); reader.Skip(); return(null); } unique.LineNumber = reader.LineNumber; unique.LinePosition = reader.LinePosition; unique.SourceUri = reader.BaseURI; while (reader.MoveToNextAttribute()) { if (reader.Name == "id") { unique.Id = reader.Value; } else if (reader.Name == "name") { unique.Name = reader.Value; } else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace) { error(h, reader.Name + " is not a valid attribute for unique", null); } else { XmlSchemaUtil.ReadUnhandledAttribute(reader, unique); } } reader.MoveToElement(); if (reader.IsEmptyElement) { return(unique); } // 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: XmlSchemaUnion.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) { unique.Annotation = annotation; } continue; } if (level <= 2 && reader.LocalName == "selector") { level = 3; XmlSchemaXPath selector = XmlSchemaXPath.Read(reader, h, "selector"); if (selector != null) { unique.Selector = selector; } continue; } if (level <= 3 && reader.LocalName == "field") { level = 3; if (unique.Selector == null) { error(h, "selector must be defined before field declarations", null); } XmlSchemaXPath field = XmlSchemaXPath.Read(reader, h, "field"); if (field != null) { unique.Fields.Add(field); } continue; } reader.RaiseInvalidElementError(); } return(unique); }
private static void ReadAttributes(XmlSchema schema, XmlSchemaReader reader, ValidationEventHandler h) { Exception ex; reader.MoveToElement(); while (reader.MoveToNextAttribute()) { switch (reader.Name) { case "attributeFormDefault": schema.attributeFormDefault = XmlSchemaUtil.ReadFormAttribute(reader, out ex); if (ex != null) { error(h, reader.Value + " is not a valid value for attributeFormDefault.", ex); } break; case "blockDefault": schema.blockDefault = XmlSchemaUtil.ReadDerivationAttribute(reader, out ex, "blockDefault", XmlSchemaUtil.ElementBlockAllowed); if (ex != null) { error(h, ex.Message, ex); } break; case "elementFormDefault": schema.elementFormDefault = XmlSchemaUtil.ReadFormAttribute(reader, out ex); if (ex != null) { error(h, reader.Value + " is not a valid value for elementFormDefault.", ex); } break; case "finalDefault": schema.finalDefault = XmlSchemaUtil.ReadDerivationAttribute(reader, out ex, "finalDefault", XmlSchemaUtil.FinalAllowed); if (ex != null) { error(h, ex.Message, ex); } break; case "id": schema.id = reader.Value; break; case "targetNamespace": schema.targetNamespace = reader.Value; break; case "version": schema.version = reader.Value; break; default: if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace) { error(h, reader.Name + " attribute is not allowed in schema element", null); } else { XmlSchemaUtil.ReadUnhandledAttribute(reader, schema); } break; } } }
//<simpleType // final = (#all | (list | union | restriction)) // id = ID // name = NCName // {any attributes with non-schema namespace . . .}> // Content: (annotation?, (restriction | list | union)) //</simpleType> internal static XmlSchemaSimpleType Read(XmlSchemaReader reader, ValidationEventHandler h) { XmlSchemaSimpleType stype = new XmlSchemaSimpleType(); 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); } stype.LineNumber = reader.LineNumber; stype.LinePosition = reader.LinePosition; stype.SourceUri = reader.BaseURI; while (reader.MoveToNextAttribute()) { if (reader.Name == "final") { Exception innerex; stype.Final = XmlSchemaUtil.ReadDerivationAttribute(reader, out innerex, "final", XmlSchemaUtil.FinalAllowed); if (innerex != null) { error(h, "some invalid values not a valid value for final", innerex); } } else if (reader.Name == "id") { stype.Id = reader.Value; } else if (reader.Name == "name") { stype.Name = reader.Value; } else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace) { error(h, reader.Name + " is not a valid attribute for simpleType", null); } else { XmlSchemaUtil.ReadUnhandledAttribute(reader, stype); } } reader.MoveToElement(); if (reader.IsEmptyElement) { return(stype); } // Content: (annotation?, (restriction | list | union)) int level = 1; while (reader.ReadNextElement()) { if (reader.NodeType == XmlNodeType.EndElement) { if (reader.LocalName != xmlname) { error(h, "Should not happen :2: XmlSchemaSimpleType.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) { stype.Annotation = annotation; } continue; } if (level <= 2) { if (reader.LocalName == "restriction") { level = 3; XmlSchemaSimpleTypeRestriction restriction = XmlSchemaSimpleTypeRestriction.Read(reader, h); if (restriction != null) { stype.content = restriction; } continue; } if (reader.LocalName == "list") { level = 3; XmlSchemaSimpleTypeList list = XmlSchemaSimpleTypeList.Read(reader, h); if (list != null) { stype.content = list; } continue; } if (reader.LocalName == "union") { level = 3; XmlSchemaSimpleTypeUnion union = XmlSchemaSimpleTypeUnion.Read(reader, h); if (union != null) { stype.content = union; } continue; } } reader.RaiseInvalidElementError(); } return(stype); }
/// <remarks> /// 1. name must be present /// 2. selector and field must be present /// </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 (Name == null) { error(h, "Required attribute name must be present"); } else if (!XmlSchemaUtil.CheckNCName(this.name)) { error(h, "attribute name must be NCName"); } else { this.qName = new XmlQualifiedName(Name, AncestorSchema.TargetNamespace); if (schema.NamedIdentities.Contains(qName)) { XmlSchemaIdentityConstraint existing = schema.NamedIdentities [qName] as XmlSchemaIdentityConstraint; error(h, String.Format("There is already same named identity constraint in this namespace. Existing item is at {0}({1},{2})", existing.SourceUri, existing.LineNumber, existing.LinePosition)); } else { schema.NamedIdentities.Add(qName, this); } } if (Selector == null) { error(h, "selector must be present"); } else { Selector.isSelector = true; errorCount += Selector.Compile(h, schema); if (selector.errorCount == 0) { compiledSelector = new XsdIdentitySelector(Selector); } } if (errorCount > 0) { return(errorCount); // fatal } if (Fields.Count == 0) { error(h, "atleast one field value must be present"); } else { for (int i = 0; i < Fields.Count; i++) { XmlSchemaXPath field = Fields [i] as XmlSchemaXPath; if (field != null) { errorCount += field.Compile(h, schema); if (field.errorCount == 0) { this.compiledSelector.AddField(new XsdIdentityField(field, i)); } } else { error(h, "Object of type " + Fields [i].GetType() + " is invalid in the Fields Collection"); } } } XmlSchemaUtil.CompileID(Id, this, schema.IDCollection, h); this.CompilationId = schema.CompilationId; return(errorCount); }
//<union // id = ID // memberTypes = List of QName // {any attributes with non-schema namespace . . .}> // Content: (annotation?, (simpleType*)) //</union> internal static XmlSchemaSimpleTypeUnion Read(XmlSchemaReader reader, ValidationEventHandler h) { XmlSchemaSimpleTypeUnion union = new XmlSchemaSimpleTypeUnion(); reader.MoveToElement(); if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname) { error(h, "Should not happen :1: XmlSchemaSimpleTypeUnion.Read, name=" + reader.Name, null); reader.Skip(); return(null); } union.LineNumber = reader.LineNumber; union.LinePosition = reader.LinePosition; union.SourceUri = reader.BaseURI; //Read Attributes while (reader.MoveToNextAttribute()) { if (reader.Name == "id") { union.Id = reader.Value; } else if (reader.Name == "memberTypes") { Exception innerEx; string[] names = XmlSchemaUtil.SplitList(reader.Value); union.memberTypes = new XmlQualifiedName[names.Length]; for (int i = 0; i < names.Length; i++) { union.memberTypes[i] = XmlSchemaUtil.ToQName(reader, names[i], out innerEx); if (innerEx != null) { error(h, "'" + names[i] + "' is not a valid memberType", innerEx); } } } else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace) { error(h, reader.Name + " is not a valid attribute for union", null); } else { XmlSchemaUtil.ReadUnhandledAttribute(reader, union); } } reader.MoveToElement(); if (reader.IsEmptyElement) { return(union); } // Content: annotation?, simpleType* int level = 1; while (reader.ReadNextElement()) { if (reader.NodeType == XmlNodeType.EndElement) { if (reader.LocalName != xmlname) { error(h, "Should not happen :2: XmlSchemaSimpleTypeUnion.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) { union.Annotation = annotation; } continue; } if (level <= 2 && reader.LocalName == "simpleType") { level = 2; XmlSchemaSimpleType stype = XmlSchemaSimpleType.Read(reader, h); if (stype != null) { union.baseTypes.Add(stype); } continue; } reader.RaiseInvalidElementError(); } return(union); }
//<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); }
//<anyAttribute // id = ID // namespace = ((##any | ##other) | List of (anyURI | (##targetNamespace | ##local)) ) : ##any // processContents = (lax | skip | strict) : strict // {any attributes with non-schema namespace . . .}> // Content: (annotation?) //</anyAttribute> internal static XmlSchemaAnyAttribute Read(XmlSchemaReader reader, ValidationEventHandler h) { XmlSchemaAnyAttribute any = new XmlSchemaAnyAttribute(); reader.MoveToElement(); if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname) { error(h, "Should not happen :1: XmlSchemaAnyAttribute.Read, name=" + reader.Name, null); reader.SkipToEnd(); return(null); } any.LineNumber = reader.LineNumber; any.LinePosition = reader.LinePosition; any.SourceUri = reader.BaseURI; while (reader.MoveToNextAttribute()) { if (reader.Name == "id") { any.Id = reader.Value; } else if (reader.Name == "namespace") { any.nameSpace = reader.Value; } else if (reader.Name == "processContents") { Exception innerex; any.processing = XmlSchemaUtil.ReadProcessingAttribute(reader, out innerex); if (innerex != null) { error(h, reader.Value + " is not a valid value for processContents", innerex); } } else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace) { error(h, reader.Name + " is not a valid attribute for anyAttribute", null); } else { XmlSchemaUtil.ReadUnhandledAttribute(reader, any); } } reader.MoveToElement(); if (reader.IsEmptyElement) { return(any); } // Content: (annotation?) int level = 1; while (reader.ReadNextElement()) { if (reader.NodeType == XmlNodeType.EndElement) { if (reader.LocalName != xmlname) { error(h, "Should not happen :2: XmlSchemaAnyAttribute.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) { any.Annotation = annotation; } continue; } reader.RaiseInvalidElementError(); } return(any); }
//<attributeGroup // id = ID // name = NCName // ref = QName // Not present in this class. // {any attributes with non-schema namespace . . .}> // Content: (annotation?, ((attribute | attributeGroup)*, anyAttribute?)) //</attributeGroup> internal static XmlSchemaAttributeGroup Read(XmlSchemaReader reader, ValidationEventHandler h) { XmlSchemaAttributeGroup attrgrp = new XmlSchemaAttributeGroup(); reader.MoveToElement(); if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname) { error(h, "Should not happen :1: XmlSchemaAttributeGroup.Read, name=" + reader.Name, null); reader.SkipToEnd(); return(null); } attrgrp.LineNumber = reader.LineNumber; attrgrp.LinePosition = reader.LinePosition; attrgrp.SourceUri = reader.BaseURI; while (reader.MoveToNextAttribute()) { if (reader.Name == "id") { attrgrp.Id = reader.Value; } else if (reader.Name == "name") { attrgrp.name = reader.Value; } else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace) { error(h, reader.Name + " is not a valid attribute for attributeGroup in this context", null); } else { XmlSchemaUtil.ReadUnhandledAttribute(reader, attrgrp); } } reader.MoveToElement(); if (reader.IsEmptyElement) { return(attrgrp); } //Content: 1.annotation?, 2.(attribute | attributeGroup)*, 3.anyAttribute? int level = 1; while (reader.ReadNextElement()) { if (reader.NodeType == XmlNodeType.EndElement) { if (reader.LocalName != xmlname) { error(h, "Should not happen :2: XmlSchemaAttributeGroup.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) { attrgrp.Annotation = annotation; } continue; } if (level <= 2) { if (reader.LocalName == "attribute") { level = 2; XmlSchemaAttribute attr = XmlSchemaAttribute.Read(reader, h); if (attr != null) { attrgrp.Attributes.Add(attr); } continue; } if (reader.LocalName == "attributeGroup") { level = 2; XmlSchemaAttributeGroupRef attr = XmlSchemaAttributeGroupRef.Read(reader, h); if (attr != null) { attrgrp.attributes.Add(attr); } continue; } } if (level <= 3 && reader.LocalName == "anyAttribute") { level = 4; XmlSchemaAnyAttribute anyattr = XmlSchemaAnyAttribute.Read(reader, h); if (anyattr != null) { attrgrp.AnyAttribute = anyattr; } continue; } reader.RaiseInvalidElementError(); } return(attrgrp); }
//<attributeGroup // id = ID // ref = QName // {any attributes with non-schema namespace . . .}> // Content: (annotation?) //</attributeGroup> internal static XmlSchemaAttributeGroupRef Read(XmlSchemaReader reader, ValidationEventHandler h) { XmlSchemaAttributeGroupRef attrgrp = new XmlSchemaAttributeGroupRef(); reader.MoveToElement(); if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname) { error(h, "Should not happen :1: XmlSchemaAttributeGroupRef.Read, name=" + reader.Name, null); reader.SkipToEnd(); return(null); } attrgrp.LineNumber = reader.LineNumber; attrgrp.LinePosition = reader.LinePosition; attrgrp.SourceUri = reader.BaseURI; while (reader.MoveToNextAttribute()) { if (reader.Name == "id") { attrgrp.Id = reader.Value; } else if (reader.Name == "ref") { Exception innerex; attrgrp.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.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace) { error(h, reader.Name + " is not a valid attribute for attributeGroup in this context", null); } else { XmlSchemaUtil.ReadUnhandledAttribute(reader, attrgrp); } } reader.MoveToElement(); if (reader.IsEmptyElement) { return(attrgrp); } int level = 1; while (reader.ReadNextElement()) { if (reader.NodeType == XmlNodeType.EndElement) { if (reader.LocalName != xmlname) { error(h, "Should not happen :2: XmlSchemaAttributeGroupRef.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) { attrgrp.Annotation = annotation; } continue; } reader.RaiseInvalidElementError(); } return(attrgrp); }
//<maxInclusive // fixed = boolean : false // id = ID // value = anySimpleType // {any attributes with non-schema namespace . . .}> // Content: (annotation?) //</maxInclusive> internal static XmlSchemaMaxInclusiveFacet Read(XmlSchemaReader reader, ValidationEventHandler h) { XmlSchemaMaxInclusiveFacet maxi = new XmlSchemaMaxInclusiveFacet(); reader.MoveToElement(); if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname) { error(h, "Should not happen :1: XmlSchemaMaxInclusiveFacet.Read, name=" + reader.Name, null); reader.Skip(); return(null); } maxi.LineNumber = reader.LineNumber; maxi.LinePosition = reader.LinePosition; maxi.SourceUri = reader.BaseURI; while (reader.MoveToNextAttribute()) { if (reader.Name == "id") { maxi.Id = reader.Value; } else if (reader.Name == "fixed") { Exception innerex; maxi.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") { maxi.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, maxi); } } reader.MoveToElement(); if (reader.IsEmptyElement) { return(maxi); } // Content: (annotation?) int level = 1; while (reader.ReadNextElement()) { if (reader.NodeType == XmlNodeType.EndElement) { if (reader.LocalName != xmlname) { error(h, "Should not happen :2: XmlSchemaMaxInclusiveFacet.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) { maxi.Annotation = annotation; } continue; } reader.RaiseInvalidElementError(); } return(maxi); }
/// <remarks> /// For a simple Type: /// 1. Content must be present /// 2. id if present, must have be a valid ID /// a) If the simpletype is local /// 1- are from <xs:complexType name="simpleType"> and <xs:complexType name="localSimpleType"> /// 1. name is prohibited /// 2. final is prohibited /// b) If the simpletype is toplevel /// 1- are from <xs:complexType name="simpleType"> and <xs:complexType name="topLevelSimpleType"> /// 1. name is required, type must be NCName /// 2. Content is required /// 3. final can have values : #all | (list | union | restriction) /// 4. If final is set, finalResolved is same as final (but within the values of b.3) /// 5. If final is not set, the finalDefault of the schema (ie. only #all and restriction) /// 6. Base type is: /// 4.1 If restriction is chosen,the base type of restriction or elements /// 4.2 otherwise simple ur-type /// </remarks> internal override int Compile(ValidationEventHandler h, XmlSchema schema) { // If this is already compiled this time, simply skip. if (CompilationId == schema.CompilationId) { return(0); } errorCount = 0; if (this.islocal) // a { if (this.Name != null) // a.1 { error(h, "Name is prohibited in a local simpletype"); } else { this.QNameInternal = new XmlQualifiedName(this.Name, AncestorSchema.TargetNamespace); } if (this.Final != XmlSchemaDerivationMethod.None) //a.2 { error(h, "Final is prohibited in a local simpletype"); } } else //b { if (this.Name == null) //b.1 { error(h, "Name is required in top level simpletype"); } else if (!XmlSchemaUtil.CheckNCName(this.Name)) // b.1.2 { error(h, "name attribute of a simpleType must be NCName"); } else { this.QNameInternal = new XmlQualifiedName(this.Name, AncestorSchema.TargetNamespace); } //NOTE: Although the FinalResolved can be Empty, it is not a valid value for Final //DEVIATION: If an error occurs, the finaldefault is always consulted. This deviates // from the way MS implementation works. switch (this.Final) //b.3, b.4 { case XmlSchemaDerivationMethod.All: this.finalResolved = XmlSchemaDerivationMethod.All; break; case XmlSchemaDerivationMethod.List: case XmlSchemaDerivationMethod.Union: case XmlSchemaDerivationMethod.Restriction: this.finalResolved = Final; break; default: error(h, "The value of final attribute is not valid for simpleType"); goto case XmlSchemaDerivationMethod.None; // use assignment from finaldefault on schema. case XmlSchemaDerivationMethod.None: // b.5 XmlSchemaDerivationMethod flags = (XmlSchemaDerivationMethod.Restriction | XmlSchemaDerivationMethod.List | XmlSchemaDerivationMethod.Extension | XmlSchemaDerivationMethod.Union); switch (schema.FinalDefault) { case XmlSchemaDerivationMethod.All: finalResolved = XmlSchemaDerivationMethod.All; break; case XmlSchemaDerivationMethod.None: finalResolved = XmlSchemaDerivationMethod.Empty; break; default: finalResolved = schema.FinalDefault & flags; break; } break; } } XmlSchemaUtil.CompileID(Id, this, schema.IDCollection, h); if (Content != null) { Content.OwnerType = this; } if (this.Content == null) //a.3,b.2 { error(h, "Content is required in a simpletype"); } else if (Content is XmlSchemaSimpleTypeRestriction) { this.resolvedDerivedBy = XmlSchemaDerivationMethod.Restriction; errorCount += ((XmlSchemaSimpleTypeRestriction)Content).Compile(h, schema); } else if (Content is XmlSchemaSimpleTypeList) { this.resolvedDerivedBy = XmlSchemaDerivationMethod.List; errorCount += ((XmlSchemaSimpleTypeList)Content).Compile(h, schema); } else if (Content is XmlSchemaSimpleTypeUnion) { this.resolvedDerivedBy = XmlSchemaDerivationMethod.Union; errorCount += ((XmlSchemaSimpleTypeUnion)Content).Compile(h, schema); } this.CompilationId = schema.CompilationId; return(errorCount); }