Preprocess()

void System.Xml.Schema.Preprocessor.Preprocess ( XmlSchema schema, string targetNamespace, ArrayList imports )

inlineprivate

Definition at line 447 of file Preprocessor.cs.

    {
        XmlSchema xmlSchema = null;
        if (schema.IsProcessing)
        {
            return;
        }
        schema.IsProcessing = true;
        string targetNamespace2 = schema.TargetNamespace;
        if (targetNamespace2 != null)
        {
            targetNamespace2 = (schema.TargetNamespace = base.NameTable.Add(targetNamespace2));
            if (targetNamespace2.Length == 0)
            {
                SendValidationEvent(System.SR.Sch_InvalidTargetNamespaceAttribute, schema);
            }
            else
            {
                ParseUri(targetNamespace2, System.SR.Sch_InvalidNamespace, schema);
            }
        }
        if (schema.Version != null)
        {
            XmlSchemaDatatype datatype = DatatypeImplementation.GetSimpleTypeFromTypeCode(XmlTypeCode.Token).Datatype;
            object typedValue;
            Exception ex = datatype.TryParseValue(schema.Version, null, null, out typedValue);
            if (ex != null)
            {
                SendValidationEvent(System.SR.Sch_AttributeValueDataTypeDetailed, new string[4] { "version", schema.Version, datatype.TypeCodeString, ex.Message }, ex, schema);
            }
            else
            {
                schema.Version = (string)typedValue;
            }
        }
        Cleanup(schema);
        for (int i = 0; i < schema.Includes.Count; i++)
        {
            XmlSchemaExternal xmlSchemaExternal = (XmlSchemaExternal)schema.Includes[i];
            XmlSchema xmlSchema2 = xmlSchemaExternal.Schema;
            SetParent(xmlSchemaExternal, schema);
            PreprocessAnnotation(xmlSchemaExternal);
            string schemaLocation = xmlSchemaExternal.SchemaLocation;
            if (schemaLocation != null)
            {
                ParseUri(schemaLocation, System.SR.Sch_InvalidSchemaLocation, xmlSchemaExternal);
            }
            else if ((xmlSchemaExternal.Compositor == Compositor.Include || xmlSchemaExternal.Compositor == Compositor.Redefine) && xmlSchema2 == null)
            {
                SendValidationEvent(System.SR.Sch_MissRequiredAttribute, "schemaLocation", xmlSchemaExternal);
            }
            switch (xmlSchemaExternal.Compositor)
            {
            case Compositor.Import:
            {
                XmlSchemaImport xmlSchemaImport = xmlSchemaExternal as XmlSchemaImport;
                string @namespace = xmlSchemaImport.Namespace;
                if (@namespace == schema.TargetNamespace)
                {
                    SendValidationEvent(System.SR.Sch_ImportTargetNamespace, xmlSchemaExternal);
                }
                if (xmlSchema2 != null)
                {
                    if (@namespace != xmlSchema2.TargetNamespace)
                    {
                        SendValidationEvent(System.SR.Sch_MismatchTargetNamespaceImport, @namespace, xmlSchema2.TargetNamespace, xmlSchemaImport);
                    }
                    xmlSchema = _rootSchemaForRedefine;
                    _rootSchemaForRedefine = xmlSchema2;
                    Preprocess(xmlSchema2, @namespace, imports);
                    _rootSchemaForRedefine = xmlSchema;
                }
                else if (@namespace != null)
                {
                    if (@namespace.Length == 0)
                    {
                        SendValidationEvent(System.SR.Sch_InvalidNamespaceAttribute, @namespace, xmlSchemaExternal);
                    }
                    else
                    {
                        ParseUri(@namespace, System.SR.Sch_InvalidNamespace, xmlSchemaExternal);
                    }
                }
                continue;
            }
            case Compositor.Include:
            {
                XmlSchema schema2 = xmlSchemaExternal.Schema;
                if (schema2 == null)
                {
                    continue;
                }
                break;
            }
            case Compositor.Redefine:
                if (xmlSchema2 == null)
                {
                    continue;
                }
                CleanupRedefine(xmlSchemaExternal);
                break;
            }
            if (xmlSchema2.TargetNamespace != null)
            {
                if (schema.TargetNamespace != xmlSchema2.TargetNamespace)
                {
                    SendValidationEvent(System.SR.Sch_MismatchTargetNamespaceInclude, xmlSchema2.TargetNamespace, schema.TargetNamespace, xmlSchemaExternal);
                }
            }
            else if (targetNamespace != null && targetNamespace.Length != 0)
            {
                xmlSchema2 = (xmlSchemaExternal.Schema = GetChameleonSchema(targetNamespace, xmlSchema2));
            }
            Preprocess(xmlSchema2, schema.TargetNamespace, imports);
        }
        _currentSchema = schema;
        BuildRefNamespaces(schema);
        ValidateIdAttribute(schema);
        _targetNamespace = ((targetNamespace == null) ? string.Empty : targetNamespace);
        SetSchemaDefaults(schema);
        _processedExternals.Clear();
        for (int j = 0; j < schema.Includes.Count; j++)
        {
            XmlSchemaExternal xmlSchemaExternal2 = (XmlSchemaExternal)schema.Includes[j];
            XmlSchema schema3 = xmlSchemaExternal2.Schema;
            if (schema3 != null)
            {
                switch (xmlSchemaExternal2.Compositor)
                {
                case Compositor.Include:
                    if (_processedExternals[schema3] != null)
                    {
                        continue;
                    }
                    _processedExternals.Add(schema3, xmlSchemaExternal2);
                    CopyIncludedComponents(schema3, schema);
                    break;
                case Compositor.Redefine:
                    if (_redefinedList == null)
                    {
                        _redefinedList = new ArrayList();
                    }
                    _redefinedList.Add(new RedefineEntry(xmlSchemaExternal2 as XmlSchemaRedefine, _rootSchemaForRedefine));
                    if (_processedExternals[schema3] != null)
                    {
                        continue;
                    }
                    _processedExternals.Add(schema3, xmlSchemaExternal2);
                    CopyIncludedComponents(schema3, schema);
                    break;
                case Compositor.Import:
                    if (schema3 != _rootSchema)
                    {
                        XmlSchemaImport xmlSchemaImport2 = xmlSchemaExternal2 as XmlSchemaImport;
                        string text2 = ((xmlSchemaImport2.Namespace != null) ? xmlSchemaImport2.Namespace : string.Empty);
                        if (!imports.Contains(schema3))
                        {
                            imports.Add(schema3);
                        }
                        if (!_rootSchema.ImportedNamespaces.Contains(text2))
                        {
                            _rootSchema.ImportedNamespaces.Add(text2);
                        }
                    }
                    break;
                }
            }
            else if (xmlSchemaExternal2.Compositor == Compositor.Redefine)
            {
                XmlSchemaRedefine xmlSchemaRedefine = xmlSchemaExternal2 as XmlSchemaRedefine;
                if (xmlSchemaRedefine.BaseUri == null)
                {
                    for (int k = 0; k < xmlSchemaRedefine.Items.Count; k++)
                    {
                        if (!(xmlSchemaRedefine.Items[k] is XmlSchemaAnnotation))
                        {
                            SendValidationEvent(System.SR.Sch_RedefineNoSchema, xmlSchemaRedefine);
                            break;
                        }
                    }
                }
            }
            ValidateIdAttribute(xmlSchemaExternal2);
        }
        List<XmlSchemaObject> list = new List<XmlSchemaObject>();
        XmlSchemaObjectCollection items = schema.Items;
        for (int l = 0; l < items.Count; l++)
        {
            SetParent(items[l], schema);
            if (items[l] is XmlSchemaAttribute xmlSchemaAttribute)
            {
                PreprocessAttribute(xmlSchemaAttribute);
                AddToTable(schema.Attributes, xmlSchemaAttribute.QualifiedName, xmlSchemaAttribute);
            }
            else if (items[l] is XmlSchemaAttributeGroup xmlSchemaAttributeGroup)
            {
                PreprocessAttributeGroup(xmlSchemaAttributeGroup);
                AddToTable(schema.AttributeGroups, xmlSchemaAttributeGroup.QualifiedName, xmlSchemaAttributeGroup);
            }
            else if (items[l] is XmlSchemaComplexType xmlSchemaComplexType)
            {
                PreprocessComplexType(xmlSchemaComplexType, local: false);
                AddToTable(schema.SchemaTypes, xmlSchemaComplexType.QualifiedName, xmlSchemaComplexType);
            }
            else if (items[l] is XmlSchemaSimpleType xmlSchemaSimpleType)
            {
                PreprocessSimpleType(xmlSchemaSimpleType, local: false);
                AddToTable(schema.SchemaTypes, xmlSchemaSimpleType.QualifiedName, xmlSchemaSimpleType);
            }
            else if (items[l] is XmlSchemaElement xmlSchemaElement)
            {
                PreprocessElement(xmlSchemaElement);
                AddToTable(schema.Elements, xmlSchemaElement.QualifiedName, xmlSchemaElement);
            }
            else if (items[l] is XmlSchemaGroup xmlSchemaGroup)
            {
                PreprocessGroup(xmlSchemaGroup);
                AddToTable(schema.Groups, xmlSchemaGroup.QualifiedName, xmlSchemaGroup);
            }
            else if (items[l] is XmlSchemaNotation xmlSchemaNotation)
            {
                PreprocessNotation(xmlSchemaNotation);
                AddToTable(schema.Notations, xmlSchemaNotation.QualifiedName, xmlSchemaNotation);
            }
            else if (items[l] is XmlSchemaAnnotation annotation)
            {
                PreprocessAnnotation(annotation);
            }
            else
            {
                SendValidationEvent(System.SR.Sch_InvalidCollection, items[l]);
                list.Add(items[l]);
            }
        }
        for (int m = 0; m < list.Count; m++)
        {
            schema.Items.Remove(list[m]);
        }
    }

