Summary description for XmlSchemaObjectTable.
Example #1
1
		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 XmlSchemaRedefine()
 {
     attributeGroups = new XmlSchemaObjectTable();
     groups          = new XmlSchemaObjectTable();
     items           = new XmlSchemaObjectCollection(this);
     schemaTypes     = new XmlSchemaObjectTable();
 }
Example #3
0
 internal override void ValidateUniqueParticleAttribution(XmlSchemaObjectTable qnames, ArrayList nsNames, ValidationEventHandler h, XmlSchema schema)
 {
     if (this.TargetGroup != null)
     {
         this.TargetGroup.Particle.ValidateUniqueParticleAttribution(qnames, nsNames, h, schema);
     }
 }
Example #4
0
		public XmlSchemaRedefine()
		{
			attributeGroups = new XmlSchemaObjectTable();
			groups = new XmlSchemaObjectTable();
			items = new XmlSchemaObjectCollection(this);
			schemaTypes = new XmlSchemaObjectTable();
		}
Example #5
0
 internal override void ValidateUniqueTypeAttribution(XmlSchemaObjectTable labels, ValidationEventHandler h, XmlSchema schema)
 {
     if (this.TargetGroup != null)
     {
         this.TargetGroup.Particle.ValidateUniqueTypeAttribution(labels, h, schema);
     }
 }
Example #6
0
 private void ProcessNewSubstitutionGroups(XmlSchemaObjectTable substitutionGroupsTable, bool resolve)
 {
     foreach (XmlSchemaSubstitutionGroup group in substitutionGroupsTable.Values)
     {
         if (resolve)
         {
             this.ResolveSubstitutionGroup(group, substitutionGroupsTable);
         }
         XmlQualifiedName           examplar = group.Examplar;
         XmlSchemaSubstitutionGroup group2   = (XmlSchemaSubstitutionGroup)this.substitutionGroups[examplar];
         if (group2 != null)
         {
             for (int i = 0; i < group.Members.Count; i++)
             {
                 if (!group2.Members.Contains(group.Members[i]))
                 {
                     group2.Members.Add(group.Members[i]);
                 }
             }
         }
         else
         {
             this.AddToTable(this.substitutionGroups, examplar, group);
         }
     }
 }
Example #7
0
 internal override void ValidateUniqueTypeAttribution(XmlSchemaObjectTable labels,
                                                      ValidationEventHandler h, XmlSchema schema)
 {
     foreach (XmlSchemaParticle p in this.Items)
     {
         p.ValidateUniqueTypeAttribution(labels, h, schema);
     }
 }
 private void ClearCompiledState()
 {
     this.attributeUses = null;
     this.localElements = null;
     this.attributeWildcard = null;
     this.contentTypeParticle = XmlSchemaParticle.Empty;
     this.blockResolved = XmlSchemaDerivationMethod.None;
 }
Example #9
0
 internal override void ValidateUniqueTypeAttribution(XmlSchemaObjectTable labels, ValidationEventHandler h, XmlSchema schema)
 {
     foreach (XmlSchemaObject xmlSchemaObject in this.Items)
     {
         XmlSchemaElement xmlSchemaElement = (XmlSchemaElement)xmlSchemaObject;
         xmlSchemaElement.ValidateUniqueTypeAttribution(labels, h, schema);
     }
 }
Example #10
0
 internal override void ValidateUniqueParticleAttribution(XmlSchemaObjectTable qnames, ArrayList nsNames, ValidationEventHandler h, XmlSchema schema)
 {
     foreach (XmlSchemaObject xmlSchemaObject in this.Items)
     {
         XmlSchemaElement xmlSchemaElement = (XmlSchemaElement)xmlSchemaObject;
         xmlSchemaElement.ValidateUniqueParticleAttribution(qnames, nsNames, h, schema);
     }
 }
 private void ClearCompiledState()
 {
     this.attributeUses = null;
     this.localElements = null;
     this.attributeWildcard = null;
     this.contentTypeParticle = XmlSchemaParticle.Empty;
     this.blockResolved = XmlSchemaDerivationMethod.None;
 }
Example #12
0
 internal void Preprocess(XmlSchema schema, string targetNamespace) {          
     this.namespaceManager = new XmlNamespaceManager(this.nameTable);
     this.schema = schema;
     this.ids = schema.Ids;
     this.identityConstraints = schema.IdentityConstraints;
     ValidateIdAttribute(schema);
     Preprocess(schema, targetNamespace, Compositor.Root);
 }
        // Adds all items in the XmlSchemaObjectTable to the specified XmlSchema
        //
        private static void AddTableToSchema(XmlSchema outSch, XmlSchemaObjectTable table)
        {
            var e = table.GetEnumerator();

            while (e.MoveNext())
            {
                outSch.Items.Add((XmlSchemaObject)e.Value);
            }
        }
Example #14
0
 private void ClearCompiledState()
 {
     //Re-set post-compiled state for cloned object
     _attributeUses       = null;
     _localElements       = null;
     _attributeWildcard   = null;
     _contentTypeParticle = XmlSchemaParticle.Empty;
     _blockResolved       = XmlSchemaDerivationMethod.None;
 }
