2010-04-06 Jb Evain <jbevain@novell.com>

[mcs.git] / class / System.XML / System.Xml.Schema / XmlSchemaComplexType.cs

//
// System.Xml.Schema.XmlSchemaComplexType.cs
//
// Authors:
//      Dwivedi, Ajay kumar  Adwiv@Yahoo.com
//      Enomoto, Atsushi     ginga@kit.hi-ho.ne.jp
//

//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Collections;
using System.Xml;
using System.ComponentModel;
using System.Xml.Serialization;

namespace System.Xml.Schema
{
        /// <summary>
        /// Summary description for XmlSchemaComplexType.
        /// </summary>
        public class XmlSchemaComplexType : XmlSchemaType
        {
                private XmlSchemaAnyAttribute anyAttribute;
                private XmlSchemaObjectCollection attributes;
                private XmlSchemaObjectTable attributeUses;
                private XmlSchemaAnyAttribute attributeWildcard;
                private XmlSchemaDerivationMethod block;
                private XmlSchemaDerivationMethod blockResolved;
                private XmlSchemaContentModel contentModel;
                private XmlSchemaParticle validatableParticle;
                private XmlSchemaParticle contentTypeParticle;
                private bool isAbstract;
                private bool isMixed;
                private XmlSchemaParticle particle;
                private XmlSchemaContentType resolvedContentType;

                internal bool ValidatedIsAbstract;
                internal bool ParentIsSchema {
                        get { return Parent is XmlSchema; }
                }

                const string xmlname = "complexType";

                private static XmlSchemaComplexType anyType;

                internal static XmlSchemaComplexType AnyType {
                        get {
                                if (anyType == null) {
                                        anyType = new XmlSchemaComplexType ();
                                        anyType.Name = "anyType";
                                        anyType.QNameInternal = new XmlQualifiedName ("anyType", XmlSchema.Namespace);
                                        if (XmlSchemaUtil.StrictMsCompliant)
                                                anyType.validatableParticle = XmlSchemaParticle.Empty; // This code makes validator handles these schemas incorrectly: particlesIb001, mgM013, mgH014, ctE004, ctD004
                                        else
                                                anyType.validatableParticle = XmlSchemaAny.AnyTypeContent;

                                        anyType.contentTypeParticle = anyType.validatableParticle;
                                        anyType.DatatypeInternal = XmlSchemaSimpleType.AnySimpleType;
                                        anyType.isMixed = true;
                                        anyType.resolvedContentType = XmlSchemaContentType.Mixed;
                                }
                                return anyType;
                        }
                }

                internal static readonly XmlQualifiedName AnyTypeName = new XmlQualifiedName ("anyType", XmlSchema.Namespace);

                public XmlSchemaComplexType ()
                {
                        attributes = new XmlSchemaObjectCollection();
                        block = XmlSchemaDerivationMethod.None;
                        attributeUses = new XmlSchemaObjectTable();
                        validatableParticle = XmlSchemaParticle.Empty;
                        contentTypeParticle = validatableParticle;
                }

                #region Attributes

                [DefaultValue(false)]
                [System.Xml.Serialization.XmlAttribute("abstract")]
                public bool IsAbstract 
                {
                        get{ return  isAbstract; }
                        set{ isAbstract = value; }
                }
                [DefaultValue(XmlSchemaDerivationMethod.None)]
                [System.Xml.Serialization.XmlAttribute("block")]
                public XmlSchemaDerivationMethod Block
                {
                        get{ return  block; }
                        set{ block = value; }
                }
                [DefaultValue(false)]
                [System.Xml.Serialization.XmlAttribute("mixed")]
                public override bool IsMixed
                {
                        get{ return  isMixed; }
                        set{ isMixed = value; }
                }
                
                #endregion
                
                #region Elements
                                
                [XmlElement("simpleContent",typeof(XmlSchemaSimpleContent))]
                [XmlElement("complexContent",typeof(XmlSchemaComplexContent))]
                public XmlSchemaContentModel ContentModel 
                {
                        get{ return  contentModel; } 
                        set{ contentModel = value; }
                }

                //LAMESPEC: The default value for particle in Schema is of Type EmptyParticle (internal?)
                [XmlElement("group",typeof(XmlSchemaGroupRef))]
                [XmlElement("all",typeof(XmlSchemaAll))]
                [XmlElement("choice",typeof(XmlSchemaChoice))]
                [XmlElement("sequence",typeof(XmlSchemaSequence))]
                public XmlSchemaParticle Particle 
                {
                        get{ return  particle; } 
                        set{ particle = value; }
                }

                [XmlElement("attribute",typeof(XmlSchemaAttribute))]
                [XmlElement("attributeGroup",typeof(XmlSchemaAttributeGroupRef))]
                public XmlSchemaObjectCollection Attributes 
                {
                        get{ return attributes; }
                }

                [XmlElement("anyAttribute")]
                public XmlSchemaAnyAttribute AnyAttribute 
                {
                        get{ return  anyAttribute; }
                        set{ anyAttribute = value; }
                }
                #endregion

                #region XmlIgnore
                [XmlIgnore]
                public XmlSchemaContentType ContentType 
                {
                        get{ return resolvedContentType; }
                }
                [XmlIgnore]
                public XmlSchemaParticle ContentTypeParticle 
                {
                        get{ return contentTypeParticle; }
                }
                [XmlIgnore]
                public XmlSchemaDerivationMethod BlockResolved 
                {
                        get{ return blockResolved; }
                }
                [XmlIgnore]
                public XmlSchemaObjectTable AttributeUses 
                {
                        get{ return attributeUses; }
                }
                [XmlIgnore]
                public XmlSchemaAnyAttribute AttributeWildcard 
                {
                        get{ return attributeWildcard; }
                }

                #endregion

                internal XmlSchemaParticle ValidatableParticle 
                {
                        get{ return contentTypeParticle; }
                }

                internal override void SetParent (XmlSchemaObject parent)
                {
                        base.SetParent (parent);
                        if (ContentModel != null)
                                ContentModel.SetParent (this);
                        if (Particle != null)
                                Particle.SetParent (this);
                        if (AnyAttribute != null)
                                AnyAttribute.SetParent (this);
                        foreach (XmlSchemaObject obj in Attributes)
                                obj.SetParent (this);
                }

