private void PreprocessComplexType(XmlSchemaComplexType complexType, bool local)
 {
     if (local)
     {
         if (complexType.Name != null)
         {
             base.SendValidationEvent("Sch_ForbiddenAttribute", "name", complexType);
         }
     }
     else
     {
         if (complexType.Name != null)
         {
             this.ValidateNameAttribute(complexType);
             complexType.SetQualifiedName(new XmlQualifiedName(complexType.Name, this.targetNamespace));
         }
         else
         {
             base.SendValidationEvent("Sch_MissRequiredAttribute", "name", complexType);
         }
         if (complexType.Block == XmlSchemaDerivationMethod.All)
         {
             complexType.SetBlockResolved(XmlSchemaDerivationMethod.All);
         }
         else if (complexType.Block == XmlSchemaDerivationMethod.None)
         {
             complexType.SetBlockResolved(this.blockDefault & (XmlSchemaDerivationMethod.Restriction | XmlSchemaDerivationMethod.Extension));
         }
         else
         {
             if ((complexType.Block & ~(XmlSchemaDerivationMethod.Restriction | XmlSchemaDerivationMethod.Extension)) != XmlSchemaDerivationMethod.Empty)
             {
                 base.SendValidationEvent("Sch_InvalidComplexTypeBlockValue", complexType);
             }
             complexType.SetBlockResolved(complexType.Block & (XmlSchemaDerivationMethod.Restriction | XmlSchemaDerivationMethod.Extension));
         }
         if (complexType.Final == XmlSchemaDerivationMethod.All)
         {
             complexType.SetFinalResolved(XmlSchemaDerivationMethod.All);
         }
         else if (complexType.Final == XmlSchemaDerivationMethod.None)
         {
             if (this.finalDefault == XmlSchemaDerivationMethod.All)
             {
                 complexType.SetFinalResolved(XmlSchemaDerivationMethod.All);
             }
             else
             {
                 complexType.SetFinalResolved(this.finalDefault & (XmlSchemaDerivationMethod.Restriction | XmlSchemaDerivationMethod.Extension));
             }
         }
         else
         {
             if ((complexType.Final & ~(XmlSchemaDerivationMethod.Restriction | XmlSchemaDerivationMethod.Extension)) != XmlSchemaDerivationMethod.Empty)
             {
                 base.SendValidationEvent("Sch_InvalidComplexTypeFinalValue", complexType);
             }
             complexType.SetFinalResolved(complexType.Final & (XmlSchemaDerivationMethod.Restriction | XmlSchemaDerivationMethod.Extension));
         }
     }
     if (complexType.ContentModel != null)
     {
         this.SetParent(complexType.ContentModel, complexType);
         this.PreprocessAnnotation(complexType.ContentModel);
         if (complexType.Particle == null)
         {
             XmlSchemaObjectCollection attributes = complexType.Attributes;
         }
         if (complexType.ContentModel is XmlSchemaSimpleContent)
         {
             XmlSchemaSimpleContent contentModel = (XmlSchemaSimpleContent) complexType.ContentModel;
             if (contentModel.Content == null)
             {
                 if (complexType.QualifiedName == XmlQualifiedName.Empty)
                 {
                     base.SendValidationEvent("Sch_NoRestOrExt", complexType);
                 }
                 else
                 {
                     base.SendValidationEvent("Sch_NoRestOrExtQName", complexType.QualifiedName.Name, complexType.QualifiedName.Namespace, complexType);
                 }
             }
             else
             {
                 this.SetParent(contentModel.Content, contentModel);
                 this.PreprocessAnnotation(contentModel.Content);
                 if (contentModel.Content is XmlSchemaSimpleContentExtension)
                 {
                     XmlSchemaSimpleContentExtension content = (XmlSchemaSimpleContentExtension) contentModel.Content;
                     if (content.BaseTypeName.IsEmpty)
                     {
                         base.SendValidationEvent("Sch_MissAttribute", "base", content);
                     }
                     else
                     {
                         this.ValidateQNameAttribute(content, "base", content.BaseTypeName);
                     }
                     this.PreprocessAttributes(content.Attributes, content.AnyAttribute, content);
                     this.ValidateIdAttribute(content);
                 }
                 else
                 {
                     XmlSchemaSimpleContentRestriction source = (XmlSchemaSimpleContentRestriction) contentModel.Content;
                     if (source.BaseTypeName.IsEmpty)
                     {
                         base.SendValidationEvent("Sch_MissAttribute", "base", source);
                     }
                     else
                     {
                         this.ValidateQNameAttribute(source, "base", source.BaseTypeName);
                     }
                     if (source.BaseType != null)
                     {
                         this.SetParent(source.BaseType, source);
                         this.PreprocessSimpleType(source.BaseType, true);
                     }
                     this.PreprocessAttributes(source.Attributes, source.AnyAttribute, source);
                     this.ValidateIdAttribute(source);
                 }
             }
             this.ValidateIdAttribute(contentModel);
         }
         else
         {
             XmlSchemaComplexContent parent = (XmlSchemaComplexContent) complexType.ContentModel;
             if (parent.Content == null)
             {
                 if (complexType.QualifiedName == XmlQualifiedName.Empty)
                 {
                     base.SendValidationEvent("Sch_NoRestOrExt", complexType);
                 }
                 else
                 {
                     base.SendValidationEvent("Sch_NoRestOrExtQName", complexType.QualifiedName.Name, complexType.QualifiedName.Namespace, complexType);
                 }
             }
             else
             {
                 if (!parent.HasMixedAttribute && complexType.IsMixed)
                 {
                     parent.IsMixed = true;
                 }
                 this.SetParent(parent.Content, parent);
                 this.PreprocessAnnotation(parent.Content);
                 if (parent.Content is XmlSchemaComplexContentExtension)
                 {
                     XmlSchemaComplexContentExtension extension2 = (XmlSchemaComplexContentExtension) parent.Content;
                     if (extension2.BaseTypeName.IsEmpty)
                     {
                         base.SendValidationEvent("Sch_MissAttribute", "base", extension2);
                     }
                     else
                     {
                         this.ValidateQNameAttribute(extension2, "base", extension2.BaseTypeName);
                     }
                     if (extension2.Particle != null)
                     {
                         this.SetParent(extension2.Particle, extension2);
                         this.PreprocessParticle(extension2.Particle);
                     }
                     this.PreprocessAttributes(extension2.Attributes, extension2.AnyAttribute, extension2);
                     this.ValidateIdAttribute(extension2);
                 }
                 else
                 {
                     XmlSchemaComplexContentRestriction restriction2 = (XmlSchemaComplexContentRestriction) parent.Content;
                     if (restriction2.BaseTypeName.IsEmpty)
                     {
                         base.SendValidationEvent("Sch_MissAttribute", "base", restriction2);
                     }
                     else
                     {
                         this.ValidateQNameAttribute(restriction2, "base", restriction2.BaseTypeName);
                     }
                     if (restriction2.Particle != null)
                     {
                         this.SetParent(restriction2.Particle, restriction2);
                         this.PreprocessParticle(restriction2.Particle);
                     }
                     this.PreprocessAttributes(restriction2.Attributes, restriction2.AnyAttribute, restriction2);
                     this.ValidateIdAttribute(restriction2);
                 }
                 this.ValidateIdAttribute(parent);
             }
         }
     }
     else
     {
         if (complexType.Particle != null)
         {
             this.SetParent(complexType.Particle, complexType);
             this.PreprocessParticle(complexType.Particle);
         }
         this.PreprocessAttributes(complexType.Attributes, complexType.AnyAttribute, complexType);
     }
     this.ValidateIdAttribute(complexType);
 }
        private void PreprocessComplexType(XmlSchemaComplexType complexType, bool local) {
            if (local) {
                if (complexType.Name != null) {
                    SendValidationEvent(Res.Sch_ForbiddenAttribute, "name", complexType);
                }
            }
            else {
                if (complexType.Name != null) {
                    ValidateNameAttribute(complexType);
                    complexType.SetQualifiedName(new XmlQualifiedName(complexType.Name, this.targetNamespace));
                }
                else {
                    SendValidationEvent(Res.Sch_MissRequiredAttribute, "name", complexType);
                }
                if (complexType.Block == XmlSchemaDerivationMethod.All) {
                    complexType.SetBlockResolved(XmlSchemaDerivationMethod.All);
                }
                else if (complexType.Block == XmlSchemaDerivationMethod.None) {
                    complexType.SetBlockResolved(this.blockDefault & complexTypeBlockAllowed);
                }
                else {
                    if ((complexType.Block & ~complexTypeBlockAllowed) != 0) {
                        SendValidationEvent(Res.Sch_InvalidComplexTypeBlockValue, complexType);
                    }
                    complexType.SetBlockResolved(complexType.Block & complexTypeBlockAllowed);
                }
                if (complexType.Final == XmlSchemaDerivationMethod.All) {
                    complexType.SetFinalResolved(XmlSchemaDerivationMethod.All);
                }
                else if (complexType.Final == XmlSchemaDerivationMethod.None) {
                    if (this.finalDefault == XmlSchemaDerivationMethod.All) {
                        complexType.SetFinalResolved(XmlSchemaDerivationMethod.All);
                    }
                    else {
                        complexType.SetFinalResolved(this.finalDefault & complexTypeFinalAllowed);
                    }
                }
                else {
                    if ((complexType.Final & ~complexTypeFinalAllowed) != 0) {
                        SendValidationEvent(Res.Sch_InvalidComplexTypeFinalValue, complexType);
                    }
                    complexType.SetFinalResolved(complexType.Final & complexTypeFinalAllowed);
                }

            }

            if (complexType.ContentModel != null) {
                SetParent(complexType.ContentModel, complexType); //SimpleContent / complexCotent
                PreprocessAnnotation(complexType.ContentModel);

                if (complexType.Particle != null || complexType.Attributes != null) {
                    // this is illigal
                }
                if (complexType.ContentModel is XmlSchemaSimpleContent) {
                    XmlSchemaSimpleContent content = (XmlSchemaSimpleContent)complexType.ContentModel;
                    if (content.Content == null) {
                        if (complexType.QualifiedName == XmlQualifiedName.Empty) {
                            SendValidationEvent(Res.Sch_NoRestOrExt, complexType);
                        }
                        else {
                            SendValidationEvent(Res.Sch_NoRestOrExtQName, complexType.QualifiedName.Name, complexType.QualifiedName.Namespace, complexType);
                        }
                    } 
                    else {
                        SetParent(content.Content, content);   //simplecontent extension / restriction
                        PreprocessAnnotation(content.Content); //annotation child of simple extension / restriction

                        if (content.Content is XmlSchemaSimpleContentExtension) {
                            XmlSchemaSimpleContentExtension contentExtension = (XmlSchemaSimpleContentExtension)content.Content;
                            if (contentExtension.BaseTypeName.IsEmpty) {
                                SendValidationEvent(Res.Sch_MissAttribute, "base", contentExtension);
                            }
                            else {
                                ValidateQNameAttribute(contentExtension, "base", contentExtension.BaseTypeName);
                            }
                            PreprocessAttributes(contentExtension.Attributes, contentExtension.AnyAttribute, contentExtension);
                            ValidateIdAttribute(contentExtension);
                        } 
                        else { //XmlSchemaSimpleContentRestriction
                            XmlSchemaSimpleContentRestriction contentRestriction = (XmlSchemaSimpleContentRestriction)content.Content;
                            if (contentRestriction.BaseTypeName.IsEmpty) {
                                SendValidationEvent(Res.Sch_MissAttribute, "base", contentRestriction);
                            }
                            else {
                                ValidateQNameAttribute(contentRestriction, "base", contentRestriction.BaseTypeName);
                            }
                            if (contentRestriction.BaseType != null) {
                                SetParent(contentRestriction.BaseType, contentRestriction);
                                PreprocessSimpleType(contentRestriction.BaseType, true);
                            } 
                            PreprocessAttributes(contentRestriction.Attributes, contentRestriction.AnyAttribute, contentRestriction);
                            ValidateIdAttribute(contentRestriction);
                        }
                    }
                    ValidateIdAttribute(content);
                } 
                else { // XmlSchemaComplexContent
                    XmlSchemaComplexContent content = (XmlSchemaComplexContent)complexType.ContentModel;
                    if (content.Content == null) {
                        if (complexType.QualifiedName == XmlQualifiedName.Empty) {
                            SendValidationEvent(Res.Sch_NoRestOrExt, complexType);
                        }
                        else {
                            SendValidationEvent(Res.Sch_NoRestOrExtQName, complexType.QualifiedName.Name, complexType.QualifiedName.Namespace, complexType);
                        }    
                    } 
                    else {
                        if ( !content.HasMixedAttribute && complexType.IsMixed) {
                            content.IsMixed = true; // fixup
                        }
                        SetParent(content.Content, content);   //complexcontent extension / restriction
                        PreprocessAnnotation(content.Content); //Annotation child of extension / restriction

                        if (content.Content is XmlSchemaComplexContentExtension) {
                            XmlSchemaComplexContentExtension contentExtension = (XmlSchemaComplexContentExtension)content.Content;
                            if (contentExtension.BaseTypeName.IsEmpty) {
                                SendValidationEvent(Res.Sch_MissAttribute, "base", contentExtension);
                            }
                            else {
                                ValidateQNameAttribute(contentExtension, "base", contentExtension.BaseTypeName);
                            }
                            if (contentExtension.Particle != null) {
                                SetParent(contentExtension.Particle, contentExtension); //Group / all / choice / sequence
                                PreprocessParticle(contentExtension.Particle);
                            }
                            PreprocessAttributes(contentExtension.Attributes, contentExtension.AnyAttribute, contentExtension);
                            ValidateIdAttribute(contentExtension);
                        } 
                        else { // XmlSchemaComplexContentRestriction
                            XmlSchemaComplexContentRestriction contentRestriction = (XmlSchemaComplexContentRestriction)content.Content;
                            if (contentRestriction.BaseTypeName.IsEmpty) {
                                SendValidationEvent(Res.Sch_MissAttribute, "base", contentRestriction);
                            }
                            else {
                                ValidateQNameAttribute(contentRestriction, "base", contentRestriction.BaseTypeName);
                            }
                            if (contentRestriction.Particle != null) {
                                SetParent(contentRestriction.Particle, contentRestriction); //Group / all / choice / sequence
                                PreprocessParticle(contentRestriction.Particle);
                            }
                            PreprocessAttributes(contentRestriction.Attributes, contentRestriction.AnyAttribute, contentRestriction);
                            ValidateIdAttribute(contentRestriction);
                        }
                        ValidateIdAttribute(content);
                    }
                }
            } 
            else {
                if (complexType.Particle != null) {
                    SetParent(complexType.Particle, complexType);
                    PreprocessParticle(complexType.Particle);
                }
                PreprocessAttributes(complexType.Attributes, complexType.AnyAttribute, complexType);
            }
            ValidateIdAttribute(complexType);
        }