Example #15
0
 private void ValidateUPAOnHeadingOptionalComponents(XmlSchemaObjectTable qnames, ArrayList nsNames, ValidationEventHandler h, XmlSchema schema)
 {
     foreach (XmlSchemaObject xmlSchemaObject in this.Items)
     {
         XmlSchemaParticle xmlSchemaParticle = (XmlSchemaParticle)xmlSchemaObject;
         xmlSchemaParticle.ValidateUniqueParticleAttribution(qnames, nsNames, h, schema);
         if (xmlSchemaParticle.ValidatedMinOccurs != 0m)
         {
             break;
         }
     }
 }
Example #16
0
 internal override void ValidateUniqueParticleAttribution(XmlSchemaObjectTable qnames, ArrayList nsNames, ValidationEventHandler h, XmlSchema schema)
 {
     foreach (object obj in nsNames)
     {
         XmlSchemaAny other = (XmlSchemaAny)obj;
         if (!this.ExamineAttributeWildcardIntersection(other, h, schema))
         {
             base.error(h, "Ambiguous -any- particle was found.");
         }
     }
     nsNames.Add(this);
 }
Example #17
0
 void ValidateUPAOnHeadingOptionalComponents(XmlSchemaObjectTable qnames, ArrayList nsNames,
                                             ValidationEventHandler h, XmlSchema schema)
 {
     // heading optional components
     foreach (XmlSchemaParticle p in this.Items)
     {
         p.ValidateUniqueParticleAttribution(qnames, nsNames, h, schema);
         if (p.ValidatedMinOccurs != 0)
         {
             break;
         }
     }
 }
 public Compiler(XmlNameTable nameTable, ValidationEventHandler eventHandler, XmlSchema schemaForSchema, XmlSchemaCompilationSettings compilationSettings) : base(nameTable, null, eventHandler, compilationSettings)
 {
     this.attributes = new XmlSchemaObjectTable();
     this.attributeGroups = new XmlSchemaObjectTable();
     this.elements = new XmlSchemaObjectTable();
     this.schemaTypes = new XmlSchemaObjectTable();
     this.groups = new XmlSchemaObjectTable();
     this.notations = new XmlSchemaObjectTable();
     this.examplars = new XmlSchemaObjectTable();
     this.identityConstraints = new XmlSchemaObjectTable();
     this.complexTypeStack = new Stack();
     this.schemasToCompile = new Hashtable();
     this.importedSchemas = new Hashtable();
     this.schemaForSchema = schemaForSchema;
 }
Example #19
0
 private bool AddToTable(XmlSchemaObjectTable table, XmlQualifiedName qname, XmlSchemaObject item)
 {
     if (qname.Name.Length != 0)
     {
         XmlSchemaObject obj2 = table[qname];
         if (obj2 != null)
         {
             if ((obj2 == item) || (obj2.SourceUri == item.SourceUri))
             {
                 return(true);
             }
             string res = string.Empty;
             if (item is XmlSchemaComplexType)
             {
                 res = "Sch_DupComplexType";
             }
             else if (item is XmlSchemaSimpleType)
             {
                 res = "Sch_DupSimpleType";
             }
             else if (item is XmlSchemaElement)
             {
                 res = "Sch_DupGlobalElement";
             }
             else if (item is XmlSchemaAttribute)
             {
                 if (qname.Namespace == "http://www.w3.org/XML/1998/namespace")
                 {
                     XmlSchemaObject obj3 = Preprocessor.GetBuildInSchema().Attributes[qname];
                     if (obj2 == obj3)
                     {
                         table.Insert(qname, item);
                         return(true);
                     }
                     if (item == obj3)
                     {
                         return(true);
                     }
                 }
                 res = "Sch_DupGlobalAttribute";
             }
             this.SendValidationEvent(new XmlSchemaException(res, qname.ToString()), XmlSeverityType.Error);
             return(false);
         }
         table.Add(qname, item);
     }
     return(true);
 }
Example #20
0
 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);
     }
 }
Example #21
0
 public XmlSchema()
 {
     attributeFormDefault = XmlSchemaForm.None;
     blockDefault         = XmlSchemaDerivationMethod.None;
     elementFormDefault   = XmlSchemaForm.None;
     finalDefault         = XmlSchemaDerivationMethod.None;
     includes             = new XmlSchemaObjectCollection();
     isCompiled           = false;
     items           = new XmlSchemaObjectCollection();
     attributeGroups = new XmlSchemaObjectTable();
     attributes      = new XmlSchemaObjectTable();
     elements        = new XmlSchemaObjectTable();
     groups          = new XmlSchemaObjectTable();
     notations       = new XmlSchemaObjectTable();
     schemaTypes     = new XmlSchemaObjectTable();
 }