                /// <remarks>
                /// 1. If ContentModel is present, neither particle nor Attributes nor AnyAttribute can be present.
                /// 2. If particle is present, 
                /// a. For a topLevelComplexType
                ///             1. name must be present and type NCName
                ///             2. if block is #all, blockdefault is #all, else List of (extension | restriction)
                ///             3. if final is #all, finaldefault is #all, else List of (extension | restriction)
                ///     b. For a local Complex type 
                ///             1. abstract must be false
                ///             2. Name must be absent
                ///             3. final must be absent
                ///             4. block must be absent
                ///             
                /// </remarks>
                internal override int Compile (ValidationEventHandler h, XmlSchema schema)
                {
                        // If this is already compiled this time, simply skip.
                        if (CompilationId == schema.CompilationId)
                                return errorCount;

                        ValidatedIsAbstract = isAbstract;
                        attributeUses.Clear();

                        if (isRedefinedComponent) {
                                if (Annotation != null)
                                        Annotation.isRedefinedComponent = true;
                                if (AnyAttribute != null)
                                        AnyAttribute.isRedefinedComponent = true;
                                foreach (XmlSchemaObject obj in Attributes)
                                        obj.isRedefinedComponent = true;
                                if (ContentModel != null)
                                        ContentModel.isRedefinedComponent = true;
                                if (Particle != null)
                                        Particle.isRedefinedComponent = true;
                        }

                        // block/final resolution
                        if(ParentIsSchema || isRedefineChild)
                        {
                                if(this.Name == null || this.Name == string.Empty)
                                        error(h,"name must be present in a top level complex type");
                                else if(!XmlSchemaUtil.CheckNCName(Name))
                                        error(h,"name must be a NCName");
                                else
                                        this.QNameInternal = new XmlQualifiedName(Name, AncestorSchema.TargetNamespace);
                                
                                if(Block != XmlSchemaDerivationMethod.None)
                                {
                                        if(Block == XmlSchemaDerivationMethod.All)
                                        {
                                                blockResolved = XmlSchemaDerivationMethod.All;
                                        }
                                        else
                                        {
                                                if ((Block & XmlSchemaUtil.ComplexTypeBlockAllowed) != Block)
                                                        error (h, "Invalid block specification.");
                                                blockResolved = Block & XmlSchemaUtil.ComplexTypeBlockAllowed;
                                        }
                                }
                                else
                                {
                                        switch (schema.BlockDefault) {
                                        case XmlSchemaDerivationMethod.All:
                                                blockResolved = XmlSchemaDerivationMethod.All;
                                                break;
                                        case XmlSchemaDerivationMethod.None:
                                                blockResolved = XmlSchemaDerivationMethod.Empty;
                                                break;
                                        default:
                                                blockResolved = schema.BlockDefault & XmlSchemaUtil.ComplexTypeBlockAllowed;
                                                break;
                                        }
                                }

                                if(Final != XmlSchemaDerivationMethod.None)
                                {
                                        if(Final == XmlSchemaDerivationMethod.All)
                                                finalResolved = XmlSchemaDerivationMethod.All;
                                        else if ((Final & XmlSchemaUtil.FinalAllowed) != Final)
                                                error (h, "Invalid final specification.");
                                        else
                                                finalResolved = Final;
                                }
                                else
                                {
                                        switch (schema.FinalDefault) {
                                        case XmlSchemaDerivationMethod.All:
                                                finalResolved = XmlSchemaDerivationMethod.All;
                                                break;
                                        case XmlSchemaDerivationMethod.None:
                                                finalResolved = XmlSchemaDerivationMethod.Empty;
                                                break;
                                        default:
                                                finalResolved = schema.FinalDefault & XmlSchemaUtil.FinalAllowed;
                                                break;
                                        }
                                }
                        }
                        else // Not Top Level
                        {
                                if(isAbstract)
                                        error(h,"abstract must be false in a local complex type");
                                if(Name != null)
                                        error(h,"name must be absent in a local complex type");
                                if(Final != XmlSchemaDerivationMethod.None)
                                        error(h,"final must be absent in a local complex type");
                                if(block != XmlSchemaDerivationMethod.None)
                                        error(h,"block must be absent in a local complex type");
                        }

                        // Process contents and BaseSchemaType
                        if(contentModel != null)
                        {
                                if(anyAttribute != null || Attributes.Count != 0 || Particle != null)
                                        error(h,"attributes, particles or anyattribute is not allowed if ContentModel is present");
                                errorCount += contentModel.Compile (h, schema);

                                XmlSchemaSimpleContent smodel = ContentModel as XmlSchemaSimpleContent;
                                if(smodel != null)
                                {
                                        XmlSchemaSimpleContentExtension sscx = smodel.Content as XmlSchemaSimpleContentExtension;
                                        if (sscx == null) {
                                                XmlSchemaSimpleContentRestriction sscr = smodel.Content as XmlSchemaSimpleContentRestriction;
                                                if (sscr != null) {
                                                        if (sscr.BaseType != null) {
                                                                sscr.BaseType.Compile (h, schema);
                                                                BaseXmlSchemaTypeInternal = sscr.BaseType;
                                                        }
                                                }
                                        }
                                }
                        }
                        else
                        {
                                if (Particle != null)
                                        errorCount += Particle.Compile (h, schema);

                                if(this.anyAttribute != null)
                                {
                                        AnyAttribute.Compile(h,schema);
                                }
                                foreach(XmlSchemaObject obj in Attributes)
                                {
                                        if(obj is XmlSchemaAttribute)
                                        {
                                                XmlSchemaAttribute attr = (XmlSchemaAttribute) obj;
                                                errorCount += attr.Compile(h,schema);
                                        }
                                        else if(obj is XmlSchemaAttributeGroupRef)
                                        {
                                                XmlSchemaAttributeGroupRef atgrp = (XmlSchemaAttributeGroupRef) obj;
                                                errorCount += atgrp.Compile(h,schema);
                                        }
                                        else
                                                error(h,obj.GetType() +" is not valid in this place::ComplexType");
                                }
                        }

                        XmlSchemaUtil.CompileID(Id, this, schema.IDCollection, h);
                        this.CompilationId = schema.CompilationId;
                        return errorCount;
                }

                Guid CollectProcessId;

