Ejemplo n.º 1
0
 private void ClearCompiledState()
 {
     //Re-set post-compiled state for cloned object
     _attributeUses       = null;
     _localElements       = null;
     _attributeWildcard   = null;
     _contentTypeParticle = XmlSchemaParticle.Empty;
     _blockResolved       = XmlSchemaDerivationMethod.None;
 }
Ejemplo n.º 2
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 = ResXml.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, table))
                    { //check for redefines
                        return;
                    }
                    code = ResXml.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 = ResXml.Sch_DupGlobalAttribute;
                }
                else if (item is XmlSchemaSimpleType)
                {
                    if (IsValidTypeRedefine(existingObject, item, table))
                    {
                        return;
                    }
                    code = ResXml.Sch_DupSimpleType;
                }
                else if (item is XmlSchemaComplexType)
                {
                    if (IsValidTypeRedefine(existingObject, item, table))
                    {
                        return;
                    }
                    code = ResXml.Sch_DupComplexType;
                }
                else if (item is XmlSchemaGroup)
                {
                    if (IsValidGroupRedefine(existingObject, item, table))
                    { //check for redefines
                        return;
                    }
                    code = ResXml.Sch_DupGroup;
                }
                else if (item is XmlSchemaNotation)
                {
                    code = ResXml.Sch_DupNotation;
                }
                else if (item is XmlSchemaIdentityConstraint)
                {
                    code = ResXml.Sch_DupIdentityConstraint;
                }
                else
                {
                    Debug.Assert(item is XmlSchemaElement);
                }
                SendValidationEvent(code, qname.ToString(), item);
            }
            else
            {
                table.Add(qname, item);
            }
        }
Ejemplo n.º 3
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);
        }
Ejemplo n.º 4
0
        private bool IsValidGroupRedefine(XmlSchemaObject existingObject, XmlSchemaObject item, XmlSchemaObjectTable table)
        {
            XmlSchemaGroup group         = item as XmlSchemaGroup;
            XmlSchemaGroup existingGroup = existingObject as XmlSchemaGroup;

            if (existingGroup == group.Redefined)
            {                                                 //group is the redefinition of existingObject
                if (existingGroup.CanonicalParticle == null)
                {                                             //If the existing one is not already compiled, then replace.
                    table.Insert(group.QualifiedName, group); //Update with redefined entry
                    return(true);
                }
            }
            else if (existingGroup.Redefined == group)
            { //Redefined type already exists in the set, original type is added after redefined type, ignore the original type
                return(true);
            }
            return(false);
        }
Ejemplo n.º 5
0
        private bool IsValidAttributeGroupRedefine(XmlSchemaObject existingObject, XmlSchemaObject item, XmlSchemaObjectTable table)
        {
            XmlSchemaAttributeGroup attGroup         = item as XmlSchemaAttributeGroup;
            XmlSchemaAttributeGroup existingAttGroup = existingObject as XmlSchemaAttributeGroup;

            if (existingAttGroup == attGroup.Redefined)
            {                                                       //attribute group is the redefinition of existingObject
                if (existingAttGroup.AttributeUses.Count == 0)
                {                                                   //If the existing one is not already compiled, then replace.
                    table.Insert(attGroup.QualifiedName, attGroup); //Update with redefined entry
                    return(true);
                }
            }
            else if (existingAttGroup.Redefined == attGroup)
            { //Redefined type already exists in the set, original type is added after redefined type, ignore the original type
                return(true);
            }
            return(false);
        }
Ejemplo n.º 6
0
 internal abstract void VerifySchemaValid(XmlSchemaObjectTable notations, XmlSchemaObject caller);