Example #22
0
 public static void AddToTable(XmlSchemaObjectTable table, XmlSchemaObject obj, XmlQualifiedName qname, ValidationEventHandler h)
 {
     if (table.Contains(qname))
     {
         if (obj.isRedefineChild)
         {
             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;
             }
             if (XmlSchemaUtil.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);
     }
 }
 internal override void VerifySchemaValid(XmlSchemaObjectTable notations, XmlSchemaObject caller)
 {
     for (Datatype_NOTATION e_notation = this; e_notation != null; e_notation = (Datatype_NOTATION)e_notation.Base)
     {
         if ((e_notation.Restriction != null) && ((e_notation.Restriction.Flags & RestrictionFlags.Enumeration) != 0))
         {
             for (int i = 0; i < e_notation.Restriction.Enumeration.Count; i++)
             {
                 XmlQualifiedName name = (XmlQualifiedName)e_notation.Restriction.Enumeration[i];
                 if (!notations.Contains(name))
                 {
                     throw new XmlSchemaException("Sch_NotationRequired", caller);
                 }
             }
             return;
         }
     }
     throw new XmlSchemaException("Sch_NotationRequired", caller);
 }
Example #24
0
        internal override int Validate(ValidationEventHandler h, XmlSchema schema)
        {
            if (base.IsValidated(schema.CompilationId))
            {
                return(this.errorCount);
            }
            if (this.redefined == null && this.redefinedObject != null)
            {
                this.redefinedObject.Compile(h, schema);
                this.redefined = (XmlSchemaAttributeGroup)this.redefinedObject;
                this.redefined.Validate(h, schema);
            }
            XmlSchemaObjectCollection xmlSchemaObjectCollection = this.Attributes;

            this.attributeUses = new XmlSchemaObjectTable();
            this.errorCount   += XmlSchemaUtil.ValidateAttributesResolved(this.attributeUses, h, schema, xmlSchemaObjectCollection, this.AnyAttribute, ref this.anyAttributeUse, this.redefined, false);
            this.ValidationId  = schema.ValidationId;
            return(this.errorCount);
        }
Example #25
0
 private void VerifyTables()
 {
     if (this.elements == null)
     {
         this.elements = new XmlSchemaObjectTable();
     }
     if (this.attributes == null)
     {
         this.attributes = new XmlSchemaObjectTable();
     }
     if (this.schemaTypes == null)
     {
         this.schemaTypes = new XmlSchemaObjectTable();
     }
     if (this.substitutionGroups == null)
     {
         this.substitutionGroups = new XmlSchemaObjectTable();
     }
 }
 internal override void VerifySchemaValid(XmlSchemaObjectTable notations, XmlSchemaObject caller)
 {
     for (Datatype_NOTATION e_notation = this; e_notation != null; e_notation = (Datatype_NOTATION) e_notation.Base)
     {
         if ((e_notation.Restriction != null) && ((e_notation.Restriction.Flags & RestrictionFlags.Enumeration) != 0))
         {
             for (int i = 0; i < e_notation.Restriction.Enumeration.Count; i++)
             {
                 XmlQualifiedName name = (XmlQualifiedName) e_notation.Restriction.Enumeration[i];
                 if (!notations.Contains(name))
                 {
                     throw new XmlSchemaException("Sch_NotationRequired", caller);
                 }
             }
             return;
         }
     }
     throw new XmlSchemaException("Sch_NotationRequired", caller);
 }
Example #27
0
        private void ValidateUPAOnItems(XmlSchemaObjectTable qnames, ArrayList nsNames, ValidationEventHandler h, XmlSchema schema)
        {
            XmlSchemaObjectTable xmlSchemaObjectTable  = new XmlSchemaObjectTable();
            ArrayList            arrayList             = new ArrayList();
            XmlSchemaObjectTable xmlSchemaObjectTable2 = new XmlSchemaObjectTable();
            ArrayList            arrayList2            = new ArrayList();

            for (int i = 0; i < this.Items.Count; i++)
            {
                XmlSchemaParticle xmlSchemaParticle = this.Items[i] as XmlSchemaParticle;
                xmlSchemaParticle.ValidateUniqueParticleAttribution(xmlSchemaObjectTable, arrayList, h, schema);
                if (xmlSchemaParticle.ValidatedMinOccurs == xmlSchemaParticle.ValidatedMaxOccurs)
                {
                    xmlSchemaObjectTable.Clear();
                    arrayList.Clear();
                }
                else
                {
                    if (xmlSchemaParticle.ValidatedMinOccurs != 0m)
                    {
                        foreach (object obj in xmlSchemaObjectTable2.Names)
                        {
                            XmlQualifiedName name = (XmlQualifiedName)obj;
                            xmlSchemaObjectTable.Set(name, null);
                        }
                        foreach (object obj2 in arrayList2)
                        {
                            arrayList.Remove(obj2);
                        }
                    }
                    foreach (object obj3 in xmlSchemaObjectTable.Names)
                    {
                        XmlQualifiedName name2 = (XmlQualifiedName)obj3;
                        xmlSchemaObjectTable2.Set(name2, xmlSchemaObjectTable[name2]);
                    }
                    arrayList2.Clear();
                    arrayList2.AddRange(arrayList);
                }
            }
        }