                private void CollectSchemaComponent (ValidationEventHandler h, XmlSchema schema)
                {
                        if (CollectProcessId == schema.CompilationId)
                                return;
                        // Below are already contributed by Compile():
                        // {name}, {namespace} => QualifiedName, QNameInternal
                        // {abstract} => ValidatedIsAbstract
                        // {prohibited substitutions} => BlockResolved
                        // {final} => FinalResolved
                        // {annotations} => Annotation (XmlSchemaAnnotated)

                        // Below are different properties depending on simpleContent | complexContent.
                        // {base type definition}
                        // {derivation method}
                        // {attribute uses} => AttributeUses (later)
                        // {attribute wildcard} => AttributeWildcard (later)
                        // {content type}


                        // {base type definition} => baseSchemaTypeInternal (later)
                        if (contentModel != null) {
                                BaseSchemaTypeName = contentModel.Content != null ? contentModel.Content.GetBaseTypeName () : XmlQualifiedName.Empty;

                                BaseXmlSchemaTypeInternal = schema.FindSchemaType(BaseSchemaTypeName);
                        }
                        // Resolve redefine.
                        if (this.isRedefineChild && BaseXmlSchemaType != null && this.QualifiedName == BaseSchemaTypeName) {
                                XmlSchemaType redType = (XmlSchemaType) redefinedObject;
                                if (redType == null)
                                        error (h, "Redefinition base type was not found.");
                                else
                                        BaseXmlSchemaTypeInternal = redType;
                        }

                        // {derivation method} => resolvedDerivedBy
                        if (contentModel != null && contentModel.Content != null) {
                                resolvedDerivedBy =
                                        contentModel.Content.IsExtension ?
                                        XmlSchemaDerivationMethod.Extension :
                                        XmlSchemaDerivationMethod.Restriction;
                        }
                        else
                                resolvedDerivedBy = XmlSchemaDerivationMethod.Empty;
                }

                void FillContentTypeParticle (ValidationEventHandler h, XmlSchema schema)
                {
                        if (CollectProcessId == schema.CompilationId)
                                return;
                        CollectProcessId = schema.CompilationId;

                        var ct = BaseXmlSchemaType as XmlSchemaComplexType;
                        if (ct != null)
                                ct.FillContentTypeParticle (h, schema);

                        // {content type} => ContentType and ContentTypeParticle (later)
                        if (ContentModel != null) {
                                CollectContentTypeFromContentModel (h, schema);
                        } else
                                CollectContentTypeFromImmediateContent ();

                        contentTypeParticle = validatableParticle.GetOptimizedParticle (true);
                        if (contentTypeParticle == XmlSchemaParticle.Empty && resolvedContentType == XmlSchemaContentType.ElementOnly)
                                resolvedContentType = XmlSchemaContentType.Empty;
                }

                #region {content type}
                private void CollectContentTypeFromImmediateContent ()
                {
                        // leave resolvedDerivedBy as Empty
                        if (Particle != null)
                                validatableParticle = Particle;
                        if (this == AnyType) {
                                resolvedContentType = XmlSchemaContentType.Mixed;
                                return;
                        }

                        if (validatableParticle == XmlSchemaParticle.Empty) {
                                // note that this covers "Particle == null" case
                                if (this.IsMixed)
                                        resolvedContentType = XmlSchemaContentType.TextOnly;
                                else
                                        resolvedContentType = XmlSchemaContentType.Empty;
                        } else {
                                if (this.IsMixed)
                                        resolvedContentType = XmlSchemaContentType.Mixed;
                                else
                                        resolvedContentType = XmlSchemaContentType.ElementOnly;
                        }
                        if (this != AnyType)
                                BaseXmlSchemaTypeInternal = XmlSchemaComplexType.AnyType;
                }

                private void CollectContentTypeFromContentModel (ValidationEventHandler h, XmlSchema schema)
                {
                        if (ContentModel.Content == null) {
                                // basically it is error. Recover by specifying empty content.
                                validatableParticle = XmlSchemaParticle.Empty;
                                resolvedContentType = XmlSchemaContentType.Empty;
                                return;
                        }

                        if (ContentModel.Content is XmlSchemaComplexContentExtension)
                                CollectContentTypeFromComplexExtension (h, schema);
                        if (ContentModel.Content is XmlSchemaComplexContentRestriction)
                                CollectContentTypeFromComplexRestriction ();
                }

                private void CollectContentTypeFromComplexExtension (ValidationEventHandler h, XmlSchema schema)
                {
                        XmlSchemaComplexContentExtension cce = (XmlSchemaComplexContentExtension) ContentModel.Content;
                        XmlSchemaComplexType baseComplexType = this.BaseXmlSchemaType as XmlSchemaComplexType;
                        if (baseComplexType != null)
                                baseComplexType.CollectSchemaComponent (h ,schema);

                        // It must exist, but consider validation error case.
                        if (BaseSchemaTypeName == XmlSchemaComplexType.AnyTypeName)
                                baseComplexType = XmlSchemaComplexType.AnyType;

                        // On error case, it simply rejects any contents
                        if (baseComplexType == null) {
                                validatableParticle = XmlSchemaParticle.Empty;
                                resolvedContentType = XmlSchemaContentType.Empty;
                                return;
                        }

                        // 3.4.2 complex content {content type}
                        // FIXME: this part is looking different than the spec. sections.
                        if (cce.Particle == null || cce.Particle == XmlSchemaParticle.Empty) {
                                // - 2.1
                                if (baseComplexType == null) {
                                        // Basically it is an error. Considering ValidationEventHandler.
                                        validatableParticle = XmlSchemaParticle.Empty;
                                        resolvedContentType = XmlSchemaContentType.Empty;
                                } else {
                                        validatableParticle = baseComplexType.ValidatableParticle;
                                        resolvedContentType = baseComplexType.resolvedContentType;
                                        // Bug #501814
                                        if (resolvedContentType == XmlSchemaContentType.Empty)
                                                resolvedContentType = GetComplexContentType (contentModel);
                                }
                        } else if (baseComplexType.validatableParticle == XmlSchemaParticle.Empty
                                || baseComplexType == XmlSchemaComplexType.AnyType) {
                                // - 2.2
                                validatableParticle = cce.Particle;
                                resolvedContentType = GetComplexContentType (contentModel);
                        } else {
                                // - 2.3 : create a new sequences that merges both contents.
                                XmlSchemaSequence seq = new XmlSchemaSequence ();
                                this.CopyInfo (seq);
                                seq.Items.Add (baseComplexType.validatableParticle);
                                seq.Items.Add (cce.Particle);
                                seq.Compile (h, schema);
                                seq.Validate (h, schema);
                                validatableParticle = seq;
                                resolvedContentType = GetComplexContentType (contentModel);
                        }
                        if (validatableParticle == null)
                                validatableParticle = XmlSchemaParticle.Empty;
                }

