Preprocess()

void System.Xml.Schema.SchemaCollectionPreprocessor.Preprocess ( XmlSchema schema, string targetNamespace, Compositor compositor )

inlineprivate

Definition at line 257 of file SchemaCollectionPreprocessor.cs.

    {
        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
            {
                try
                {
                    XmlConvert.ToUri(targetNamespace2);
                }
                catch
                {
                    SendValidationEvent(System.SR.Sch_InvalidNamespace, schema.TargetNamespace, schema);
                }
            }
        }
        if (schema.Version != null)
        {
            try
            {
                XmlConvert.VerifyTOKEN(schema.Version);
            }
            catch (Exception)
            {
                SendValidationEvent(System.SR.Sch_AttributeValueDataType, "version", schema);
            }
        }
        switch (compositor)
        {
        case Compositor.Root:
            if (targetNamespace == null && schema.TargetNamespace != null)
            {
                targetNamespace = schema.TargetNamespace;
            }
            else if (schema.TargetNamespace == null && targetNamespace != null && targetNamespace.Length == 0)
            {
                targetNamespace = null;
            }
            if (targetNamespace != schema.TargetNamespace)
            {
                SendValidationEvent(System.SR.Sch_MismatchTargetNamespaceEx, targetNamespace, schema.TargetNamespace, schema);
            }
            break;
        case Compositor.Import:
            if (targetNamespace != schema.TargetNamespace)
            {
                SendValidationEvent(System.SR.Sch_MismatchTargetNamespaceImport, targetNamespace, schema.TargetNamespace, schema);
            }
            break;
        case Compositor.Include:
            if (schema.TargetNamespace != null && targetNamespace != schema.TargetNamespace)
            {
                SendValidationEvent(System.SR.Sch_MismatchTargetNamespaceInclude, targetNamespace, schema.TargetNamespace, schema);
            }
            break;
        }
        for (int i = 0; i < schema.Includes.Count; i++)
        {
            XmlSchemaExternal xmlSchemaExternal = (XmlSchemaExternal)schema.Includes[i];
            SetParent(xmlSchemaExternal, schema);
            PreprocessAnnotation(xmlSchemaExternal);
            string schemaLocation = xmlSchemaExternal.SchemaLocation;
            if (schemaLocation != null)
            {
                try
                {
                    XmlConvert.ToUri(schemaLocation);
                }
                catch
                {
                    SendValidationEvent(System.SR.Sch_InvalidSchemaLocation, schemaLocation, xmlSchemaExternal);
                }
            }
            else if ((xmlSchemaExternal is XmlSchemaRedefine || xmlSchemaExternal is XmlSchemaInclude) && xmlSchemaExternal.Schema == null)
            {
                SendValidationEvent(System.SR.Sch_MissRequiredAttribute, "schemaLocation", xmlSchemaExternal);
            }
            if (xmlSchemaExternal.Schema != null)
            {
                if (xmlSchemaExternal is XmlSchemaRedefine)
                {
                    Preprocess(xmlSchemaExternal.Schema, schema.TargetNamespace, Compositor.Include);
                }
                else if (xmlSchemaExternal is XmlSchemaImport)
                {
                    if (((XmlSchemaImport)xmlSchemaExternal).Namespace == null && schema.TargetNamespace == null)
                    {
                        SendValidationEvent(System.SR.Sch_ImportTargetNamespaceNull, xmlSchemaExternal);
                    }
                    else if (((XmlSchemaImport)xmlSchemaExternal).Namespace == schema.TargetNamespace)
                    {
                        SendValidationEvent(System.SR.Sch_ImportTargetNamespace, xmlSchemaExternal);
                    }
                    Preprocess(xmlSchemaExternal.Schema, ((XmlSchemaImport)xmlSchemaExternal).Namespace, Compositor.Import);
                }
                else
                {
                    Preprocess(xmlSchemaExternal.Schema, schema.TargetNamespace, Compositor.Include);
                }
            }
            else
            {
                if (!(xmlSchemaExternal is XmlSchemaImport))
                {
                    continue;
                }
                string @namespace = ((XmlSchemaImport)xmlSchemaExternal).Namespace;
                if (@namespace == null)
                {
                    continue;
                }
                if (@namespace.Length == 0)
                {
                    SendValidationEvent(System.SR.Sch_InvalidNamespaceAttribute, @namespace, xmlSchemaExternal);
                    continue;
                }
                try
                {
                    XmlConvert.ToUri(@namespace);
                }
                catch (FormatException)
                {
                    SendValidationEvent(System.SR.Sch_InvalidNamespace, @namespace, xmlSchemaExternal);
                }
            }
        }
        BuildRefNamespaces(schema);
        _targetNamespace = ((targetNamespace == null) ? string.Empty : targetNamespace);
        if (schema.BlockDefault == XmlSchemaDerivationMethod.All)
        {
            _blockDefault = XmlSchemaDerivationMethod.All;
        }
        else if (schema.BlockDefault == XmlSchemaDerivationMethod.None)
        {
            _blockDefault = XmlSchemaDerivationMethod.Empty;
        }
        else
        {
            if (((uint)schema.BlockDefault & 0xFFFFFFF8u) != 0)
            {
                SendValidationEvent(System.SR.Sch_InvalidBlockDefaultValue, schema);
            }
            _blockDefault = schema.BlockDefault & (XmlSchemaDerivationMethod.Substitution | XmlSchemaDerivationMethod.Extension | XmlSchemaDerivationMethod.Restriction);
        }
        if (schema.FinalDefault == XmlSchemaDerivationMethod.All)
        {
            _finalDefault = XmlSchemaDerivationMethod.All;
        }
        else if (schema.FinalDefault == XmlSchemaDerivationMethod.None)
        {
            _finalDefault = XmlSchemaDerivationMethod.Empty;
        }
        else
        {
            if (((uint)schema.FinalDefault & 0xFFFFFFE1u) != 0)
            {
                SendValidationEvent(System.SR.Sch_InvalidFinalDefaultValue, schema);
            }
            _finalDefault = schema.FinalDefault & (XmlSchemaDerivationMethod.Extension | XmlSchemaDerivationMethod.Restriction | XmlSchemaDerivationMethod.List | XmlSchemaDerivationMethod.Union);
        }
        _elementFormDefault = schema.ElementFormDefault;
        if (_elementFormDefault == XmlSchemaForm.None)
        {
            _elementFormDefault = XmlSchemaForm.Unqualified;
        }
        _attributeFormDefault = schema.AttributeFormDefault;
        if (_attributeFormDefault == XmlSchemaForm.None)
        {
            _attributeFormDefault = XmlSchemaForm.Unqualified;
        }
        for (int j = 0; j < schema.Includes.Count; j++)
        {
            XmlSchemaExternal xmlSchemaExternal2 = (XmlSchemaExternal)schema.Includes[j];
            if (xmlSchemaExternal2 is XmlSchemaRedefine)
            {
                XmlSchemaRedefine xmlSchemaRedefine = (XmlSchemaRedefine)xmlSchemaExternal2;
                if (xmlSchemaExternal2.Schema != null)
                {
                    PreprocessRedefine(xmlSchemaRedefine);
                }
                else
                {
                    for (int k = 0; k < xmlSchemaRedefine.Items.Count; k++)
                    {
                        if (!(xmlSchemaRedefine.Items[k] is XmlSchemaAnnotation))
                        {
                            SendValidationEvent(System.SR.Sch_RedefineNoSchema, xmlSchemaRedefine);
                            break;
                        }
                    }
                }
            }
            XmlSchema schema2 = xmlSchemaExternal2.Schema;
            if (schema2 != null)
            {
                foreach (XmlSchemaElement value in schema2.Elements.Values)
                {
                    AddToTable(schema.Elements, value.QualifiedName, value);
                }
                foreach (XmlSchemaAttribute value2 in schema2.Attributes.Values)
                {
                    AddToTable(schema.Attributes, value2.QualifiedName, value2);
                }
                foreach (XmlSchemaGroup value3 in schema2.Groups.Values)
                {
                    AddToTable(schema.Groups, value3.QualifiedName, value3);
                }
                foreach (XmlSchemaAttributeGroup value4 in schema2.AttributeGroups.Values)
                {
                    AddToTable(schema.AttributeGroups, value4.QualifiedName, value4);
                }
                foreach (XmlSchemaType value5 in schema2.SchemaTypes.Values)
                {
                    AddToTable(schema.SchemaTypes, value5.QualifiedName, value5);
                }
                foreach (XmlSchemaNotation value6 in schema2.Notations.Values)
                {
                    AddToTable(schema.Notations, value6.QualifiedName, value6);
                }
            }
            ValidateIdAttribute(xmlSchemaExternal2);
        }
        List<XmlSchemaObject> list = new List<XmlSchemaObject>();
        for (int l = 0; l < schema.Items.Count; l++)
        {
            SetParent(schema.Items[l], schema);
            if (schema.Items[l] is XmlSchemaAttribute xmlSchemaAttribute2)
            {
                PreprocessAttribute(xmlSchemaAttribute2);
                AddToTable(schema.Attributes, xmlSchemaAttribute2.QualifiedName, xmlSchemaAttribute2);
            }
            else if (schema.Items[l] is XmlSchemaAttributeGroup)
            {
                XmlSchemaAttributeGroup xmlSchemaAttributeGroup2 = (XmlSchemaAttributeGroup)schema.Items[l];
                PreprocessAttributeGroup(xmlSchemaAttributeGroup2);
                AddToTable(schema.AttributeGroups, xmlSchemaAttributeGroup2.QualifiedName, xmlSchemaAttributeGroup2);
            }
            else if (schema.Items[l] is XmlSchemaComplexType)
            {
                XmlSchemaComplexType xmlSchemaComplexType = (XmlSchemaComplexType)schema.Items[l];
                PreprocessComplexType(xmlSchemaComplexType, local: false);
                AddToTable(schema.SchemaTypes, xmlSchemaComplexType.QualifiedName, xmlSchemaComplexType);
            }
            else if (schema.Items[l] is XmlSchemaSimpleType)
            {
                XmlSchemaSimpleType xmlSchemaSimpleType = (XmlSchemaSimpleType)schema.Items[l];
                PreprocessSimpleType(xmlSchemaSimpleType, local: false);
                AddToTable(schema.SchemaTypes, xmlSchemaSimpleType.QualifiedName, xmlSchemaSimpleType);
            }
            else if (schema.Items[l] is XmlSchemaElement)
            {
                XmlSchemaElement xmlSchemaElement2 = (XmlSchemaElement)schema.Items[l];
                PreprocessElement(xmlSchemaElement2);
                AddToTable(schema.Elements, xmlSchemaElement2.QualifiedName, xmlSchemaElement2);
            }
            else if (schema.Items[l] is XmlSchemaGroup)
            {
                XmlSchemaGroup xmlSchemaGroup2 = (XmlSchemaGroup)schema.Items[l];
                PreprocessGroup(xmlSchemaGroup2);
                AddToTable(schema.Groups, xmlSchemaGroup2.QualifiedName, xmlSchemaGroup2);
            }
            else if (schema.Items[l] is XmlSchemaNotation)
            {
                XmlSchemaNotation xmlSchemaNotation2 = (XmlSchemaNotation)schema.Items[l];
                PreprocessNotation(xmlSchemaNotation2);
                AddToTable(schema.Notations, xmlSchemaNotation2.QualifiedName, xmlSchemaNotation2);
            }
            else if (!(schema.Items[l] is XmlSchemaAnnotation))
            {
                SendValidationEvent(System.SR.Sch_InvalidCollection, schema.Items[l]);
                list.Add(schema.Items[l]);
            }
        }
        for (int m = 0; m < list.Count; m++)
        {
            schema.Items.Remove(list[m]);
        }
        schema.IsProcessing = false;
    }