Example #28
0
        void ValidateUPAOnItems(XmlSchemaObjectTable qnames, ArrayList nsNames,
                                ValidationEventHandler h, XmlSchema schema)
        {
            // non-optional components
            XmlSchemaObjectTable elems        = new XmlSchemaObjectTable();
            ArrayList            wildcards    = new ArrayList();
            XmlSchemaObjectTable tmpElems     = new XmlSchemaObjectTable();
            ArrayList            tmpWildcards = new ArrayList();

            for (int i = 0; i < Items.Count; i++)
            {
                XmlSchemaParticle p1 = Items [i] as XmlSchemaParticle;
                p1.ValidateUniqueParticleAttribution(elems, wildcards, h, schema);
                if (p1.ValidatedMinOccurs == p1.ValidatedMaxOccurs)
                {
                    elems.Clear();
                    wildcards.Clear();
                }
                else
                {
                    if (p1.ValidatedMinOccurs != 0)
                    {
                        foreach (XmlQualifiedName n in tmpElems.Names)
                        {
                            elems.Set(n, null);                              // remove
                        }
                        foreach (object o in tmpWildcards)
                        {
                            wildcards.Remove(o);
                        }
                    }
                    foreach (XmlQualifiedName n in elems.Names)
                    {
                        tmpElems.Set(n, elems [n]);
                    }
                    tmpWildcards.Clear();
                    tmpWildcards.AddRange(wildcards);
                }
            }
        }
Example #29
0
        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);
        }
 internal override void VerifySchemaValid(XmlSchemaObjectTable notations, XmlSchemaObject caller) {/*noop*/}
Example #31
0
		internal override void ValidateUniqueTypeAttribution (XmlSchemaObjectTable labels,
			ValidationEventHandler h, XmlSchema schema)
		{
			foreach (XmlSchemaParticle p in this.Items)
				p.ValidateUniqueTypeAttribution (labels, h, schema);
		}
		internal override void ValidateUniqueTypeAttribution (XmlSchemaObjectTable labels,
			ValidationEventHandler h, XmlSchema schema)
		{
			if (TargetGroup != null)
				TargetGroup.Particle.ValidateUniqueTypeAttribution (labels, h, schema);
		}
Example #33
0
 private void GenerateAttribute(XmlSchemaObjectTable attributes, InstanceElement elem)
 {
     IDictionaryEnumerator ienum = attributes.GetEnumerator();
     while (ienum.MoveNext()) {
         if (ienum.Value is XmlSchemaAttribute) {
             GenerateInstanceAttribute((XmlSchemaAttribute)ienum.Value, elem);
         }
     }
 }
 internal override void VerifySchemaValid(XmlSchemaObjectTable notations, XmlSchemaObject caller)
 {
 }
Example #35
0
 private XmlSchemaAttribute GetAttributeFromNS(string ns, XmlSchemaObjectTable attributes)
 {
     return GetAttributeFromNS(ns, false, attributes);
 }
			internal override void ValidateUniqueTypeAttribution (XmlSchemaObjectTable labels,
				ValidationEventHandler h, XmlSchema schema)
			{
				// do nothing
			}
Example #37
0
 internal override void ValidateUniqueParticleAttribution(XmlSchemaObjectTable qnames,
                                                          ArrayList nsNames, ValidationEventHandler h, XmlSchema schema)
 {
     // do nothing
 }
		internal virtual void ValidateUniqueTypeAttribution (XmlSchemaObjectTable labels,
			ValidationEventHandler h, XmlSchema schema)
		{
		}
			internal override void ValidateUniqueParticleAttribution (XmlSchemaObjectTable qnames,
				ArrayList nsNames, ValidationEventHandler h, XmlSchema schema)
			{
				// do nothing
			}
		internal virtual void ValidateUniqueParticleAttribution (
			XmlSchemaObjectTable qnames, ArrayList nsNames,
			ValidationEventHandler h, XmlSchema schema)
		{
		}
Example #41
0
        private bool IsValidTypeRedefine(XmlSchemaObject existingObject, XmlSchemaObject item, XmlSchemaObjectTable table)
        {
            XmlSchemaType schemaType   = (item as XmlSchemaType) !;
            XmlSchemaType existingType = (existingObject as XmlSchemaType) !;

            if (existingType == schemaType.Redefined)
            {                                                           //schemaType is the redefinition of existingObject
                if (existingType.ElementDecl == null)
                {                                                       //If the existing one is not already compiled, then replace.
                    table.Insert(schemaType.QualifiedName, schemaType); //Update with redefined entry
                    return(true);
                }
            }
            else if (existingType.Redefined == schemaType)
            { //Redefined type already exists in the set, original type is added after redefined type, ignore the original type
                return(true);
            }
            return(false);
        }
Example #42
0
		internal override void ValidateUniqueParticleAttribution (XmlSchemaObjectTable qnames, ArrayList nsNames,
			ValidationEventHandler h, XmlSchema schema)
		{
			foreach (XmlSchemaParticle p in this.Items)
				p.ValidateUniqueParticleAttribution (qnames, nsNames, h, schema);
		}