                private void CollectContentTypeFromComplexRestriction ()
                {
                        XmlSchemaComplexContentRestriction ccr = (XmlSchemaComplexContentRestriction) ContentModel.Content;
                        // 3.4.2 complex content schema component {content type}
                        // - 1.1.1
                        bool isEmptyParticle = false;
                        if (ccr.Particle == null) 
                                isEmptyParticle = true;
                        else {
                                XmlSchemaGroupBase gb = ccr.Particle as XmlSchemaGroupBase;
                                if (gb != null) {
                                        // - 1.1.2
                                        if (!(gb is XmlSchemaChoice) && gb.Items.Count == 0)
                                                isEmptyParticle = true;
                                        // - 1.1.3
                                        else if (gb is XmlSchemaChoice && gb.Items.Count == 0 && gb.ValidatedMinOccurs == 0)
                                                isEmptyParticle = true;
                                }
                        }
                        if (isEmptyParticle) {
                                resolvedContentType = XmlSchemaContentType.Empty;
                                validatableParticle = XmlSchemaParticle.Empty;
                        } else {
                                // - 1.2.1
                                resolvedContentType = GetComplexContentType (contentModel);
                                // - 1.2.2
                                validatableParticle = ccr.Particle;
                        }
                }

                // 3.4.2 Complex Content Schema Component {content type} 1.2.1
                private XmlSchemaContentType GetComplexContentType (XmlSchemaContentModel content)
                {
                        if (this.IsMixed || ((XmlSchemaComplexContent) content).IsMixed)
                                return XmlSchemaContentType.Mixed;
                        else
                                return XmlSchemaContentType.ElementOnly;
                }
                #endregion

                //
                // We have to validate:
                //
                //      - 3.4.3 Complex Type Definition Representation OK
                //      - 3.4.6 Type Definition Properties Correct
                //      - 3.4.6 Derivation Valid (Extension)
                //      - 3.4.6 Derivation Valid (Restriction, Complex)
                //
                // There are many schema errata:
                // http://www.w3.org/2001/05/xmlschema-errata#Errata1
                //
                // E1-43 Derivation Valid (Restriction, Complex) 5.
                // E1-21 Derivation Valid (Restriction, Complex) 4.3.
                // E1-17 Type Derivation OK (Complex) 2.1.
                //
                // And E1-38, E1-37, E1-30, E1-27
                //
                internal override int Validate (ValidationEventHandler h, XmlSchema schema)
                {
                        if (IsValidated (schema.ValidationId))
                                return errorCount;
                        // FIXME: omitting it causes StackOverflowException
                        // among the compilation of element and types, but
                        // it may result in insufficient results.
                        ValidationId = schema.ValidationId;

                        CollectSchemaComponent (h, schema);

                        ValidateBaseXmlSchemaType (h, schema);
                        
                        ValidateParticle (h, schema);
                        
                        FillContentTypeParticle (h, schema);

                        // 3.4.6: Properties Correct
                        // Term. 1 => 3.4.1 already done by CollectSchemaComponent()
                        //            except for {attribute uses} and {attribute wildcard}
                        // Term. 2, 3 and 4 goes to ValidateContentModel().
                        // Term. 5 follows in this method.
                        //
                        if (ContentModel != null)
                                ValidateContentModel (h, schema);
                        else
                                ValidateImmediateAttributes (h, schema);

                        // Additional support for 3.8.6 All Group Limited
                        if (ContentTypeParticle != null) {
                                XmlSchemaAll termAll = contentTypeParticle.GetOptimizedParticle (true) as XmlSchemaAll;
                                if (termAll != null && (termAll.ValidatedMaxOccurs != 1 || contentTypeParticle.ValidatedMaxOccurs != 1)) // here contentTypeParticle is used to check occurence.
                                        error (h, "Particle whose term is -all- and consists of complex type content particle must have maxOccurs = 1.");
                        }

#if NET_2_0
                        if (schema.Schemas.CompilationSettings != null &&
                                schema.Schemas.CompilationSettings.EnableUpaCheck)
#endif
                        // This check is optional only after 2.0
                        contentTypeParticle.ValidateUniqueParticleAttribution (new XmlSchemaObjectTable (),
                                new ArrayList (), h, schema);
                        contentTypeParticle.ValidateUniqueTypeAttribution (
                                new XmlSchemaObjectTable (), h, schema);

                        // 3.4.6 Properties Correct :: 5 (Two distinct ID attributes)
                        XmlSchemaAttribute idAttr = null;
                        foreach (DictionaryEntry entry in attributeUses) {
                                XmlSchemaAttribute attr = (XmlSchemaAttribute) entry.Value;
                                XmlSchemaDatatype dt = attr.AttributeType as XmlSchemaDatatype;
                                if (dt != null && dt.TokenizedType != XmlTokenizedType.ID)
                                        continue;
                                if (dt == null)
                                        dt = ((XmlSchemaSimpleType) attr.AttributeType).Datatype;
                                if (dt != null && dt.TokenizedType == XmlTokenizedType.ID) {
                                        if (idAttr != null)
                                                error (h, "Two or more ID typed attribute declarations in a complex type are found.");
                                        else
                                                idAttr = attr;
                                }
                        }

                        ValidationId = schema.ValidationId;
                        return errorCount;
                }

                private void ValidateImmediateAttributes (ValidationEventHandler h, XmlSchema schema)
                {
                        // {attribute uses}
                        // also checks 3.4.6 Properties Correct :: 4 (Distinct attributes)
                        attributeUses = new XmlSchemaObjectTable ();
                        XmlSchemaUtil.ValidateAttributesResolved (attributeUses,
                                h, schema, attributes, anyAttribute, ref attributeWildcard, null, false);
                }
                
                private void ValidateBaseXmlSchemaType (ValidationEventHandler h, XmlSchema schema)
                {
                        if (ContentModel != null && BaseXmlSchemaTypeInternal != null)
                                errorCount += BaseXmlSchemaTypeInternal.Validate (h, schema);
                }

                private void ValidateParticle (ValidationEventHandler h, XmlSchema schema)
                {       
                        if (ContentModel == null && Particle != null) {
                                errorCount += particle.Validate (h, schema);
                                XmlSchemaGroupRef pgrp = Particle as XmlSchemaGroupRef;
                                if (pgrp != null) {
                                        if (pgrp.TargetGroup != null)
                                                errorCount += pgrp.TargetGroup.Validate (h,schema);
                                        // otherwise, it might be missing sub components.
                                        else if (!schema.IsNamespaceAbsent (pgrp.RefName.Namespace))
                                                error (h, "Referenced group " + pgrp.RefName + " was not found in the corresponding schema.");
                                }
                        }
                }