References System.Xml.Schema.Preprocessor._currentSchema, System.Xml.Schema.Preprocessor._processedExternals, System.Xml.Schema.Preprocessor._redefinedList, System.Xml.Schema.Preprocessor._rootSchema, System.Xml.Schema.Preprocessor._rootSchemaForRedefine, System.Xml.Schema.Preprocessor._targetNamespace, System.Collections.Hashtable.Add(), System.Collections.ArrayList.Add(), System.Collections.Generic.Dictionary< TKey, TValue >.Add(), System.Xml.Schema.BaseProcessor.AddToTable(), System.Xml.Schema.Preprocessor.BuildRefNamespaces(), System.Xml.Schema.Preprocessor.Cleanup(), System.Xml.Schema.Preprocessor.CleanupRedefine(), System.Collections.Hashtable.Clear(), System.Collections.Generic.Dictionary< TKey, TValue >.Contains(), System.Collections.ArrayList.Contains(), System.Xml.Schema.Preprocessor.CopyIncludedComponents(), System.Collections.CollectionBase.Count, System.Collections.Generic.Dictionary< TKey, TValue >.Count, System.Xml.Dictionary, System.Xml.Schema.Preprocessor.GetChameleonSchema(), System.Xml.Schema.DatatypeImplementation.GetSimpleTypeFromTypeCode(), System.Xml.Schema.XmlSchema.ImportedNamespaces, System.Xml.Schema.Length, System.list, System.Xml.Schema.Preprocessor.ParseUri(), System.Xml.Schema.Preprocessor.Preprocess(), System.Xml.Schema.Preprocessor.PreprocessAnnotation(), System.Xml.Schema.Preprocessor.PreprocessAttribute(), System.Xml.Schema.Preprocessor.PreprocessAttributeGroup(), System.Xml.Schema.Preprocessor.PreprocessComplexType(), System.Xml.Schema.Preprocessor.PreprocessElement(), System.Xml.Schema.Preprocessor.PreprocessGroup(), System.Xml.Schema.Preprocessor.PreprocessNotation(), System.Xml.Schema.Preprocessor.PreprocessSimpleType(), System.Collections.Generic.Dictionary< TKey, TValue >.Remove(), System.SR.Sch_AttributeValueDataTypeDetailed, System.SR.Sch_ImportTargetNamespace, System.SR.Sch_InvalidCollection, System.SR.Sch_InvalidNamespace, System.SR.Sch_InvalidNamespaceAttribute, System.SR.Sch_InvalidSchemaLocation, System.SR.Sch_InvalidTargetNamespaceAttribute, System.SR.Sch_MismatchTargetNamespaceImport, System.SR.Sch_MismatchTargetNamespaceInclude, System.SR.Sch_MissRequiredAttribute, System.SR.Sch_RedefineNoSchema, System.Xml.Schema.BaseProcessor.SendValidationEvent(), System.Xml.Schema.Preprocessor.SetParent(), System.Xml.Schema.Preprocessor.SetSchemaDefaults(), System.Xml.Schema.XmlSchemaDatatype.TryParseValue(), and System.Xml.Schema.Preprocessor.ValidateIdAttribute().

Referenced by System.Xml.Schema.Preprocessor.Execute(), and System.Xml.Schema.Preprocessor.Preprocess().