Example #43
0
 internal virtual void ValidateUniqueParticleAttribution(
     XmlSchemaObjectTable qnames, ArrayList nsNames,
     ValidationEventHandler h, XmlSchema schema)
 {
 }
        private XmlQueryCardinality AddAttributes(List<XmlQueryType> list, XmlSchemaObjectTable attributeUses, XmlSchemaAnyAttribute attributeWildcard, XmlQueryType filter) {
            XmlQueryCardinality card = XmlQueryCardinality.Zero;
            if (attributeWildcard != null) {
                XmlSchemaType attributeSchemaType = attributeWildcard.ProcessContentsCorrect == XmlSchemaContentProcessing.Skip ? DatatypeImplementation.UntypedAtomicType : DatatypeImplementation.AnySimpleType;

                // wildcard will match more then one attribute
                switch (attributeWildcard.NamespaceList.Type) {
                case NamespaceList.ListType.Set:
                    foreach (string ns in attributeWildcard.NamespaceList.Enumerate) {
                        card += AddFilteredPrime(list, CreateAttributeType(ns, false, attributeSchemaType), filter);
                    }
                    break;
                case NamespaceList.ListType.Other:
                    card += AddFilteredPrime(list, CreateAttributeType(attributeWildcard.NamespaceList.Excluded, true, attributeSchemaType), filter);
                    break;
                case NamespaceList.ListType.Any:
                default:
                    card +=  AddFilteredPrime(list, attributeWildcard.ProcessContentsCorrect == XmlSchemaContentProcessing.Skip ? UntypedAttribute : Attribute, filter);
                    break;
                }
                // Always optional
                card *= XmlQueryCardinality.ZeroOrOne;
            }
            foreach (XmlSchemaAttribute attribute in attributeUses.Values) {
                XmlQueryCardinality cardAttr = AddFilteredPrime(list, CreateAttributeType(attribute), filter);
                if (cardAttr != XmlQueryCardinality.Zero) {
                    Debug.Assert(cardAttr == XmlQueryCardinality.ZeroOrOne || cardAttr == XmlQueryCardinality.One);
                    card += (attribute.Use == XmlSchemaUse.Optional ? XmlQueryCardinality.ZeroOrOne : cardAttr);
                }
            }
            return card;
        }
Example #45
0
 internal virtual void ValidateUniqueTypeAttribution(XmlSchemaObjectTable labels,
                                                     ValidationEventHandler h, XmlSchema schema)
 {
 }
 private void TraverseAttributes(XmlSchemaObjectTable derivedAttributes, ClrContentTypeInfo typeInfo)
 {
     foreach (XmlSchemaAttribute derivedAttribute in derivedAttributes.Values)
     {
         Debug.Assert(derivedAttribute.AttributeSchemaType != null); //For use=prohibited, without derivation it doesnt mean anything, hence attribute should be compiled
         ClrBasePropertyInfo propertyInfo = BuildProperty(derivedAttribute, false, false);
         BuildAnnotationInformation(propertyInfo, derivedAttribute, false, false);
         typeInfo.AddMember(propertyInfo);
     }
 }
Example #47
0
 internal override void ValidateUniqueTypeAttribution(XmlSchemaObjectTable labels,
                                                      ValidationEventHandler h, XmlSchema schema)
 {
     // do nothing
 }
 private void TraverseAttributes(XmlSchemaObjectTable derivedAttributes, XmlSchemaObjectTable baseAttributes, ClrContentTypeInfo typeInfo)
 {
     foreach (XmlSchemaAttribute derivedAttribute in derivedAttributes.Values)
     {
         if (derivedAttribute.Use == XmlSchemaUse.Prohibited)
         {
             continue;
         }
         XmlSchemaAttribute baseAttribute = baseAttributes[derivedAttribute.QualifiedName] as XmlSchemaAttribute;
         if (baseAttribute != null && baseAttribute == derivedAttribute)
         {
             // Its the one copied from the base
             // http://linqtoxsd.codeplex.com/WorkItem/View.aspx?WorkItemId=3064
             ClrBasePropertyInfo propertyInfo = BuildProperty(
                 derivedAttribute, typeInfo.IsDerived, false);
             BuildAnnotationInformation(propertyInfo, derivedAttribute, false, false);
             typeInfo.AddMember(propertyInfo);
         }
         else
         {
             ClrBasePropertyInfo propertyInfo = BuildProperty(derivedAttribute, false, baseAttribute != null);
             BuildAnnotationInformation(propertyInfo, derivedAttribute, false, false);
             typeInfo.AddMember(propertyInfo);
         }
     }
 }