                private void ValidateContentModel (ValidationEventHandler h, XmlSchema schema)
                {
                        errorCount += contentModel.Validate (h, schema);
                        
                        XmlSchemaType baseType = BaseXmlSchemaTypeInternal;

                        // Here we check 3.4.6 Properties Correct :: 2. and 3.
                        XmlSchemaComplexContentExtension cce = contentModel.Content as XmlSchemaComplexContentExtension;
                        XmlSchemaComplexContentRestriction ccr = contentModel.Content as XmlSchemaComplexContentRestriction;
                        XmlSchemaSimpleContentExtension sce = contentModel.Content as XmlSchemaSimpleContentExtension;
                        XmlSchemaSimpleContentRestriction scr = contentModel.Content as XmlSchemaSimpleContentRestriction;

                        XmlSchemaAnyAttribute localAnyAttribute = null;
                        XmlSchemaAnyAttribute baseAnyAttribute = null;

                        // 3.4.6 Properties Correct :: 3. Circular definition prohibited.
                        if (ValidateRecursionCheck ())
                                error (h, "Circular definition of schema types was found.");
                        if (baseType != null) {
                                // Fill "Datatype" property.
                                this.DatatypeInternal = baseType.Datatype;
                        } else if (BaseSchemaTypeName == XmlSchemaComplexType.AnyTypeName)
                                DatatypeInternal = XmlSchemaSimpleType.AnySimpleType;
                        else if (XmlSchemaUtil.IsBuiltInDatatypeName (BaseSchemaTypeName)) {
                                DatatypeInternal = XmlSchemaDatatype.FromName (BaseSchemaTypeName);
                        }

                        XmlSchemaComplexType baseComplexType = baseType as XmlSchemaComplexType;
                        XmlSchemaSimpleType baseSimpleType = baseType as XmlSchemaSimpleType;

                        // 3.4.6 Derivation Valid (common to Extension and Restriction, Complex) :: 1.
                        if (baseType != null && (baseType.FinalResolved & resolvedDerivedBy) != 0)
                                        error (h, "Specified derivation is specified as final by derived schema type.");

                        // 3.4.6 Properties Correct :: 2.
                        // Simple {base type definition} and restriction {derivation method} not allowed.
                        if (baseSimpleType != null && resolvedDerivedBy == XmlSchemaDerivationMethod.Restriction)
                                error (h, "If the base schema type is a simple type, then this type must be extension.");

                        // Common to complexContent
                        if (cce != null || ccr != null) {
                                // 3.4.3 Complex Type Definition Representation OK :: 1.
                                // base
                                if (BaseSchemaTypeName == XmlSchemaComplexType.AnyTypeName)
                                        baseComplexType = XmlSchemaComplexType.AnyType;
                                else if (XmlSchemaUtil.IsBuiltInDatatypeName (BaseSchemaTypeName))
                                        error (h, "Referenced base schema type is XML Schema datatype.");
                                else if (baseComplexType == null && !schema.IsNamespaceAbsent (BaseSchemaTypeName.Namespace))
                                        error (h, "Referenced base schema type " + BaseSchemaTypeName + " was not complex type or not found in the corresponding schema.");
                        }
                        // Common to simpleContent 
                        else {
                                // ContentType of {content type}
                                resolvedContentType = XmlSchemaContentType.TextOnly;

                                // 3.4.3 Complex Type Definition Representation OK :: 1.
                                // base
                                if (BaseSchemaTypeName == XmlSchemaComplexType.AnyTypeName)
                                        baseComplexType = XmlSchemaComplexType.AnyType;

                                if (baseComplexType != null && baseComplexType.ContentType != XmlSchemaContentType.TextOnly) {
                                        error (h, "Base schema complex type of a simple content must be simple content type. Base type is " + BaseSchemaTypeName);
                                } else if (sce == null && (baseSimpleType != null && BaseSchemaTypeName.Namespace != XmlSchema.Namespace)) {
                                        error (h, "If a simple content is not an extension, base schema type must be complex type. Base type is " + BaseSchemaTypeName);
                                } else if (XmlSchemaUtil.IsBuiltInDatatypeName (BaseSchemaTypeName)) {
                                        // do nothing for particle.
                                }
                                // otherwise, it might be missing sub components.
                                else if (baseType == null && !schema.IsNamespaceAbsent (BaseSchemaTypeName.Namespace))
                                        error (h, "Referenced base schema type " + BaseSchemaTypeName + " was not found in the corresponding schema.");

                                // 3.4.3 Complex Type Definition Representation OK :: 2.
                                // Note that baseSimpleType is also allowed as to Errata E1-27 (http://www.w3.org/2001/05/xmlschema-errata)
                                if (baseComplexType != null) {
                                        if (baseComplexType.ContentType == XmlSchemaContentType.TextOnly) {
                                                // 2.1.1
                                        // Here "baseComplexType.Particle != null" is required for error-ignorant case
                                        } else if (scr != null && baseComplexType.ContentType == XmlSchemaContentType.Mixed && baseComplexType.Particle != null && baseComplexType.Particle.ValidateIsEmptiable () && scr.BaseType != null) {
                                                // 2.1.2 && 2.2: OK
                                        }
                                        else
                                                error (h, "Base complex type of a simple content restriction must be text only.");
                                } else {
                                        if (sce != null && baseComplexType == null) {
                                                // 2.1.3 : OK
                                        }
                                        else
                                                error (h, "Not allowed base type of a simple content restriction.");
                                }
                        }

                        // complexType/complexContent/extension
                        if (cce != null) {
                                // I don't think 3.4.6 Derivation Valid (Extension) :: 1.2
                                // is constraining anything here, since 3.4.2 {attribute uses}
                                // defines as to include base type's attribute uses.
                                localAnyAttribute = cce.AnyAttribute;
                                if (baseComplexType != null) {
                                        foreach (DictionaryEntry entry in baseComplexType.AttributeUses) {
                                                XmlSchemaAttribute attr = (XmlSchemaAttribute) entry.Value;
                                                XmlSchemaUtil.AddToTable (attributeUses, attr, attr.QualifiedName, h);
                                        }
                                        baseAnyAttribute = baseComplexType.AttributeWildcard;
                                }
                                // attributes
                                errorCount += XmlSchemaUtil.ValidateAttributesResolved (
                                        this.attributeUses, h, schema, cce.Attributes, 
                                        cce.AnyAttribute , ref attributeWildcard, null, true);

                                // After adding them, test extension validity.
                                if (baseComplexType != null)
                                        this.ValidateComplexBaseDerivationValidExtension (baseComplexType, h, schema);
                                else if (baseSimpleType != null)
                                        this.ValidateSimpleBaseDerivationValidExtension (baseSimpleType, h, schema);
                        }
                        // complexType/complexContent/restriction
                        if (ccr != null) {
                                // For ValidationEventHandler.
                                if (baseComplexType == null)
                                        baseComplexType = XmlSchemaComplexType.AnyType;

                                // attributes
                                localAnyAttribute = ccr.AnyAttribute;
                                this.attributeWildcard = localAnyAttribute;
                                if (baseComplexType != null)
                                        baseAnyAttribute = baseComplexType.AttributeWildcard;
                                if (baseAnyAttribute != null && localAnyAttribute != null)
                                        // 1.3 attribute wildcard subset. (=> 3.10.6)
                                        localAnyAttribute.ValidateWildcardSubset (baseAnyAttribute, h, schema);

                                // 3.4.2 Complex Type Definition with complex content Schema Component
                                // and its {attribute uses} and {attribute wildcard} are done here (descendantly)
                                errorCount += XmlSchemaUtil.ValidateAttributesResolved (
                                        this.attributeUses, h, schema, ccr.Attributes, 
                                        ccr.AnyAttribute, ref attributeWildcard, null, false);
                                foreach (DictionaryEntry entry in baseComplexType.AttributeUses) {
                                        XmlSchemaAttribute attr = (XmlSchemaAttribute) entry.Value;
                                        if (attributeUses [attr.QualifiedName] == null)
                                                XmlSchemaUtil.AddToTable (attributeUses, attr, attr.QualifiedName, h);
                                }

                                // Derivation Valid (Restriction, Complex) :: 5.
                                // Also see E1-15 of http://www.w3.org/2001/05/xmlschema-errata#Errata1
                                // 5.1 shouled be in scr (XmlSchemaSimpleContentRestriction)
                                this.ValidateDerivationValidRestriction (baseComplexType, h, schema);
                        }
                        // complexType/simpleContent/extension
                        if (sce != null) {
                                errorCount += XmlSchemaUtil.ValidateAttributesResolved (
                                        this.attributeUses, h, schema, sce.Attributes, 
                                        sce.AnyAttribute, ref attributeWildcard, null, true);

                                // Attributes
                                // I don't think 3.4.6 Derivation Valid (Extension) :: 1.2
                                // is constraining anything here, since 3.4.2 {attribute uses}
                                // defines as to include base type's attribute uses.
                                localAnyAttribute = sce.AnyAttribute;

                                if (baseComplexType != null) {
                                        baseAnyAttribute = baseComplexType.AttributeWildcard;

                                        foreach (DictionaryEntry entry in baseComplexType.AttributeUses) {
                                                XmlSchemaAttribute attr = (XmlSchemaAttribute) entry.Value;
#if BUGGY_MS_COMPLIANT
                                                if (attr.Use != XmlSchemaUse.Prohibited)
                                                        XmlSchemaUtil.AddToTable (attributeUses, attr, attr.QualifiedName, h);
#endif
                                                XmlSchemaUtil.AddToTable (attributeUses, attr, attr.QualifiedName, h);
                                        }
                                }
                                if (baseAnyAttribute != null && localAnyAttribute != null)
                                        // 1.3 attribute wildcard subset. (=> 3.10.6)
                                        localAnyAttribute.ValidateWildcardSubset (baseAnyAttribute, h, schema);
                        }
                        // complexType/simpleContent/restriction
                        if (scr != null) {
                                // Attributes
                                baseAnyAttribute = baseComplexType != null ? baseComplexType.AttributeWildcard : null;

                                localAnyAttribute = scr.AnyAttribute;
                                if (localAnyAttribute != null && baseAnyAttribute != null)
                                        // 1.3 attribute wildcard subset. (=> 3.10.6)
                                        localAnyAttribute.ValidateWildcardSubset (baseAnyAttribute, h, schema);
                                // 3.4.6 :: 5.1. Beware that There is an errata for 5.1!!
                                // http://www.w3.org/2001/05/xmlschema-errata#Errata1

                                // 3.4.2 Complex Type Definition with simple content Schema Component
                                // and its {attribute uses} and {attribute wildcard} are done here (descendantly)
                                errorCount += XmlSchemaUtil.ValidateAttributesResolved (
                                        this.attributeUses, h, schema, scr.Attributes, 
                                        scr.AnyAttribute, ref attributeWildcard, null, false);
                        }

                        // Common process of AttributeWildcard.
                        if (localAnyAttribute != null) {
                                this.attributeWildcard = localAnyAttribute;
                        }
                        else
                                this.attributeWildcard = baseAnyAttribute;
                }