References System.Xml.Schema.SchemaCollectionPreprocessor._attributeFormDefault, System.Xml.Schema.SchemaCollectionPreprocessor._blockDefault, System.Xml.Schema.SchemaCollectionPreprocessor._elementFormDefault, System.Xml.Schema.SchemaCollectionPreprocessor._finalDefault, System.Xml.Schema.SchemaCollectionPreprocessor._targetNamespace, System.Collections.Generic.Dictionary< TKey, TValue >.Add(), System.Xml.Schema.BaseProcessor.AddToTable(), System.Xml.Schema.SchemaCollectionPreprocessor.BuildRefNamespaces(), System.Collections.Generic.Dictionary< TKey, TValue >.Count, System.Xml.Dictionary, System.Xml.Schema.Length, System.list, System.Xml.Schema.Namespace, System.Xml.Schema.SchemaCollectionPreprocessor.Preprocess(), System.Xml.Schema.SchemaCollectionPreprocessor.PreprocessAnnotation(), System.Xml.Schema.SchemaCollectionPreprocessor.PreprocessAttribute(), System.Xml.Schema.SchemaCollectionPreprocessor.PreprocessAttributeGroup(), System.Xml.Schema.SchemaCollectionPreprocessor.PreprocessComplexType(), System.Xml.Schema.SchemaCollectionPreprocessor.PreprocessElement(), System.Xml.Schema.SchemaCollectionPreprocessor.PreprocessGroup(), System.Xml.Schema.SchemaCollectionPreprocessor.PreprocessNotation(), System.Xml.Schema.SchemaCollectionPreprocessor.PreprocessRedefine(), System.Xml.Schema.SchemaCollectionPreprocessor.PreprocessSimpleType(), System.Collections.Generic.Dictionary< TKey, TValue >.Remove(), System.SR.Sch_AttributeValueDataType, System.SR.Sch_ImportTargetNamespace, System.SR.Sch_ImportTargetNamespaceNull, System.SR.Sch_InvalidBlockDefaultValue, System.SR.Sch_InvalidCollection, System.SR.Sch_InvalidFinalDefaultValue, System.SR.Sch_InvalidNamespace, System.SR.Sch_InvalidNamespaceAttribute, System.SR.Sch_InvalidSchemaLocation, System.SR.Sch_InvalidTargetNamespaceAttribute, System.SR.Sch_MismatchTargetNamespaceEx, System.SR.Sch_MismatchTargetNamespaceImport, System.SR.Sch_MismatchTargetNamespaceInclude, System.SR.Sch_MissRequiredAttribute, System.SR.Sch_RedefineNoSchema, System.Xml.Schema.BaseProcessor.SendValidationEvent(), System.Xml.Schema.SchemaCollectionPreprocessor.SetParent(), System.Xml.XmlConvert.ToUri(), System.Xml.Schema.SchemaCollectionPreprocessor.ValidateIdAttribute(), System.value, System.Collections.Generic.Dictionary< TKey, TValue >.Values, and System.Xml.XmlConvert.VerifyTOKEN().

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