Example #49
0
 private XmlSchemaAttribute GetAttributeFromNS(string ns, bool other, XmlSchemaObjectTable attributes)
 {
     if (other) {
         foreach(XmlSchemaAttribute attr in schemaSet.GlobalAttributes.Values) {
             if (attr.QualifiedName.Namespace != ns && attr.QualifiedName.Namespace != string.Empty && attributes[attr.QualifiedName] == null) {
                 return attr;
             }
         }
     }
     else {
         foreach(XmlSchemaAttribute attr in schemaSet.GlobalAttributes.Values) {
             if (attr.QualifiedName.Namespace == ns && attributes[attr.QualifiedName] == null) {
                 return attr;
             }
         }
     }
     return null;
 }
 private string DumpAttributes(XmlSchemaObjectTable attributeUses, XmlSchemaAnyAttribute attributeWildcard) {
     StringBuilder sb = new StringBuilder();
     sb.Append("[");
     bool first = true;
     foreach (XmlSchemaAttribute attribute in attributeUses.Values) {
         if (attribute.Use != XmlSchemaUse.Prohibited) {
             if (first) {
                 first = false;
             }
             else {
                 sb.Append(" ");
             }
             sb.Append(attribute.QualifiedName.Name);       
             if (attribute.Use == XmlSchemaUse.Optional || attribute.Use == XmlSchemaUse.None) {
                 sb.Append("?");                                                                  
             }
         }
     }
     if (attributeWildcard != null) {
         if (attributeUses.Count != 0) {
             sb.Append(" ");                                                                  
         }
         sb.Append("<");
         sb.Append(attributeWildcard.NamespaceList.ToString());
         sb.Append(">");
     }
     sb.Append("] - [");
     first = true;
     foreach (XmlSchemaAttribute attribute in attributeUses.Values) {
         if (attribute.Use == XmlSchemaUse.Prohibited) {
             if (first) {
                 first = false;
             }
             else {
                 sb.Append(" ");
             }
             sb.Append(attribute.QualifiedName.Name);       
         }
     }
     sb.Append("]");
     return sb.ToString();
 }
		internal override void ValidateUniqueParticleAttribution (XmlSchemaObjectTable qnames, ArrayList nsNames,
			ValidationEventHandler h, XmlSchema schema)
		{
			if (TargetGroup != null)
				TargetGroup.Particle.ValidateUniqueParticleAttribution (qnames, nsNames, h, schema);
		}
		public XmlSchema ()
		{
			attributeFormDefault= XmlSchemaForm.None;
			blockDefault = XmlSchemaDerivationMethod.None;
			elementFormDefault = XmlSchemaForm.None;
			finalDefault = XmlSchemaDerivationMethod.None;
			includes = new XmlSchemaObjectCollection();
			isCompiled = false;
			items = new XmlSchemaObjectCollection();
			attributeGroups = new XmlSchemaObjectTable();
			attributes = new XmlSchemaObjectTable();
			elements = new XmlSchemaObjectTable();
			groups = new XmlSchemaObjectTable();
			notations = new XmlSchemaObjectTable();
			schemaTypes = new XmlSchemaObjectTable();
		}
Example #53
0
 internal abstract void VerifySchemaValid(XmlSchemaObjectTable notations, XmlSchemaObject caller);
Example #54
0
        protected void AddToTable(XmlSchemaObjectTable table, XmlQualifiedName qname, XmlSchemaObject item)
        {
            if (qname.Name.Length == 0)
            {
                return;
            }
            XmlSchemaObject existingObject = (XmlSchemaObject)table[qname];

            if (existingObject != null)
            {
                if (existingObject == item)
                {
                    return;
                }
                string code = Res.Sch_DupGlobalElement;
                if (item is XmlSchemaAttributeGroup)
                {
                    string ns = nameTable.Add(qname.Namespace);
                    if (Ref.Equal(ns, NsXml))   //Check for xml namespace
                    {
                        XmlSchema       schemaForXmlNS        = Preprocessor.GetBuildInSchema();
                        XmlSchemaObject builtInAttributeGroup = schemaForXmlNS.AttributeGroups[qname];
                        if ((object)existingObject == (object)builtInAttributeGroup)
                        {
                            table.Insert(qname, item);
                            return;
                        }
                        else if ((object)item == (object)builtInAttributeGroup)   //trying to overwrite customer's component with built-in, ignore built-in
                        {
                            return;
                        }
                    }
                    else if (IsValidAttributeGroupRedefine(existingObject, item))  //check for redefines
                    {
                        table.Insert(qname, item);
                        return;
                    }
                    code = Res.Sch_DupAttributeGroup;
                }
                else if (item is XmlSchemaAttribute)
                {
                    string ns = nameTable.Add(qname.Namespace);
                    if (Ref.Equal(ns, NsXml))
                    {
                        XmlSchema       schemaForXmlNS   = Preprocessor.GetBuildInSchema();
                        XmlSchemaObject builtInAttribute = schemaForXmlNS.Attributes[qname];
                        if ((object)existingObject == (object)builtInAttribute)   //replace built-in one
                        {
                            table.Insert(qname, item);
                            return;
                        }
                        else if ((object)item == (object)builtInAttribute)   //trying to overwrite customer's component with built-in, ignore built-in
                        {
                            return;
                        }
                    }
                    code = Res.Sch_DupGlobalAttribute;
                }
                else if (item is XmlSchemaSimpleType)
                {
                    if (IsValidTypeRedefine(existingObject, item))
                    {
                        table.Insert(qname, item);
                        return;
                    }
                    code = Res.Sch_DupSimpleType;
                }
                else if (item is XmlSchemaComplexType)
                {
                    if (IsValidTypeRedefine(existingObject, item))
                    {
                        table.Insert(qname, item);
                        return;
                    }
                    code = Res.Sch_DupComplexType;
                }
                else if (item is XmlSchemaGroup)
                {
                    if (IsValidGroupRedefine(existingObject, item))  //check for redefines
                    {
                        table.Insert(qname, item);
                        return;
                    }
                    code = Res.Sch_DupGroup;
                }
                else if (item is XmlSchemaNotation)
                {
                    code = Res.Sch_DupNotation;
                }
                else if (item is XmlSchemaIdentityConstraint)
                {
                    code = Res.Sch_DupIdentityConstraint;
                }
                else
                {
                    Debug.Assert(item is XmlSchemaElement);
                }
                SendValidationEvent(code, qname.ToString(), item);
            }
            else
            {
                table.Add(qname, item);
            }
        }
        internal override void VerifySchemaValid(XmlSchemaObjectTable notations, XmlSchemaObject caller) {

            // Only datatypes that are derived from NOTATION by specifying a value for enumeration can be used in a schema.
            // Furthermore, the value of all enumeration facets must match the name of a notation declared in the current schema.                    //
            for(Datatype_NOTATION dt = this; dt != null; dt = (Datatype_NOTATION)dt.Base) {
                if (dt.Restriction != null && (dt.Restriction.Flags & RestrictionFlags.Enumeration) != 0) {
                    for (int i = 0; i < dt.Restriction.Enumeration.Count; ++i) {
                        XmlQualifiedName notation = (XmlQualifiedName)dt.Restriction.Enumeration[i];
                        if (!notations.Contains(notation)) {
                            throw new XmlSchemaException(Res.Sch_NotationRequired, caller);
                        }
                    }
                    return;
                }
            }
            throw new XmlSchemaException(Res.Sch_NotationRequired, caller);
        }