                // 3.4.6 Type Derivation OK (Complex)
                internal void ValidateTypeDerivationOK (object b, ValidationEventHandler h, XmlSchema schema)
                {
                        // AnyType derives from AnyType itself.
                        if (this == XmlSchemaComplexType.AnyType && BaseXmlSchemaType == this)
                                return;

                        XmlSchemaType bst = b as XmlSchemaType;
                        if (b == this)  // 1 and 2.1
                                return;
                        if (bst != null && (resolvedDerivedBy & bst.FinalResolved) != 0) // 1.
                                error (h, "Derivation type " + resolvedDerivedBy + " is prohibited by the base type.");
                        // FIXME: here BaseSchemaType should be 
                        // BaseXmlSchemaType, however for some case it 
                        // seems not working.
                        if (BaseSchemaType == b) // 2.2
                                return;
                        if (BaseSchemaType == null || BaseXmlSchemaType == XmlSchemaComplexType.AnyType) { // 2.3.1
                                error (h, "Derived type's base schema type is anyType.");
                                return;
                        }
                        // 2.3.2.1
                        XmlSchemaComplexType dbct = BaseXmlSchemaType as XmlSchemaComplexType;
                        if (dbct != null) {
                                dbct.ValidateTypeDerivationOK (b, h, schema);
                                return;
                        }
                        // 2.3.2.2
                        XmlSchemaSimpleType dbst = BaseXmlSchemaType as XmlSchemaSimpleType;
                        if (dbst != null) {
                                dbst.ValidateTypeDerivationOK (b, h, schema, true);
                                return;
                        }
                }

