private SetAttributeWildcard ( XmlSchemaAnyAttribute value ) : void | ||
value | XmlSchemaAnyAttribute | |
Результат | void |
private static XmlSchemaComplexType CreateAnyType(XmlSchemaContentProcessing processContents) { XmlSchemaComplexType type = new XmlSchemaComplexType(); type.SetQualifiedName(DatatypeImplementation.QnAnyType); XmlSchemaAny item = new XmlSchemaAny { MinOccurs = 0M, MaxOccurs = 79228162514264337593543950335M, ProcessContents = processContents }; item.BuildNamespaceList(null); XmlSchemaSequence sequence = new XmlSchemaSequence(); sequence.Items.Add(item); type.SetContentTypeParticle(sequence); type.SetContentType(XmlSchemaContentType.Mixed); type.ElementDecl = SchemaElementDecl.CreateAnyTypeElementDecl(); type.ElementDecl.SchemaType = type; ParticleContentValidator validator = new ParticleContentValidator(XmlSchemaContentType.Mixed); validator.Start(); validator.OpenGroup(); validator.AddNamespaceList(item.NamespaceList, item); validator.AddStar(); validator.CloseGroup(); ContentValidator validator2 = validator.Finish(true); type.ElementDecl.ContentValidator = validator2; XmlSchemaAnyAttribute attribute = new XmlSchemaAnyAttribute { ProcessContents = processContents }; attribute.BuildNamespaceList(null); type.SetAttributeWildcard(attribute); type.ElementDecl.AnyAttribute = attribute; return type; }
static XmlSchemaComplexType() { anyType = new XmlSchemaComplexType(); anyType.SetContentType(XmlSchemaContentType.Mixed); anyType.ElementDecl = SchemaElementDecl.CreateAnyTypeElementDecl(); XmlSchemaAnyAttribute anyAttribute = new XmlSchemaAnyAttribute(); anyAttribute.BuildNamespaceList(null); anyType.SetAttributeWildcard(anyAttribute); anyType.ElementDecl.AnyAttribute = anyAttribute; }
static XmlSchemaComplexType() { anyType = new XmlSchemaComplexType(); anyType.SetContentType(XmlSchemaContentType.Mixed); anyType.ElementDecl = SchemaElementDecl.CreateAnyTypeElementDecl(); XmlSchemaAnyAttribute anyAttribute = new XmlSchemaAnyAttribute(); anyAttribute.BuildNamespaceList(null); anyType.SetAttributeWildcard(anyAttribute); anyType.ElementDecl.AnyAttribute = anyAttribute; }
private static XmlSchemaComplexType CreateAnyType(XmlSchemaContentProcessing processContents) { XmlSchemaComplexType localAnyType = new XmlSchemaComplexType(); localAnyType.SetQualifiedName(DatatypeImplementation.QnAnyType); XmlSchemaAny anyElement = new XmlSchemaAny(); anyElement.MinOccurs = decimal.Zero; anyElement.MaxOccurs = decimal.MaxValue; anyElement.ProcessContents = processContents; anyElement.BuildNamespaceList(null); XmlSchemaSequence seq = new XmlSchemaSequence(); seq.Items.Add(anyElement); localAnyType.SetContentTypeParticle(seq); localAnyType.SetContentType(XmlSchemaContentType.Mixed); localAnyType.ElementDecl = SchemaElementDecl.CreateAnyTypeElementDecl(); localAnyType.ElementDecl.SchemaType = localAnyType; //Create contentValidator for Any ParticleContentValidator contentValidator = new ParticleContentValidator(XmlSchemaContentType.Mixed); contentValidator.Start(); contentValidator.OpenGroup(); contentValidator.AddNamespaceList(anyElement.NamespaceList !, anyElement); contentValidator.AddStar(); contentValidator.CloseGroup(); ContentValidator anyContentValidator = contentValidator.Finish(true); localAnyType.ElementDecl.ContentValidator = anyContentValidator; XmlSchemaAnyAttribute anyAttribute = new XmlSchemaAnyAttribute(); anyAttribute.ProcessContents = processContents; anyAttribute.BuildNamespaceList(null); localAnyType.SetAttributeWildcard(anyAttribute); localAnyType.ElementDecl.AnyAttribute = anyAttribute; return(localAnyType); }
private static void CleanupComplexType(XmlSchemaComplexType complexType) { if (complexType.ContentModel != null) { if (complexType.ContentModel is XmlSchemaSimpleContent) { XmlSchemaSimpleContent contentModel = (XmlSchemaSimpleContent) complexType.ContentModel; if (contentModel.Content is XmlSchemaSimpleContentExtension) { XmlSchemaSimpleContentExtension content = (XmlSchemaSimpleContentExtension) contentModel.Content; CleanupAttributes(content.Attributes); } else { XmlSchemaSimpleContentRestriction restriction = (XmlSchemaSimpleContentRestriction) contentModel.Content; CleanupAttributes(restriction.Attributes); } } else { XmlSchemaComplexContent content2 = (XmlSchemaComplexContent) complexType.ContentModel; if (content2.Content is XmlSchemaComplexContentExtension) { XmlSchemaComplexContentExtension extension2 = (XmlSchemaComplexContentExtension) content2.Content; CleanupParticle(extension2.Particle); CleanupAttributes(extension2.Attributes); } else { XmlSchemaComplexContentRestriction restriction2 = (XmlSchemaComplexContentRestriction) content2.Content; CleanupParticle(restriction2.Particle); CleanupAttributes(restriction2.Attributes); } } } else { CleanupParticle(complexType.Particle); CleanupAttributes(complexType.Attributes); } complexType.LocalElements.Clear(); complexType.AttributeUses.Clear(); complexType.SetAttributeWildcard(null); complexType.SetContentTypeParticle(XmlSchemaParticle.Empty); complexType.ElementDecl = null; }
private void CompileLocalAttributes(XmlSchemaComplexType baseType, XmlSchemaComplexType derivedType, XmlSchemaObjectCollection attributes, XmlSchemaAnyAttribute anyAttribute, XmlSchemaDerivationMethod derivedBy) { XmlSchemaAnyAttribute b = (baseType != null) ? baseType.AttributeWildcard : null; for (int i = 0; i < attributes.Count; i++) { XmlSchemaAttribute xa = attributes[i] as XmlSchemaAttribute; if (xa != null) { if (xa.Use != XmlSchemaUse.Prohibited) { this.CompileAttribute(xa); } if ((xa.Use != XmlSchemaUse.Prohibited) || (((xa.Use == XmlSchemaUse.Prohibited) && (derivedBy == XmlSchemaDerivationMethod.Restriction)) && (baseType != XmlSchemaComplexType.AnyType))) { if (derivedType.AttributeUses[xa.QualifiedName] == null) { derivedType.AttributeUses.Add(xa.QualifiedName, xa); } else { base.SendValidationEvent("Sch_DupAttributeUse", xa.QualifiedName.ToString(), xa); } } else { base.SendValidationEvent("Sch_AttributeIgnored", xa.QualifiedName.ToString(), xa, XmlSeverityType.Warning); } } else { XmlSchemaAttributeGroupRef source = (XmlSchemaAttributeGroupRef) attributes[i]; XmlSchemaAttributeGroup attributeGroup = (XmlSchemaAttributeGroup) this.schema.AttributeGroups[source.RefName]; if (attributeGroup != null) { this.CompileAttributeGroup(attributeGroup); foreach (XmlSchemaAttribute attribute3 in attributeGroup.AttributeUses.Values) { if ((attribute3.Use != XmlSchemaUse.Prohibited) || (((attribute3.Use == XmlSchemaUse.Prohibited) && (derivedBy == XmlSchemaDerivationMethod.Restriction)) && (baseType != XmlSchemaComplexType.AnyType))) { if (derivedType.AttributeUses[attribute3.QualifiedName] == null) { derivedType.AttributeUses.Add(attribute3.QualifiedName, attribute3); } else { base.SendValidationEvent("Sch_DupAttributeUse", attribute3.QualifiedName.ToString(), source); } } else { base.SendValidationEvent("Sch_AttributeIgnored", attribute3.QualifiedName.ToString(), attribute3, XmlSeverityType.Warning); } } anyAttribute = this.CompileAnyAttributeIntersection(anyAttribute, attributeGroup.AttributeWildcard); } else { base.SendValidationEvent("Sch_UndefAttributeGroupRef", source.RefName.ToString(), source); } } } if (baseType != null) { if (derivedBy == XmlSchemaDerivationMethod.Extension) { derivedType.SetAttributeWildcard(this.CompileAnyAttributeUnion(anyAttribute, b)); foreach (XmlSchemaAttribute attribute4 in baseType.AttributeUses.Values) { XmlSchemaAttribute attribute5 = (XmlSchemaAttribute) derivedType.AttributeUses[attribute4.QualifiedName]; if (attribute5 != null) { if ((attribute5.AttributeSchemaType != attribute4.AttributeSchemaType) || (attribute4.Use == XmlSchemaUse.Prohibited)) { base.SendValidationEvent("Sch_InvalidAttributeExtension", attribute5); } } else { derivedType.AttributeUses.Add(attribute4.QualifiedName, attribute4); } } } else { if ((anyAttribute != null) && ((b == null) || !XmlSchemaAnyAttribute.IsSubset(anyAttribute, b))) { base.SendValidationEvent("Sch_InvalidAnyAttributeRestriction", derivedType); } else { derivedType.SetAttributeWildcard(anyAttribute); } foreach (XmlSchemaAttribute attribute6 in baseType.AttributeUses.Values) { XmlSchemaAttribute attribute7 = (XmlSchemaAttribute) derivedType.AttributeUses[attribute6.QualifiedName]; if (attribute7 == null) { derivedType.AttributeUses.Add(attribute6.QualifiedName, attribute6); } else if ((attribute6.Use == XmlSchemaUse.Prohibited) && (attribute7.Use != XmlSchemaUse.Prohibited)) { base.SendValidationEvent("Sch_AttributeRestrictionProhibited", attribute7); } else if ((attribute7.Use != XmlSchemaUse.Prohibited) && (((attribute6.AttributeSchemaType == null) || (attribute7.AttributeSchemaType == null)) || !XmlSchemaType.IsDerivedFrom(attribute7.AttributeSchemaType, attribute6.AttributeSchemaType, XmlSchemaDerivationMethod.Empty))) { base.SendValidationEvent("Sch_AttributeRestrictionInvalid", attribute7); } } foreach (XmlSchemaAttribute attribute8 in derivedType.AttributeUses.Values) { if ((((XmlSchemaAttribute) baseType.AttributeUses[attribute8.QualifiedName]) == null) && ((b == null) || !b.Allows(attribute8.QualifiedName))) { base.SendValidationEvent("Sch_AttributeRestrictionInvalidFromWildcard", attribute8); } } } } else { derivedType.SetAttributeWildcard(anyAttribute); } }
private void CleanupComplexType(XmlSchemaComplexType complexType) { if (complexType.QualifiedName == DatatypeImplementation.QnAnyType) { //if it is built-in anyType dont clean it. return; } if (complexType.ContentModel != null) { //simpleContent or complexContent if (complexType.ContentModel is XmlSchemaSimpleContent) { XmlSchemaSimpleContent simpleContent = (XmlSchemaSimpleContent)complexType.ContentModel; if (simpleContent.Content is XmlSchemaSimpleContentExtension) { XmlSchemaSimpleContentExtension simpleExtension = (XmlSchemaSimpleContentExtension)simpleContent.Content; CleanupAttributes(simpleExtension.Attributes); } else { //simpleContent.Content is XmlSchemaSimpleContentRestriction XmlSchemaSimpleContentRestriction simpleRestriction = (XmlSchemaSimpleContentRestriction)simpleContent.Content; CleanupAttributes(simpleRestriction.Attributes); } } else { // complexType.ContentModel is XmlSchemaComplexContent XmlSchemaComplexContent complexContent = (XmlSchemaComplexContent)complexType.ContentModel; if (complexContent.Content is XmlSchemaComplexContentExtension) { XmlSchemaComplexContentExtension complexExtension = (XmlSchemaComplexContentExtension)complexContent.Content; CleanupParticle(complexExtension.Particle); CleanupAttributes(complexExtension.Attributes); } else { //XmlSchemaComplexContentRestriction XmlSchemaComplexContentRestriction complexRestriction = (XmlSchemaComplexContentRestriction)complexContent.Content; CleanupParticle(complexRestriction.Particle); CleanupAttributes(complexRestriction.Attributes); } } } else { //equals XmlSchemaComplexContent with baseType is anyType CleanupParticle(complexType.Particle); CleanupAttributes(complexType.Attributes); } complexType.LocalElements.Clear(); complexType.AttributeUses.Clear(); complexType.SetAttributeWildcard(null); complexType.SetContentTypeParticle(XmlSchemaParticle.Empty); complexType.ElementDecl = null; complexType.HasWildCard = false; //Clean up the original type if this is a redefined type if (complexType.Redefined != null) { CleanupComplexType(complexType.Redefined as XmlSchemaComplexType); } }
private void CompileLocalAttributes(XmlSchemaComplexType baseType, XmlSchemaComplexType derivedType, XmlSchemaObjectCollection attributes, XmlSchemaAnyAttribute anyAttribute, XmlSchemaDerivationMethod derivedBy) { XmlSchemaAnyAttribute baseAttributeWildcard = baseType != null ? baseType.AttributeWildcard : null; for (int i = 0; i < attributes.Count; ++i) { XmlSchemaAttribute attr = attributes[i] as XmlSchemaAttribute; if (attr != null) { if (attr.Use != XmlSchemaUse.Prohibited) { CompileAttribute(attr); } if (attr.Use != XmlSchemaUse.Prohibited || (attr.Use == XmlSchemaUse.Prohibited && derivedBy == XmlSchemaDerivationMethod.Restriction && baseType != XmlSchemaComplexType.AnyType)) { if (derivedType.AttributeUses[attr.QualifiedName] == null) { derivedType.AttributeUses.Add(attr.QualifiedName, attr); } else { SendValidationEvent(Res.Sch_DupAttributeUse, attr.QualifiedName.ToString(), attr); } } else { SendValidationEvent(Res.Sch_AttributeIgnored, attr.QualifiedName.ToString(), attr, XmlSeverityType.Warning); } } else { // is XmlSchemaAttributeGroupRef XmlSchemaAttributeGroupRef attributeGroupRef = (XmlSchemaAttributeGroupRef) attributes[i]; XmlSchemaAttributeGroup attributeGroup = (XmlSchemaAttributeGroup)attributeGroups[attributeGroupRef.RefName]; if (attributeGroup != null) { CompileAttributeGroup(attributeGroup); foreach (XmlSchemaAttribute attribute in attributeGroup.AttributeUses.Values) { if (attribute.Use != XmlSchemaUse.Prohibited || (attribute.Use == XmlSchemaUse.Prohibited && derivedBy == XmlSchemaDerivationMethod.Restriction && baseType != XmlSchemaComplexType.AnyType)) { if (derivedType.AttributeUses[attribute.QualifiedName] == null) { derivedType.AttributeUses.Add(attribute.QualifiedName, attribute); } else { SendValidationEvent(Res.Sch_DupAttributeUse, attribute.QualifiedName.ToString(), attributeGroupRef); } } else { SendValidationEvent(Res.Sch_AttributeIgnored, attribute.QualifiedName.ToString(), attribute, XmlSeverityType.Warning); } } anyAttribute = CompileAnyAttributeIntersection(anyAttribute, attributeGroup.AttributeWildcard); } else { SendValidationEvent(Res.Sch_UndefAttributeGroupRef, attributeGroupRef.RefName.ToString(), attributeGroupRef); } } } // check derivation rules if (baseType != null) { if (derivedBy == XmlSchemaDerivationMethod.Extension) { derivedType.SetAttributeWildcard(CompileAnyAttributeUnion(anyAttribute, baseAttributeWildcard)); foreach(XmlSchemaAttribute attributeBase in baseType.AttributeUses.Values) { XmlSchemaAttribute attribute = (XmlSchemaAttribute)derivedType.AttributeUses[attributeBase.QualifiedName]; if (attribute == null) { derivedType.AttributeUses.Add(attributeBase.QualifiedName, attributeBase); } else { Debug.Assert(attribute.Use != XmlSchemaUse.Prohibited); if (attributeBase.Use != XmlSchemaUse.Prohibited && attribute.AttributeSchemaType != attributeBase.AttributeSchemaType) { //Extension allows previously prohibited attributes to be re-added, SendValidationEvent(Res.Sch_InvalidAttributeExtension, attribute); } } } } else { // derivedBy == XmlSchemaDerivationMethod.Restriction // Schema Component Constraint: Derivation Valid (Restriction, Complex) if ((anyAttribute != null) && (baseAttributeWildcard == null || !XmlSchemaAnyAttribute.IsSubset(anyAttribute, baseAttributeWildcard) || !IsProcessContentsRestricted(baseType, anyAttribute, baseAttributeWildcard)) ) { SendValidationEvent(Res.Sch_InvalidAnyAttributeRestriction, derivedType); } else { derivedType.SetAttributeWildcard(anyAttribute); //complete wildcard } // Add form the base foreach(XmlSchemaAttribute attributeBase in baseType.AttributeUses.Values) { XmlSchemaAttribute attribute = (XmlSchemaAttribute)derivedType.AttributeUses[attributeBase.QualifiedName]; if (attribute == null) { derivedType.AttributeUses.Add(attributeBase.QualifiedName, attributeBase); } else { if (attributeBase.Use == XmlSchemaUse.Prohibited && attribute.Use != XmlSchemaUse.Prohibited) { #if DEBUG string position = string.Empty; if (derivedType.SourceUri != null) { position = " in " + derivedType.SourceUri + "(" + derivedType.LineNumber + ", " + derivedType.LinePosition + ")"; } Debug.WriteLineIf(DiagnosticsSwitches.XmlSchema.TraceError, "Invalid complexType attributes restriction" + position); Debug.WriteLineIf(DiagnosticsSwitches.XmlSchema.TraceError, " Base " + DumpAttributes(baseType.AttributeUses, baseType.AttributeWildcard)); Debug.WriteLineIf(DiagnosticsSwitches.XmlSchema.TraceError, " Derived " + DumpAttributes(derivedType.AttributeUses, derivedType.AttributeWildcard)); #endif SendValidationEvent(Res.Sch_AttributeRestrictionProhibited, attribute); } else if (attributeBase.Use == XmlSchemaUse.Required && (attribute.Use != XmlSchemaUse.Required)) { //If base is required, derived should also be required SendValidationEvent(Res.Sch_AttributeUseInvalid, attribute); } else if (attribute.Use == XmlSchemaUse.Prohibited) { continue; } else if (attributeBase.AttributeSchemaType == null || attribute.AttributeSchemaType == null || !XmlSchemaType.IsDerivedFrom(attribute.AttributeSchemaType, attributeBase.AttributeSchemaType, XmlSchemaDerivationMethod.Empty)) { SendValidationEvent(Res.Sch_AttributeRestrictionInvalid, attribute); } else if (!IsFixedEqual(attributeBase.AttDef, attribute.AttDef)) { SendValidationEvent(Res.Sch_AttributeFixedInvalid, attribute); } } } // Check additional ones are valid restriction of base's wildcard foreach(XmlSchemaAttribute attribute in derivedType.AttributeUses.Values) { XmlSchemaAttribute attributeBase = (XmlSchemaAttribute)baseType.AttributeUses[attribute.QualifiedName]; if (attributeBase != null) { continue; } if (baseAttributeWildcard == null || !baseAttributeWildcard.Allows(attribute.QualifiedName)) { #if DEBUG string position = string.Empty; if (derivedType.SourceUri != null) { position = " in " + derivedType.SourceUri + "(" + derivedType.LineNumber + ", " + derivedType.LinePosition + ")"; } Debug.WriteLineIf(DiagnosticsSwitches.XmlSchema.TraceError, "Invalid complexType attributes restriction" + position); Debug.WriteLineIf(DiagnosticsSwitches.XmlSchema.TraceError, " Base " + DumpAttributes(baseType.AttributeUses, baseType.AttributeWildcard)); Debug.WriteLineIf(DiagnosticsSwitches.XmlSchema.TraceError, " Derived " + DumpAttributes(derivedType.AttributeUses, derivedType.AttributeWildcard)); #endif SendValidationEvent(Res.Sch_AttributeRestrictionInvalidFromWildcard, attribute); } } } } else { derivedType.SetAttributeWildcard(anyAttribute); } }
static XmlSchemaComplexType CreateAnyType(XmlSchemaContentProcessing processContents) { XmlSchemaComplexType localAnyType = new XmlSchemaComplexType(); localAnyType.SetQualifiedName(DatatypeImplementation.QnAnyType); XmlSchemaAny anyElement = new XmlSchemaAny(); anyElement.MinOccurs = decimal.Zero; anyElement.MaxOccurs = decimal.MaxValue; anyElement.ProcessContents = processContents; anyElement.BuildNamespaceList(null); XmlSchemaSequence seq = new XmlSchemaSequence(); seq.Items.Add(anyElement); localAnyType.SetContentTypeParticle(seq); localAnyType.SetContentType(XmlSchemaContentType.Mixed); localAnyType.ElementDecl = SchemaElementDecl.CreateAnyTypeElementDecl(); localAnyType.ElementDecl.SchemaType = localAnyType; //Create contentValidator for Any ParticleContentValidator contentValidator = new ParticleContentValidator(XmlSchemaContentType.Mixed); contentValidator.Start(); contentValidator.OpenGroup(); contentValidator.AddNamespaceList(anyElement.NamespaceList, anyElement); contentValidator.AddStar(); contentValidator.CloseGroup(); ContentValidator anyContentValidator = contentValidator.Finish(true); localAnyType.ElementDecl.ContentValidator = anyContentValidator; XmlSchemaAnyAttribute anyAttribute = new XmlSchemaAnyAttribute(); anyAttribute.ProcessContents = processContents; anyAttribute.BuildNamespaceList(null); localAnyType.SetAttributeWildcard(anyAttribute); localAnyType.ElementDecl.AnyAttribute = anyAttribute; return localAnyType; }
private void CleanupComplexType(XmlSchemaComplexType complexType) { if (complexType.QualifiedName != DatatypeImplementation.QnAnyType) { if (complexType.ContentModel != null) { if (complexType.ContentModel is XmlSchemaSimpleContent) { XmlSchemaSimpleContent contentModel = (XmlSchemaSimpleContent) complexType.ContentModel; if (contentModel.Content is XmlSchemaSimpleContentExtension) { XmlSchemaSimpleContentExtension content = (XmlSchemaSimpleContentExtension) contentModel.Content; this.CleanupAttributes(content.Attributes); } else { XmlSchemaSimpleContentRestriction restriction = (XmlSchemaSimpleContentRestriction) contentModel.Content; this.CleanupAttributes(restriction.Attributes); } } else { XmlSchemaComplexContent content2 = (XmlSchemaComplexContent) complexType.ContentModel; if (content2.Content is XmlSchemaComplexContentExtension) { XmlSchemaComplexContentExtension extension2 = (XmlSchemaComplexContentExtension) content2.Content; this.CleanupParticle(extension2.Particle); this.CleanupAttributes(extension2.Attributes); } else { XmlSchemaComplexContentRestriction restriction2 = (XmlSchemaComplexContentRestriction) content2.Content; this.CleanupParticle(restriction2.Particle); this.CleanupAttributes(restriction2.Attributes); } } } else { this.CleanupParticle(complexType.Particle); this.CleanupAttributes(complexType.Attributes); } complexType.LocalElements.Clear(); complexType.AttributeUses.Clear(); complexType.SetAttributeWildcard(null); complexType.SetContentTypeParticle(XmlSchemaParticle.Empty); complexType.ElementDecl = null; complexType.HasWildCard = false; if (complexType.Redefined != null) { this.CleanupComplexType(complexType.Redefined as XmlSchemaComplexType); } } }
private static void CleanupComplexType(XmlSchemaComplexType complexType) { if (complexType.ContentModel != null) { //simpleContent or complexContent if (complexType.ContentModel is XmlSchemaSimpleContent) { XmlSchemaSimpleContent simpleContent = (XmlSchemaSimpleContent)complexType.ContentModel; if (simpleContent.Content is XmlSchemaSimpleContentExtension) { XmlSchemaSimpleContentExtension simpleExtension = (XmlSchemaSimpleContentExtension)simpleContent.Content; CleanupAttributes(simpleExtension.Attributes); } else { //simpleContent.Content is XmlSchemaSimpleContentRestriction XmlSchemaSimpleContentRestriction simpleRestriction = (XmlSchemaSimpleContentRestriction)simpleContent.Content; CleanupAttributes(simpleRestriction.Attributes); } } else { // complexType.ContentModel is XmlSchemaComplexContent XmlSchemaComplexContent complexContent = (XmlSchemaComplexContent)complexType.ContentModel; if (complexContent.Content is XmlSchemaComplexContentExtension) { XmlSchemaComplexContentExtension complexExtension = (XmlSchemaComplexContentExtension)complexContent.Content; CleanupParticle(complexExtension.Particle); CleanupAttributes(complexExtension.Attributes); } else { //XmlSchemaComplexContentRestriction XmlSchemaComplexContentRestriction complexRestriction = (XmlSchemaComplexContentRestriction)complexContent.Content; CleanupParticle(complexRestriction.Particle); CleanupAttributes(complexRestriction.Attributes); } } } else { //equals XmlSchemaComplexContent with baseType is anyType CleanupParticle(complexType.Particle); CleanupAttributes(complexType.Attributes); } complexType.LocalElements.Clear(); complexType.AttributeUses.Clear(); complexType.SetAttributeWildcard(null); complexType.SetContentTypeParticle(XmlSchemaParticle.Empty); complexType.ElementDecl = null; }
private void CompileLocalAttributes(XmlSchemaComplexType baseType, XmlSchemaComplexType derivedType, XmlSchemaObjectCollection attributes, XmlSchemaAnyAttribute anyAttribute, XmlSchemaDerivationMethod derivedBy) { XmlSchemaAnyAttribute baseAttributeWildcard = baseType != null ? baseType.AttributeWildcard : null; foreach (XmlSchemaObject obj in attributes) { if (obj is XmlSchemaAttribute) { XmlSchemaAttribute attribute = (XmlSchemaAttribute)obj; if (attribute.Use != XmlSchemaUse.Prohibited) { CompileAttribute(attribute); } if (derivedType.AttributeUses[attribute.QualifiedName] == null) { derivedType.AttributeUses.Add(attribute.QualifiedName, attribute); } else { SendValidationEvent(Res.Sch_DupAttributeUse, attribute.QualifiedName.ToString(), attribute); } } else { // is XmlSchemaAttributeGroupRef XmlSchemaAttributeGroupRef attributeGroupRef = (XmlSchemaAttributeGroupRef)obj; XmlSchemaAttributeGroup attributeGroup = (XmlSchemaAttributeGroup)this.schema.AttributeGroups[attributeGroupRef.RefName]; if (attributeGroup != null) { CompileAttributeGroup(attributeGroup); foreach (XmlSchemaAttribute attribute in attributeGroup.AttributeUses.Values) { if (derivedType.AttributeUses[attribute.QualifiedName] == null) { derivedType.AttributeUses.Add(attribute.QualifiedName, attribute); } else { SendValidationEvent(Res.Sch_DupAttributeUse, attribute.QualifiedName.ToString(), attributeGroupRef); } } anyAttribute = CompileAnyAttributeIntersection(anyAttribute, attributeGroup.AttributeWildcard); } else { SendValidationEvent(Res.Sch_UndefAttributeGroupRef, attributeGroupRef.RefName.ToString(), attributeGroupRef); } } } // check derivation rules if (baseType != null) { if (derivedBy == XmlSchemaDerivationMethod.Extension) { derivedType.SetAttributeWildcard(CompileAnyAttributeUnion(anyAttribute, baseAttributeWildcard)); foreach(XmlSchemaAttribute attributeBase in baseType.AttributeUses.Values) { XmlSchemaAttribute attribute = (XmlSchemaAttribute)derivedType.AttributeUses[attributeBase.QualifiedName]; if (attribute != null) { if (attribute.Use != XmlSchemaUse.Prohibited && attributeBase.Use != XmlSchemaUse.Prohibited) { if (attribute.AttributeType != attributeBase.AttributeType) { SendValidationEvent(Res.Sch_InvalidAttributeExtension, attribute); } } } else { derivedType.AttributeUses.Add(attributeBase.QualifiedName, attributeBase); } } } else { // derivedBy == XmlSchemaDerivationMethod.Restriction // Schema Component Constraint: Derivation Valid (Restriction, Complex) if ((anyAttribute != null) && (baseAttributeWildcard == null || !XmlSchemaAnyAttribute.IsSubset(anyAttribute, baseAttributeWildcard))) { SendValidationEvent(Res.Sch_InvalidAnyAttributeRestriction, derivedType); } else { derivedType.SetAttributeWildcard(anyAttribute); //complete wildcard } // Add form the base foreach(XmlSchemaAttribute attributeBase in baseType.AttributeUses.Values) { XmlSchemaAttribute attribute = (XmlSchemaAttribute)derivedType.AttributeUses[attributeBase.QualifiedName]; if (attribute == null) { derivedType.AttributeUses.Add(attributeBase.QualifiedName, attributeBase); } else { if (attributeBase.Use == XmlSchemaUse.Prohibited && attribute.Use != XmlSchemaUse.Prohibited) { #if DEBUG string position = string.Empty; if (derivedType.SourceUri != null) { position = " in " + derivedType.SourceUri + "(" + derivedType.LineNumber + ", " + derivedType.LinePosition + ")"; } Debug.WriteLineIf(CompModSwitches.XmlSchema.TraceError, "Invalid complexType attributes restriction" + position); Debug.WriteLineIf(CompModSwitches.XmlSchema.TraceError, " Base " + DumpAttributes(baseType.AttributeUses, baseType.AttributeWildcard)); Debug.WriteLineIf(CompModSwitches.XmlSchema.TraceError, " Derived " + DumpAttributes(derivedType.AttributeUses, derivedType.AttributeWildcard)); #endif SendValidationEvent(Res.Sch_AttributeRestrictionProhibited, attribute); } else if (attribute.Use == XmlSchemaUse.Prohibited) { continue; } else if (attributeBase.AttributeType == null || attribute.AttributeType == null || !XmlSchemaType.IsDerivedFrom(attribute.AttributeType, attributeBase.AttributeType, XmlSchemaDerivationMethod.Empty)) { SendValidationEvent(Res.Sch_AttributeRestrictionInvalid, attribute); } } } // Check additional ones are valid restriction of base's wildcard foreach(XmlSchemaAttribute attribute in derivedType.AttributeUses.Values) { XmlSchemaAttribute attributeBase = (XmlSchemaAttribute)baseType.AttributeUses[attribute.QualifiedName]; if (attributeBase != null) { continue; } if (baseAttributeWildcard == null || !baseAttributeWildcard.Allows(attribute.QualifiedName)) { #if DEBUG string position = string.Empty; if (derivedType.SourceUri != null) { position = " in " + derivedType.SourceUri + "(" + derivedType.LineNumber + ", " + derivedType.LinePosition + ")"; } Debug.WriteLineIf(CompModSwitches.XmlSchema.TraceError, "Invalid complexType attributes restriction" + position); Debug.WriteLineIf(CompModSwitches.XmlSchema.TraceError, " Base " + DumpAttributes(baseType.AttributeUses, baseType.AttributeWildcard)); Debug.WriteLineIf(CompModSwitches.XmlSchema.TraceError, " Derived " + DumpAttributes(derivedType.AttributeUses, derivedType.AttributeWildcard)); #endif SendValidationEvent(Res.Sch_AttributeRestrictionInvalidFromWildcard, attribute); } } } } else { derivedType.SetAttributeWildcard(anyAttribute); } }
private static XmlSchemaComplexType CreateAnyType(XmlSchemaContentProcessing processContents) { XmlSchemaComplexType type = new XmlSchemaComplexType(); type.SetQualifiedName(DatatypeImplementation.QnAnyType); XmlSchemaAny item = new XmlSchemaAny { MinOccurs = 0M, MaxOccurs = 79228162514264337593543950335M, ProcessContents = processContents }; item.BuildNamespaceList(null); XmlSchemaSequence sequence = new XmlSchemaSequence(); sequence.Items.Add(item); type.SetContentTypeParticle(sequence); type.SetContentType(XmlSchemaContentType.Mixed); type.ElementDecl = SchemaElementDecl.CreateAnyTypeElementDecl(); type.ElementDecl.SchemaType = type; ParticleContentValidator validator = new ParticleContentValidator(XmlSchemaContentType.Mixed); validator.Start(); validator.OpenGroup(); validator.AddNamespaceList(item.NamespaceList, item); validator.AddStar(); validator.CloseGroup(); ContentValidator validator2 = validator.Finish(true); type.ElementDecl.ContentValidator = validator2; XmlSchemaAnyAttribute attribute = new XmlSchemaAnyAttribute { ProcessContents = processContents }; attribute.BuildNamespaceList(null); type.SetAttributeWildcard(attribute); type.ElementDecl.AnyAttribute = attribute; return type; }