Example #56
0
 internal abstract void VerifySchemaValid(XmlSchemaObjectTable notations, XmlSchemaObject caller);
 internal XSODictionaryEnumerator(List<XmlSchemaObjectTable.XmlSchemaObjectEntry> entries, int size, XmlSchemaObjectTable.EnumeratorType enumType) : base(entries, size, enumType)
 {
 }
 public SchemaCollectionCompiler(XmlNameTable nameTable, ValidationEventHandler eventHandler) : base(nameTable, null, eventHandler)
 {
     this.examplars = new XmlSchemaObjectTable();
     this.complexTypeStack = new Stack();
 }
Example #59
0
            private XmlSchemaAttribute AddAttribute(string localName, string prefix, string childURI, string attrValue, bool bCreatingNewType, XmlSchema parentSchema, XmlSchemaObjectCollection addLocation, XmlSchemaObjectTable compiledAttributes)
            {
                if (childURI == XmlSchema.Namespace)
                {
                    throw new XmlSchemaInferenceException(Res.SchInf_schema, 0, 0);
                }

                XmlSchemaAttribute xsa = null;
                int AttributeType = -1;
                XmlSchemaAttribute returnedAttribute = null;    //this value will change to attributeReference if childURI!= parentURI
                XmlSchema xs = null;
                bool add = true;

                Debug.Assert(compiledAttributes != null); //AttributeUses is never null
                // First we need to look into the already compiled attributes 
                //   (they come from the schemaset which we got on input)
                // If there are none or we don't find it there, then we must search the list of attributes
                //   where we are going to add a new one (if it doesn't exist). 
                //   This is necessary to avoid adding duplicate attribute declarations.
                ICollection searchCollectionPrimary, searchCollectionSecondary;
                if (compiledAttributes.Count > 0) {
                    searchCollectionPrimary = compiledAttributes.Values;
                    searchCollectionSecondary = addLocation;
                }
                else {
                    searchCollectionPrimary = addLocation;
                    searchCollectionSecondary = null;
                }
                if (childURI == XmlReservedNs.NsXml)
                {
                    XmlSchemaAttribute attributeReference = null;
                    //see if the reference exists
                    attributeReference = FindAttributeRef(searchCollectionPrimary, localName, childURI);
                    if (attributeReference == null && searchCollectionSecondary != null) {
                        attributeReference = FindAttributeRef(searchCollectionSecondary, localName, childURI);
                    }
                    if (attributeReference == null)
                    {
                        attributeReference = new XmlSchemaAttribute();
                        attributeReference.RefName = new XmlQualifiedName(localName, childURI);
                        if (bCreatingNewType && this.Occurrence == InferenceOption.Restricted)
                        {
                            attributeReference.Use = XmlSchemaUse.Required;
                        }
                        else
                        {
                            attributeReference.Use = XmlSchemaUse.Optional;
                        }

                        addLocation.Add(attributeReference);
                    }
                    returnedAttribute = attributeReference;
                }
                else
                {
                    if (childURI.Length == 0)
                    {
                        xs = parentSchema;
                        add = false;
                    }
                    else if (childURI != null && !schemaSet.Contains(childURI))
                    {
                        /*if (parentSchema.AttributeFormDefault = XmlSchemaForm.Unqualified && childURI.Length == 0)
                    {
                        xs = parentSchema;
                        add = false;
                        break;
                    }*/
                        xs = new XmlSchema();
                        xs.AttributeFormDefault = XmlSchemaForm.Unqualified;
                        xs.ElementFormDefault = XmlSchemaForm.Qualified;
                        if (childURI.Length != 0)
                            xs.TargetNamespace = childURI;
                        //schemas.Add(childURI, xs);
                        this.schemaSet.Add(xs);
                        if (prefix.Length != 0 && String.Compare(prefix, "xml", StringComparison.OrdinalIgnoreCase) != 0)
                            NamespaceManager.AddNamespace(prefix, childURI);
                    }
                    else
                    {
                        ArrayList col = this.schemaSet.Schemas(childURI) as ArrayList;
                        if (col != null && col.Count > 0)
                        {
                            xs = col[0] as XmlSchema;
                        }

                    }
                    if (childURI.Length != 0) //
                    {
                        XmlSchemaAttribute attributeReference = null;
                        //see if the reference exists
                        attributeReference = FindAttributeRef(searchCollectionPrimary, localName, childURI);
                        if (attributeReference == null & searchCollectionSecondary != null) {
                            attributeReference = FindAttributeRef(searchCollectionSecondary, localName, childURI);
                        }
                        if (attributeReference == null)
                        {
                            attributeReference = new XmlSchemaAttribute();
                            attributeReference.RefName = new XmlQualifiedName(localName, childURI);
                            if (bCreatingNewType && this.Occurrence == InferenceOption.Restricted)
                            {
                                attributeReference.Use = XmlSchemaUse.Required;
                            }
                            else
                            {
                                attributeReference.Use = XmlSchemaUse.Optional;
                            }

                            addLocation.Add(attributeReference);
                        }
                        returnedAttribute = attributeReference;

                        //see if the attribute exists on the global level
                        xsa = FindAttribute(xs.Items, localName);
                        if (xsa == null)
                        {
                            xsa = new XmlSchemaAttribute();
                            xsa.Name = localName;
                            xsa.SchemaTypeName = RefineSimpleType(attrValue, ref AttributeType);
                            xsa.LineNumber = AttributeType; //we use LineNumber to store flags of valid types
                            xs.Items.Add(xsa);

                        }
                        else
                        {
                            if (xsa.Parent == null)
                            {
                                AttributeType = xsa.LineNumber; // we use LineNumber to store flags of valid types
                            }
                            else
                            {
                                AttributeType = GetSchemaType(xsa.SchemaTypeName);
                                xsa.Parent = null;
                            }
                            xsa.SchemaTypeName = RefineSimpleType(attrValue, ref AttributeType);
                            xsa.LineNumber = AttributeType; // we use LineNumber to store flags of valid types
                        }
                    }
                    else
                    {
                        xsa = FindAttribute(searchCollectionPrimary, localName);
                        if (xsa == null && searchCollectionSecondary != null) {
                            xsa = FindAttribute(searchCollectionSecondary, localName);
                        }
                        if (xsa == null)
                        {
                            xsa = new XmlSchemaAttribute();
                            xsa.Name = localName;
                            xsa.SchemaTypeName = RefineSimpleType(attrValue, ref AttributeType);
                            xsa.LineNumber = AttributeType; // we use LineNumber to store flags of valid types
                            if (bCreatingNewType && this.Occurrence == InferenceOption.Restricted)
                                xsa.Use = XmlSchemaUse.Required;
                            else
                                xsa.Use = XmlSchemaUse.Optional;
                            addLocation.Add(xsa);
                            if (xs.AttributeFormDefault != XmlSchemaForm.Unqualified)
                            {
                                xsa.Form = XmlSchemaForm.Unqualified;
                            }
                        }
                        else
                        {
                            if (xsa.Parent == null)
                            {
                                AttributeType = xsa.LineNumber; // we use LineNumber to store flags of valid types
                            }
                            else
                            {
                                AttributeType = GetSchemaType(xsa.SchemaTypeName);
                                xsa.Parent = null;
                            }
                            xsa.SchemaTypeName = RefineSimpleType(attrValue, ref AttributeType);
                            xsa.LineNumber = AttributeType; // we use LineNumber to store flags of valid types
                        }
                        returnedAttribute = xsa;
                    }
                }
                string nullString = null;
                if (add && childURI != parentSchema.TargetNamespace)
                {
                    for (int i = 0; i < parentSchema.Includes.Count; ++i)
                    {
                        XmlSchemaImport import = parentSchema.Includes[i] as XmlSchemaImport;
                        if (import == null)
                        {
                            continue;
                        }
                        if (import.Namespace == childURI)
                        {
                            add = false;
                        }
                    }
                    if (add)
                    {
                        XmlSchemaImport import = new XmlSchemaImport();
                        import.Schema = xs;
                        if (childURI.Length != 0)
                        {
                            nullString = childURI;
                        }
                        import.Namespace = nullString;
                        parentSchema.Includes.Add(import);
                    }
                }


                return returnedAttribute;
            }
 internal XSOEnumerator(List<XmlSchemaObjectTable.XmlSchemaObjectEntry> entries, int size, XmlSchemaObjectTable.EnumeratorType enumType)
 {
     this.entries = entries;
     this.size = size;
     this.enumType = enumType;
     this.currentIndex = -1;
 }