                // 3.4.6 Derivation Valid (Extension) - Term. 1 (Complex Type)
                internal void ValidateComplexBaseDerivationValidExtension (XmlSchemaComplexType baseComplexType,
                        ValidationEventHandler h, XmlSchema schema)
                {
                        // 1.1
                        if ((baseComplexType.FinalResolved & XmlSchemaDerivationMethod.Extension) != 0)
                                error (h, "Derivation by extension is prohibited.");
                        // 1.2
                        foreach (DictionaryEntry entry in baseComplexType.AttributeUses) {
                                XmlSchemaAttribute ba = (XmlSchemaAttribute) entry.Value;
                                XmlSchemaAttribute da = AttributeUses [ba.QualifiedName] as XmlSchemaAttribute;
                                if (da == null)
                                        error (h, "Invalid complex type derivation by extension was found. Missing attribute was found: " + ba.QualifiedName + " .");
                        }
                        // 1.3 -> 3.10.6 Wildcard Subset.
                        if (AnyAttribute != null) {
                                if (baseComplexType.AnyAttribute == null)
                                        error (h, "Invalid complex type derivation by extension was found. Base complex type does not have an attribute wildcard.");
                                else
                                        baseComplexType.AnyAttribute.ValidateWildcardSubset (AnyAttribute, h, schema);
                        }

                        // 1.4 => 1.4.2 (1.4.1 would be included in SimpleContentExtention).
                        // 1.4.2.1
//                      if (contentTypeParticle == null)
//                              error (h, "Extended complex type's content type must not be empty.");
                        // 1.4.2.2.1
                        if (baseComplexType.ContentType != XmlSchemaContentType.Empty) {
                                // 1.4.2.2.2.1
                                if (this.ContentType != baseComplexType.ContentType)
//                              if (this.GetContentType (false) != baseComplexType.GetContentType (false))
                                        error (h, "Base complex type has different content type " + baseComplexType.ContentType + ".");
                                // 1.4.2.2.2.2 => 3.9.6 Particle Valid (Extension)
                                else if (this.contentTypeParticle == null ||
                                        !this.contentTypeParticle.ParticleEquals (baseComplexType.ContentTypeParticle)) {
                                        XmlSchemaSequence seq = contentTypeParticle as XmlSchemaSequence;
                                        if (contentTypeParticle != XmlSchemaParticle.Empty && (seq == null || contentTypeParticle.ValidatedMinOccurs != 1 || contentTypeParticle.ValidatedMaxOccurs != 1))
                                                error (h, "Invalid complex content extension was found.");
                                        else {
                                                // Identical sequence item should be checked, but
                                                // I think it is naturally achieved as coded above.
                                        }
                                }
                        }
                }

                // 3.4.6 Derivation Valid (Extension) - Term. 2 (Simple Type)
                internal void ValidateSimpleBaseDerivationValidExtension (object baseType,
                        ValidationEventHandler h, XmlSchema schema)
                {
                        XmlSchemaSimpleType st = baseType as XmlSchemaSimpleType;
                        if (st != null && (st.FinalResolved & XmlSchemaDerivationMethod.Extension) != 0)
                                error (h, "Extension is prohibited by the base type.");

                        XmlSchemaDatatype dt = baseType as XmlSchemaDatatype;
                        if (dt == null)
                                dt = st.Datatype;
                        if (dt != this.Datatype)
                                error (h, "To extend simple type, a complex type must have the same content type as the base type.");
                }

                internal void ValidateDerivationValidRestriction (XmlSchemaComplexType baseType,
                        ValidationEventHandler h, XmlSchema schema)
                {
                        // 1.
                        if (baseType == null) {
                                error (h, "Base schema type is not a complex type.");
                                return;
                        }
                        if ((baseType.FinalResolved & XmlSchemaDerivationMethod.Restriction) != 0) {
                                error (h, "Prohibited derivation by restriction by base schema type.");
                                return;
                        }

                        // 2.
                        foreach (DictionaryEntry entry in this.AttributeUses) {
                                XmlSchemaAttribute attr = (XmlSchemaAttribute) entry.Value;
                                XmlSchemaAttribute baseAttr = baseType.AttributeUses [attr.QualifiedName] as XmlSchemaAttribute;
                                if (baseAttr != null) {
                                        // 2.1
                                        // 2.1.1
                                        if (baseAttr.ValidatedUse != XmlSchemaUse.Optional && attr.ValidatedUse != XmlSchemaUse.Required)
                                                error (h, "Invalid attribute derivation by restriction was found for " + attr.QualifiedName + " .");
                                        // 2.1.2
                                        XmlSchemaSimpleType attrSimpleType = attr.AttributeType as XmlSchemaSimpleType;
                                        XmlSchemaSimpleType baseAttrSimpleType = baseAttr.AttributeType as XmlSchemaSimpleType;
                                        bool typeError = false;
                                        if (attrSimpleType != null)
                                                attrSimpleType.ValidateDerivationValid (baseAttrSimpleType, null, h, schema);
                                        else if (attrSimpleType == null && baseAttrSimpleType != null)
                                                typeError = true;
                                        else {
                                                Type t1 = attr.AttributeType.GetType ();
                                                Type t2 = baseAttr.AttributeType.GetType ();
                                                if (t1 != t2 && t1.IsSubclassOf (t2))
                                                        typeError = true;
                                        }
                                        if (typeError)
                                                error (h, "Invalid attribute derivation by restriction because of its type: " + attr.QualifiedName + " .");
                                        // 2.1.3
                                        if (baseAttr.ValidatedFixedValue != null && attr.ValidatedFixedValue != baseAttr.ValidatedFixedValue)
                                                error (h, "Invalid attribute derivation by restriction because of its fixed value constraint: " + attr.QualifiedName + " .");
                                } else {
                                        // 2.2
                                        if (baseType.AttributeWildcard != null)
                                                if (!baseType.AttributeWildcard.ValidateWildcardAllowsNamespaceName (
                                                        attr.QualifiedName.Namespace, schema) &&
                                                        !schema.IsNamespaceAbsent (attr.QualifiedName.Namespace))
                                                        error (h, "Invalid attribute derivation by restriction was found for " + attr.QualifiedName + " .");
                                }
                        }
                        // I think 3. is considered in 2.
                        // 4.
                        if (this.AttributeWildcard != null && baseType != XmlSchemaComplexType.AnyType) {
                                if (baseType.AttributeWildcard == null)
                                        error (h, "Invalid attribute derivation by restriction because of attribute wildcard.");
                                else
                                        AttributeWildcard.ValidateWildcardSubset (baseType.AttributeWildcard, h, schema);
                        }

                        // 5.
                        if (this == AnyType)
                                return;
                        if (contentTypeParticle == XmlSchemaParticle.Empty) {
                                // 5.1
                                if (ContentType != XmlSchemaContentType.Empty) {
                                        // TODO: 5.1.1
//                                      XmlSchemaSimpleType baseST = baseType as XmlSchemaSimpleType;
                                        // 5.1.2
                                        if (baseType.ContentType == XmlSchemaContentType.Mixed && !baseType.ContentTypeParticle.ValidateIsEmptiable ())
                                                error (h, "Invalid content type derivation.");

                                } else {
                                        // 5.2
                                        if (baseType.ContentTypeParticle != XmlSchemaParticle.Empty &&
                                                !baseType.ContentTypeParticle.ValidateIsEmptiable ())
                                                error (h, "Invalid content type derivation.");
                                }
                        } else {
                                // 5.3 => 3.9.6 Particle Valid (Restriction)
                                if (baseType.ContentTypeParticle != null) {
                                        // 3.9.6 - 1 : same particle.
                                        // 3.9.6 - 2 is covered by using ActualParticle.
                                        if (!contentTypeParticle.ParticleEquals (baseType.ContentTypeParticle))
                                                contentTypeParticle.ValidateDerivationByRestriction (baseType.ContentTypeParticle, h, schema, true);
                                }
                        }
                }

#region Read
                //<complexType
                //  abstract = boolean : false
                //  block = (#all | List of (extension | restriction)) 
                //  final = (#all | List of (extension | restriction)) 
                //  id = ID
                //  mixed = boolean : false
                //  name = NCName
                //  {any attributes with non-schema namespace . . .}>
                //  Content: (annotation?, (simpleContent | complexContent | ((group | all | choice | sequence)?, ((attribute | attributeGroup)*, anyAttribute?))))
                //</complexType>
                internal static XmlSchemaComplexType Read(XmlSchemaReader reader, ValidationEventHandler h)
                {
                        XmlSchemaComplexType ctype = new XmlSchemaComplexType();
                        reader.MoveToElement();
                        Exception innerex;

                        if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
                        {
                                error(h,"Should not happen :1: XmlSchemaComplexType.Read, name="+reader.Name,null);
                                reader.SkipToEnd();
                                return null;
                        }

                        ctype.LineNumber = reader.LineNumber;
                        ctype.LinePosition = reader.LinePosition;
                        ctype.SourceUri = reader.BaseURI;

                        while(reader.MoveToNextAttribute())
                        {
                                if(reader.Name == "abstract")
                                {
                                        ctype.IsAbstract = XmlSchemaUtil.ReadBoolAttribute(reader,out innerex);
                                        if(innerex != null)
                                                error(h,reader.Value + " is invalid value for abstract",innerex);
                                }
                                else if(reader.Name == "block")
                                {
                                        ctype.block = XmlSchemaUtil.ReadDerivationAttribute(reader,out innerex, "block",
                                                XmlSchemaUtil.ComplexTypeBlockAllowed);
                                        if(innerex != null)
                                                error (h,"some invalid values for block attribute were found",innerex);
                                }
                                else if(reader.Name == "final")
                                {
                                        ctype.Final = XmlSchemaUtil.ReadDerivationAttribute(reader,out innerex, "final",
                                                XmlSchemaUtil.FinalAllowed);
                                        if(innerex != null)
                                                error (h,"some invalid values for final attribute were found",innerex);
                                }
                                else if(reader.Name == "id")
                                {
                                        ctype.Id = reader.Value;
                                }
                                else if(reader.Name == "mixed")
                                {
                                        ctype.isMixed = XmlSchemaUtil.ReadBoolAttribute(reader,out innerex);
                                        if(innerex != null)
                                                error(h,reader.Value + " is invalid value for mixed",innerex);
                                }
                                else if(reader.Name == "name")
                                {
                                        ctype.Name = reader.Value;
                                }
                                else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
                                {
                                        error(h,reader.Name + " is not a valid attribute for complexType",null);
                                }
                                else
                                {
                                        XmlSchemaUtil.ReadUnhandledAttribute(reader,ctype);
                                }
                        }
                        
                        reader.MoveToElement();
                        if(reader.IsEmptyElement)
                                return ctype;

                        //Content: 1. annotation?, 
                        //                 2. simpleContent | 2. complexContent | 
                        //                      (3.(group | all | choice | sequence)?, (4.(attribute | attributeGroup)*, 5.anyAttribute?)))
                        int level = 1;
                        while(reader.ReadNextElement())
                        {
                                if(reader.NodeType == XmlNodeType.EndElement)
                                {
                                        if(reader.LocalName != xmlname)
                                                error(h,"Should not happen :2: XmlSchemaComplexType.Read, name="+reader.Name,null);
                                        break;
                                }
                                if(level <= 1 && reader.LocalName == "annotation")
                                {
                                        level = 2; //Only one annotation
                                        XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
                                        if(annotation != null)
                                                ctype.Annotation = annotation;
                                        continue;
                                }
                                if(level <=2)
                                {
                                        if(reader.LocalName == "simpleContent")
                                        {
                                                level = 6;
                                                XmlSchemaSimpleContent simple = XmlSchemaSimpleContent.Read(reader,h);
                                                if(simple != null)
                                                        ctype.ContentModel = simple;
                                                continue;
                                        }
                                        if(reader.LocalName == "complexContent")
                                        {
                                                level = 6;
                                                XmlSchemaComplexContent complex = XmlSchemaComplexContent.Read(reader,h);
                                                if(complex != null)
                                                        ctype.contentModel = complex;
                                                continue;
                                        }
                                }
                                if(level <= 3)
                                {
                                        if(reader.LocalName == "group")
                                        {
                                                level = 4;
                                                XmlSchemaGroupRef group = XmlSchemaGroupRef.Read(reader,h);
                                                if(group != null)
                                                        ctype.particle = group;
                                                continue;
                                        }
                                        if(reader.LocalName == "all")
                                        {
                                                level = 4;
                                                XmlSchemaAll all = XmlSchemaAll.Read(reader,h);
                                                if(all != null)
                                                        ctype.particle = all;
                                                continue;
                                        }
                                        if(reader.LocalName == "choice")
                                        {
                                                level = 4;
                                                XmlSchemaChoice choice = XmlSchemaChoice.Read(reader,h);
                                                if(choice != null)
                                                        ctype.particle = choice;
                                                continue;
                                        }
                                        if(reader.LocalName == "sequence")
                                        {
                                                level = 4;
                                                XmlSchemaSequence sequence = XmlSchemaSequence.Read(reader,h);
                                                if(sequence != null)
                                                        ctype.particle = sequence;
                                                continue;
                                        }
                                }
                                if(level <= 4)
                                {
                                        if(reader.LocalName == "attribute")
                                        {
                                                level = 4;
                                                XmlSchemaAttribute attr = XmlSchemaAttribute.Read(reader,h);
                                                if(attr != null)
                                                        ctype.Attributes.Add(attr);
                                                continue;
                                        }
                                        if(reader.LocalName == "attributeGroup")
                                        {
                                                level = 4;
                                                XmlSchemaAttributeGroupRef attr = XmlSchemaAttributeGroupRef.Read(reader,h);
                                                if(attr != null)
                                                        ctype.attributes.Add(attr);
                                                continue;
                                        }
                                }
                                if(level <= 5 && reader.LocalName == "anyAttribute")
                                {
                                        level = 6;
                                        XmlSchemaAnyAttribute anyattr = XmlSchemaAnyAttribute.Read(reader,h);
                                        if(anyattr != null)
                                                ctype.AnyAttribute = anyattr;
                                        continue;
                                }
                                reader.RaiseInvalidElementError();
                        }
                        return ctype;
                }
#endregion
        }
}