1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtXmlPatterns module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qxsdschemaresolver_p.h"

    43 

    44 #include "qderivedinteger_p.h"

    45 #include "qderivedstring_p.h"

    46 #include "qqnamevalue_p.h"

    47 #include "qxsdattributereference_p.h"

    48 #include "qxsdparticlechecker_p.h"

    49 #include "qxsdreference_p.h"

    50 #include "qxsdschemacontext_p.h"

    51 #include "qxsdschemahelper_p.h"

    52 #include "qxsdschemaparsercontext_p.h"

    53 #include "qxsdschematypesfactory_p.h"

    54 

    55 QT_BEGIN_NAMESPACE

    56 

    57 using namespace QPatternist;

    58 

    59 XsdSchemaResolver::XsdSchemaResolver(const QExplicitlySharedDataPointer<XsdSchemaContext> &context, const XsdSchemaParserContext *parserContext)

    60     : m_context(context)

    61     , m_checker(parserContext->checker())

    62     , m_namePool(parserContext->namePool())

    63     , m_schema(parserContext->schema())

    64 {

    65     m_keyReferences.reserve(20);

    66     m_simpleRestrictionBases.reserve(20);

    67     m_simpleListTypes.reserve(20);

    68     m_simpleUnionTypes.reserve(20);

    69     m_elementTypes.reserve(20);

    70     m_complexBaseTypes.reserve(20);

    71     m_attributeTypes.reserve(20);

    72     m_alternativeTypes.reserve(20);

    73     m_alternativeTypeElements.reserve(20);

    74     m_substitutionGroupAffiliations.reserve(20);

    75 

    76     m_predefinedSchemaTypes = m_context->schemaTypeFactory()->types().values();

    77 }

    78 

    79 XsdSchemaResolver::~XsdSchemaResolver()

    80 {

    81 }

    82 

    83 void XsdSchemaResolver::resolve()

    84 {

    85     m_checker->addComponentLocationHash(m_componentLocationHash);

    86 

    87     // resolve the base types for all types

    88     resolveSimpleRestrictionBaseTypes();

    89     resolveComplexBaseTypes();

    90 

    91     // do the basic checks which depend on having a base type available

    92     m_checker->basicCheck();

    93 

    94     // resolve further types that only map a type name to a type object

    95     resolveSimpleListType();

    96     resolveSimpleUnionTypes();

    97     resolveElementTypes();

    98     resolveAttributeTypes();

    99     resolveAlternativeTypes();

   100 

   101     // resolve objects that do not need information about inheritance

   102     resolveKeyReferences();

   103     resolveSubstitutionGroupAffiliations();

   104 

   105     // resolve objects that do need information about inheritance

   106     resolveSimpleRestrictions();

   107     resolveSimpleContentComplexTypes();

   108 

   109     // resolve objects which replace place holders

   110     resolveTermReferences();

   111     resolveAttributeTermReferences();

   112 

   113     // resolve additional objects that do need information about inheritance

   114     resolveAttributeInheritance();

   115     resolveComplexContentComplexTypes();

   116     resolveSubstitutionGroups();

   117 

   118     resolveEnumerationFacetValues();

   119 

   120     checkRedefinedGroups();

   121     checkRedefinedAttributeGroups();

   122 

   123     // check the constraining facets before we resolve them

   124     m_checker->checkConstrainingFacets();

   125 

   126     // add it again, as we may have added new components in the meantime

   127     m_checker->addComponentLocationHash(m_componentLocationHash);

   128 

   129     m_checker->check();

   130 }

   131 

   132 void XsdSchemaResolver::addKeyReference(const XsdElement::Ptr &element, const XsdIdentityConstraint::Ptr &keyRef, const QXmlName &reference, const QSourceLocation &location)

   133 {

   134     KeyReference item;

   135     item.element = element;

   136     item.keyRef = keyRef;

   137     item.reference = reference;

   138     item.location = location;

   139 

   140     m_keyReferences.append(item);

   141 }

   142 

   143 void XsdSchemaResolver::addSimpleRestrictionBase(const XsdSimpleType::Ptr &simpleType, const QXmlName &baseName, const QSourceLocation &location)

   144 {

   145     SimpleRestrictionBase item;

   146     item.simpleType = simpleType;

   147     item.baseName = baseName;

   148     item.location = location;

   149 

   150     m_simpleRestrictionBases.append(item);

   151 }

   152 

   153 void XsdSchemaResolver::removeSimpleRestrictionBase(const XsdSimpleType::Ptr &type)

   154 {

   155     for (int i = 0; i < m_simpleRestrictionBases.count(); ++i) {

   156         if (m_simpleRestrictionBases.at(i).simpleType == type) {

   157             m_simpleRestrictionBases.remove(i);

   158             break;

   159         }

   160     }

   161 }

   162 

   163 void XsdSchemaResolver::addSimpleListType(const XsdSimpleType::Ptr &simpleType, const QXmlName &typeName, const QSourceLocation &location)

   164 {

   165     SimpleListType item;

   166     item.simpleType = simpleType;

   167     item.typeName = typeName;

   168     item.location = location;

   169 

   170     m_simpleListTypes.append(item);

   171 }

   172 

   173 void XsdSchemaResolver::addSimpleUnionTypes(const XsdSimpleType::Ptr &simpleType, const QList<QXmlName> &typeNames, const QSourceLocation &location)

   174 {

   175     SimpleUnionType item;

   176     item.simpleType = simpleType;

   177     item.typeNames = typeNames;

   178     item.location = location;

   179 

   180     m_simpleUnionTypes.append(item);

   181 }

   182 

   183 void XsdSchemaResolver::addElementType(const XsdElement::Ptr &element, const QXmlName &typeName, const QSourceLocation &location)

   184 {

   185     ElementType item;

   186     item.element = element;

   187     item.typeName = typeName;

   188     item.location = location;

   189 

   190     m_elementTypes.append(item);

   191 }

   192 

   193 void XsdSchemaResolver::addComplexBaseType(const XsdComplexType::Ptr &complexType, const QXmlName &baseName, const QSourceLocation &location, const XsdFacet::Hash &facets)

   194 {

   195     ComplexBaseType item;

   196     item.complexType = complexType;

   197     item.baseName = baseName;

   198     item.location = location;

   199     item.facets = facets;

   200 

   201     m_complexBaseTypes.append(item);

   202 }

   203 

   204 void XsdSchemaResolver::removeComplexBaseType(const XsdComplexType::Ptr &type)

   205 {

   206     for (int i = 0; i < m_complexBaseTypes.count(); ++i) {

   207         if (m_complexBaseTypes.at(i).complexType == type) {

   208             m_complexBaseTypes.remove(i);

   209             break;

   210         }

   211     }

   212 }

   213 

   214 void XsdSchemaResolver::addComplexContentType(const XsdComplexType::Ptr &complexType, const XsdParticle::Ptr &content, bool mixed)

   215 {

   216     ComplexContentType item;

   217     item.complexType = complexType;

   218     item.explicitContent = content;

   219     item.effectiveMixed = mixed;

   220     m_complexContentTypes.append(item);

   221 }

   222 

   223 void XsdSchemaResolver::addAttributeType(const XsdAttribute::Ptr &attribute, const QXmlName &typeName, const QSourceLocation &location)

   224 {

   225     AttributeType item;

   226     item.attribute = attribute;

   227     item.typeName = typeName;

   228     item.location = location;

   229 

   230     m_attributeTypes.append(item);

   231 }

   232 

   233 void XsdSchemaResolver::addAlternativeType(const XsdAlternative::Ptr &alternative, const QXmlName &typeName, const QSourceLocation &location)

   234 {

   235     AlternativeType item;

   236     item.alternative = alternative;

   237     item.typeName = typeName;

   238     item.location = location;

   239 

   240     m_alternativeTypes.append(item);

   241 }

   242 

   243 void XsdSchemaResolver::addAlternativeType(const XsdAlternative::Ptr &alternative, const XsdElement::Ptr &element)

   244 {

   245     AlternativeTypeElement item;

   246     item.alternative = alternative;

   247     item.element = element;

   248 

   249     m_alternativeTypeElements.append(item);

   250 }

   251 

   252 void XsdSchemaResolver::addSubstitutionGroupAffiliation(const XsdElement::Ptr &element, const QList<QXmlName> &elementNames, const QSourceLocation &location)

   253 {

   254     SubstitutionGroupAffiliation item;

   255     item.element = element;

   256     item.elementNames = elementNames;

   257     item.location = location;

   258 

   259     m_substitutionGroupAffiliations.append(item);

   260 }

   261 

   262 void XsdSchemaResolver::addSubstitutionGroupType(const XsdElement::Ptr &element)

   263 {

   264     m_substitutionGroupTypes.append(element);

   265 }

   266 

   267 void XsdSchemaResolver::addComponentLocationHash(const ComponentLocationHash &hash)

   268 {

   269     m_componentLocationHash.unite(hash);

   270 }

   271 

   272 void XsdSchemaResolver::addEnumerationFacetValue(const AtomicValue::Ptr &facetValue, const NamespaceSupport &namespaceSupport)

   273 {

   274     m_enumerationFacetValues.insert(facetValue, namespaceSupport);

   275 }

   276 

   277 void XsdSchemaResolver::addRedefinedGroups(const XsdModelGroup::Ptr &redefinedGroup, const XsdModelGroup::Ptr &group)

   278 {

   279     RedefinedGroups item;

   280     item.redefinedGroup = redefinedGroup;

   281     item.group = group;

   282 

   283     m_redefinedGroups.append(item);

   284 }

   285 

   286 void XsdSchemaResolver::addRedefinedAttributeGroups(const XsdAttributeGroup::Ptr &redefinedGroup, const XsdAttributeGroup::Ptr &group)

   287 {

   288     RedefinedAttributeGroups item;

   289     item.redefinedGroup = redefinedGroup;

   290     item.group = group;

   291 

   292     m_redefinedAttributeGroups.append(item);

   293 }

   294 

   295 void XsdSchemaResolver::addAllGroupCheck(const XsdReference::Ptr &reference)

   296 {

   297     m_allGroups.insert(reference);

   298 }

   299 

   300 void XsdSchemaResolver::copyDataTo(const XsdSchemaResolver::Ptr &other) const

   301 {

   302     other->m_keyReferences << m_keyReferences;

   303     other->m_simpleRestrictionBases << m_simpleRestrictionBases;

   304     other->m_simpleListTypes << m_simpleListTypes;

   305     other->m_simpleUnionTypes << m_simpleUnionTypes;

   306     other->m_elementTypes << m_elementTypes;

   307     other->m_complexBaseTypes << m_complexBaseTypes;

   308     other->m_complexContentTypes << m_complexContentTypes;

   309     other->m_attributeTypes << m_attributeTypes;

   310     other->m_alternativeTypes << m_alternativeTypes;

   311     other->m_alternativeTypeElements << m_alternativeTypeElements;

   312     other->m_substitutionGroupAffiliations << m_substitutionGroupAffiliations;

   313     other->m_substitutionGroupTypes << m_substitutionGroupTypes;

   314 }

   315 

   316 QXmlName XsdSchemaResolver::baseTypeNameOfType(const SchemaType::Ptr &type) const

   317 {

   318     for (int i = 0; i < m_simpleRestrictionBases.count(); ++i) {

   319         if (m_simpleRestrictionBases.at(i).simpleType == type)

   320             return m_simpleRestrictionBases.at(i).baseName;

   321     }

   322 

   323     for (int i = 0; i < m_complexBaseTypes.count(); ++i) {

   324         if (m_complexBaseTypes.at(i).complexType == type)

   325             return m_complexBaseTypes.at(i).baseName;

   326     }

   327 

   328     return QXmlName();

   329 }

   330 

   331 QXmlName XsdSchemaResolver::typeNameOfAttribute(const XsdAttribute::Ptr &attribute) const

   332 {

   333     for (int i = 0; i < m_attributeTypes.count(); ++i) {

   334         if (m_attributeTypes.at(i).attribute == attribute)

   335             return m_attributeTypes.at(i).typeName;

   336     }

   337 

   338     return QXmlName();

   339 }

   340 

   341 void XsdSchemaResolver::setDefaultOpenContent(const XsdComplexType::OpenContent::Ptr &openContent, bool appliesToEmpty)

   342 {

   343     m_defaultOpenContent = openContent;

   344     m_defaultOpenContentAppliesToEmpty = appliesToEmpty;

   345 }

   346 

   347 void XsdSchemaResolver::resolveKeyReferences()

   348 {

   349     for (int i = 0; i < m_keyReferences.count(); ++i) {

   350         const KeyReference ref = m_keyReferences.at(i);

   351 

   352         const XsdIdentityConstraint::Ptr constraint = m_schema->identityConstraint(ref.reference);

   353         if (!constraint) {

   354             m_context->error(QtXmlPatterns::tr("%1 references unknown %2 or %3 element %4.")

   355                                               .arg(formatKeyword(ref.keyRef->displayName(m_namePool)))

   356                                               .arg(formatElement("key"))

   357                                               .arg(formatElement("unique"))

   358                                               .arg(formatKeyword(m_namePool, ref.reference)),

   359                              XsdSchemaContext::XSDError, ref.location);

   360             return;

   361         }

   362 

   363         if (constraint->category() != XsdIdentityConstraint::Key && constraint->category() != XsdIdentityConstraint::Unique) { // only key and unique can be referenced

   364             m_context->error(QtXmlPatterns::tr("%1 references identity constraint %2 that is no %3 or %4 element.")

   365                                               .arg(formatKeyword(ref.keyRef->displayName(m_namePool)))

   366                                               .arg(formatKeyword(m_namePool, ref.reference))

   367                                               .arg(formatElement("key"))

   368                                               .arg(formatElement("unique")),

   369                              XsdSchemaContext::XSDError, ref.location);

   370             return;

   371         }

   372 

   373         if (constraint->fields().count() != ref.keyRef->fields().count()) {

   374             m_context->error(QtXmlPatterns::tr("%1 has a different number of fields from the identity constraint %2 that it references.")

   375                                               .arg(formatKeyword(ref.keyRef->displayName(m_namePool)))

   376                                               .arg(formatKeyword(m_namePool, ref.reference)),

   377                              XsdSchemaContext::XSDError, ref.location);

   378             return;

   379         }

   380 

   381         ref.keyRef->setReferencedKey(constraint);

   382     }

   383 }

   384 

   385 void XsdSchemaResolver::resolveSimpleRestrictionBaseTypes()

   386 {

   387     // iterate over all simple types that are derived by restriction

   388     for (int i = 0; i < m_simpleRestrictionBases.count(); ++i) {

   389         const SimpleRestrictionBase item = m_simpleRestrictionBases.at(i);

   390 

   391         // find the base type

   392         SchemaType::Ptr type = m_schema->type(item.baseName);

   393         if (!type) {

   394             // maybe it's a basic type...

   395             type = m_context->schemaTypeFactory()->createSchemaType(item.baseName);

   396             if (!type) {

   397                 m_context->error(QtXmlPatterns::tr("Base type %1 of %2 element cannot be resolved.")

   398                                                   .arg(formatType(m_namePool, item.baseName))

   399                                                   .arg(formatElement("restriction")),

   400                                  XsdSchemaContext::XSDError, item.location);

   401                 return;

   402             }

   403         }

   404 

   405         item.simpleType->setWxsSuperType(type);

   406     }

   407 }

   408 

   409 void XsdSchemaResolver::resolveSimpleRestrictions()

   410 {

   411     XsdSimpleType::List simpleTypes;

   412 

   413     // first collect the global simple types

   414     const SchemaType::List types = m_schema->types();

   415     for (int i = 0; i < types.count(); ++i) {

   416         if (types.at(i)->isSimpleType() && (types.at(i)->derivationMethod() == SchemaType::DerivationRestriction))

   417             simpleTypes.append(types.at(i));

   418     }

   419 

   420     // then collect all anonymous simple types

   421     const SchemaType::List anonymousTypes = m_schema->anonymousTypes();

   422     for (int i = 0; i < anonymousTypes.count(); ++i) {

   423         if (anonymousTypes.at(i)->isSimpleType() && (anonymousTypes.at(i)->derivationMethod() == SchemaType::DerivationRestriction))

   424             simpleTypes.append(anonymousTypes.at(i));

   425     }

   426 

   427     QSet<XsdSimpleType::Ptr> visitedTypes;

   428     for (int i = 0; i < simpleTypes.count(); ++i) {

   429         resolveSimpleRestrictions(simpleTypes.at(i), visitedTypes);

   430     }

   431 }

   432 

   433 void XsdSchemaResolver::resolveSimpleRestrictions(const XsdSimpleType::Ptr &simpleType, QSet<XsdSimpleType::Ptr> &visitedTypes)

   434 {

   435     if (visitedTypes.contains(simpleType))

   436         return;

   437     else

   438         visitedTypes.insert(simpleType);

   439 

   440     if (simpleType->derivationMethod() != XsdSimpleType::DerivationRestriction)

   441         return;

   442 

   443     // as xs:NMTOKENS, xs:ENTITIES and xs:IDREFS are provided by our XsdSchemaTypesFactory, they are

   444     // setup correctly already and shouldn't be handled here

   445     if (m_predefinedSchemaTypes.contains(simpleType))

   446         return;

   447 

   448     const SchemaType::Ptr baseType = simpleType->wxsSuperType();

   449     Q_ASSERT(baseType);

   450 

   451     if (baseType->isDefinedBySchema())

   452         resolveSimpleRestrictions(XsdSimpleType::Ptr(baseType), visitedTypes);

   453 

   454     simpleType->setCategory(baseType->category());

   455 

   456     if (simpleType->category() == XsdSimpleType::SimpleTypeAtomic) {

   457         QSet<AnySimpleType::Ptr> visitedPrimitiveTypes;

   458         const AnySimpleType::Ptr primitiveType = findPrimitiveType(baseType, visitedPrimitiveTypes);

   459         simpleType->setPrimitiveType(primitiveType);

   460     } else if (simpleType->category() == XsdSimpleType::SimpleTypeList) {

   461         const XsdSimpleType::Ptr simpleBaseType = baseType;

   462         simpleType->setItemType(simpleBaseType->itemType());

   463     } else if (simpleType->category() == XsdSimpleType::SimpleTypeUnion) {

   464         const XsdSimpleType::Ptr simpleBaseType = baseType;

   465         simpleType->setMemberTypes(simpleBaseType->memberTypes());

   466     }

   467 }

   468 

   469 void XsdSchemaResolver::resolveSimpleListType()

   470 {

   471     // iterate over all simple types where the item type shall be resolved

   472     for (int i = 0; i < m_simpleListTypes.count(); ++i) {

   473         const SimpleListType item = m_simpleListTypes.at(i);

   474 

   475         // try to resolve the name

   476         SchemaType::Ptr type = m_schema->type(item.typeName);

   477         if (!type) {

   478             // maybe it's a basic type...

   479             type = m_context->schemaTypeFactory()->createSchemaType(item.typeName);

   480             if (!type) {

   481                 m_context->error(QtXmlPatterns::tr("Item type %1 of %2 element cannot be resolved.")

   482                                                   .arg(formatType(m_namePool, item.typeName))

   483                                                   .arg(formatElement("list")),

   484                                  XsdSchemaContext::XSDError, item.location);

   485                 return;

   486             }

   487         }

   488 

   489         item.simpleType->setItemType(type);

   490     }

   491 }

   492 

   493 void XsdSchemaResolver::resolveSimpleUnionTypes()

   494 {

   495     // iterate over all simple types where the union member types shall be resolved

   496     for (int i = 0; i < m_simpleUnionTypes.count(); ++i) {

   497         const SimpleUnionType item = m_simpleUnionTypes.at(i);

   498 

   499         AnySimpleType::List memberTypes;

   500 

   501         // iterate over all union member type names

   502         const QList<QXmlName> typeNames = item.typeNames;

   503         for (int j = 0; j < typeNames.count(); ++j) {

   504             const QXmlName typeName = typeNames.at(j);

   505 

   506             // try to resolve the name

   507             SchemaType::Ptr type = m_schema->type(typeName);

   508             if (!type) {

   509                 // maybe it's a basic type...

   510                 type = m_context->schemaTypeFactory()->createSchemaType(typeName);

   511                 if (!type) {

   512                     m_context->error(QtXmlPatterns::tr("Member type %1 of %2 element cannot be resolved.")

   513                                                       .arg(formatType(m_namePool, typeName))

   514                                                       .arg(formatElement("union")),

   515                                      XsdSchemaContext::XSDError, item.location);

   516                     return;

   517                 }

   518             }

   519 

   520             memberTypes.append(type);

   521         }

   522 

   523         // append the types that have been defined as <simpleType> children

   524         memberTypes << item.simpleType->memberTypes();

   525 

   526         item.simpleType->setMemberTypes(memberTypes);

   527     }

   528 }

   529 

   530 void XsdSchemaResolver::resolveElementTypes()

   531 {

   532     for (int i = 0; i < m_elementTypes.count(); ++i) {

   533         const ElementType item = m_elementTypes.at(i);

   534 

   535         SchemaType::Ptr type = m_schema->type(item.typeName);

   536         if (!type) {

   537             // maybe it's a basic type...

   538             type = m_context->schemaTypeFactory()->createSchemaType(item.typeName);

   539             if (!type) {

   540                 m_context->error(QtXmlPatterns::tr("Type %1 of %2 element cannot be resolved.")

   541                                                   .arg(formatType(m_namePool, item.typeName))

   542                                                   .arg(formatElement("element")),

   543                                  XsdSchemaContext::XSDError, item.location);

   544                 return;

   545             }

   546         }

   547 

   548         item.element->setType(type);

   549     }

   550 }

   551 

   552 void XsdSchemaResolver::resolveComplexBaseTypes()

   553 {

   554     for (int i = 0; i < m_complexBaseTypes.count(); ++i) {

   555         const ComplexBaseType item = m_complexBaseTypes.at(i);

   556 

   557         SchemaType::Ptr type = m_schema->type(item.baseName);

   558         if (!type) {

   559             // maybe it's a basic type...

   560             type = m_context->schemaTypeFactory()->createSchemaType(item.baseName);

   561             if (!type) {

   562                 m_context->error(QtXmlPatterns::tr("Base type %1 of complex type cannot be resolved.").arg(formatType(m_namePool, item.baseName)), XsdSchemaContext::XSDError, item.location);

   563                 return;

   564             }

   565         }

   566 

   567         if (item.complexType->contentType()->variety() == XsdComplexType::ContentType::Simple) {

   568             if (type->isComplexType() && type->isDefinedBySchema()) {

   569                 const XsdComplexType::Ptr baseType = type;

   570                 if (baseType->contentType()->variety() != XsdComplexType::ContentType::Simple) {

   571                     m_context->error(QtXmlPatterns::tr("%1 cannot have complex base type that has a %2.")

   572                                                       .arg(formatElement("simpleContent"))

   573                                                       .arg(formatElement("complexContent")),

   574                                      XsdSchemaContext::XSDError, item.location);

   575                     return;

   576                 }

   577             }

   578         }

   579 

   580         item.complexType->setWxsSuperType(type);

   581     }

   582 }

   583 

   584 void XsdSchemaResolver::resolveSimpleContentComplexTypes()

   585 {

   586     XsdComplexType::List complexTypes;

   587 

   588     // first collect the global complex types

   589     const SchemaType::List types = m_schema->types();

   590     for (int i = 0; i < types.count(); ++i) {

   591         if (types.at(i)->isComplexType() && types.at(i)->isDefinedBySchema())

   592             complexTypes.append(types.at(i));

   593     }

   594 

   595     // then collect all anonymous simple types

   596     const SchemaType::List anonymousTypes = m_schema->anonymousTypes();

   597     for (int i = 0; i < anonymousTypes.count(); ++i) {

   598         if (anonymousTypes.at(i)->isComplexType() && anonymousTypes.at(i)->isDefinedBySchema())

   599             complexTypes.append(anonymousTypes.at(i));

   600     }

   601 

   602     QSet<XsdComplexType::Ptr> visitedTypes;

   603     for (int i = 0; i < complexTypes.count(); ++i) {

   604         if (XsdComplexType::Ptr(complexTypes.at(i))->contentType()->variety() == XsdComplexType::ContentType::Simple)

   605             resolveSimpleContentComplexTypes(complexTypes.at(i), visitedTypes);

   606     }

   607 }

   608 

   609 void XsdSchemaResolver::resolveSimpleContentComplexTypes(const XsdComplexType::Ptr &complexType, QSet<XsdComplexType::Ptr> &visitedTypes)

   610 {

   611     if (visitedTypes.contains(complexType))

   612         return;

   613     else

   614         visitedTypes.insert(complexType);

   615 

   616     const SchemaType::Ptr baseType = complexType->wxsSuperType();

   617 

   618     // at this point simple types have been resolved already, so we care about

   619     // complex types here only

   620 

   621     // http://www.w3.org/TR/xmlschema11-1/#dcl.ctd.ctsc

   622     // 1

   623     if (baseType->isComplexType() && baseType->isDefinedBySchema()) {

   624         const XsdComplexType::Ptr complexBaseType = baseType;

   625 

   626         resolveSimpleContentComplexTypes(complexBaseType, visitedTypes);

   627 

   628         if (complexBaseType->contentType()->variety() == XsdComplexType::ContentType::Simple) {

   629             if (complexType->derivationMethod() == XsdComplexType::DerivationRestriction) {

   630                 if (complexType->contentType()->simpleType()) {

   631                     // 1.1 contains the content of the <simpleType> already

   632                 } else {

   633                     // 1.2

   634                     const XsdSimpleType::Ptr anonType(new XsdSimpleType());

   635                     anonType->setCategory(complexBaseType->contentType()->simpleType()->category());

   636                     anonType->setDerivationMethod(XsdSimpleType::DerivationRestriction);

   637                     anonType->setWxsSuperType(complexBaseType->contentType()->simpleType());

   638                     anonType->setFacets(complexTypeFacets(complexType));

   639 

   640                     QSet<AnySimpleType::Ptr> visitedPrimitiveTypes;

   641                     const AnySimpleType::Ptr primitiveType = findPrimitiveType(anonType->wxsSuperType(), visitedPrimitiveTypes);

   642                     anonType->setPrimitiveType(primitiveType);

   643 

   644                     complexType->contentType()->setSimpleType(anonType);

   645 

   646                     m_schema->addAnonymousType(anonType);

   647                     m_componentLocationHash.insert(anonType, m_componentLocationHash.value(complexType));

   648                 }

   649             } else if (complexBaseType->derivationMethod() == XsdComplexType::DerivationExtension) { // 3

   650                 complexType->contentType()->setSimpleType(complexBaseType->contentType()->simpleType());

   651             }

   652         } else if (complexBaseType->contentType()->variety() == XsdComplexType::ContentType::Mixed &&

   653                    complexType->derivationMethod() == XsdComplexType::DerivationRestriction &&

   654                    XsdSchemaHelper::isParticleEmptiable(complexBaseType->contentType()->particle())) { // 2

   655             // simple type was already set in parser

   656 

   657             const XsdSimpleType::Ptr anonType(new XsdSimpleType());

   658             anonType->setCategory(complexType->contentType()->simpleType()->category());

   659             anonType->setDerivationMethod(XsdSimpleType::DerivationRestriction);

   660             anonType->setWxsSuperType(complexType->contentType()->simpleType());

   661             anonType->setFacets(complexTypeFacets(complexType));

   662 

   663             QSet<AnySimpleType::Ptr> visitedPrimitiveTypes;

   664             const AnySimpleType::Ptr primitiveType = findPrimitiveType(anonType->wxsSuperType(), visitedPrimitiveTypes);

   665             anonType->setPrimitiveType(primitiveType);

   666 

   667             complexType->contentType()->setSimpleType(anonType);

   668 

   669             m_schema->addAnonymousType(anonType);

   670             m_componentLocationHash.insert(anonType, m_componentLocationHash.value(complexType));

   671         } else {

   672             complexType->contentType()->setSimpleType(BuiltinTypes::xsAnySimpleType);

   673         }

   674     } else if (baseType->isSimpleType()) { // 4

   675         complexType->contentType()->setSimpleType(baseType);

   676     } else { // 5

   677         complexType->contentType()->setSimpleType(BuiltinTypes::xsAnySimpleType);

   678     }

   679 }

   680 

   681 void XsdSchemaResolver::resolveComplexContentComplexTypes()

   682 {

   683     XsdComplexType::List complexTypes;

   684 

   685     // first collect the global complex types

   686     const SchemaType::List types = m_schema->types();

   687     for (int i = 0; i < types.count(); ++i) {

   688         if (types.at(i)->isComplexType() && types.at(i)->isDefinedBySchema())

   689             complexTypes.append(types.at(i));

   690     }

   691 

   692     // then collect all anonymous simple types

   693     const SchemaType::List anonymousTypes = m_schema->anonymousTypes();

   694     for (int i = 0; i < anonymousTypes.count(); ++i) {

   695         if (anonymousTypes.at(i)->isComplexType() && anonymousTypes.at(i)->isDefinedBySchema())

   696             complexTypes.append(anonymousTypes.at(i));

   697     }

   698 

   699     QSet<XsdComplexType::Ptr> visitedTypes;

   700     for (int i = 0; i < complexTypes.count(); ++i) {

   701         if (XsdComplexType::Ptr(complexTypes.at(i))->contentType()->variety() != XsdComplexType::ContentType::Simple)

   702             resolveComplexContentComplexTypes(complexTypes.at(i), visitedTypes);

   703     }

   704 }

   705 

   706 void XsdSchemaResolver::resolveComplexContentComplexTypes(const XsdComplexType::Ptr &complexType, QSet<XsdComplexType::Ptr> &visitedTypes)

   707 {

   708     if (visitedTypes.contains(complexType))

   709         return;

   710     else

   711         visitedTypes.insert(complexType);

   712 

   713     ComplexContentType item;

   714     bool foundCorrespondingItem = false;

   715     for (int i = 0; i < m_complexContentTypes.count(); ++i) {

   716         if (m_complexContentTypes.at(i).complexType == complexType) {

   717             item = m_complexContentTypes.at(i);

   718             foundCorrespondingItem = true;

   719             break;

   720         }

   721     }

   722 

   723     if (!foundCorrespondingItem)

   724         return;

   725 

   726     const SchemaType::Ptr baseType = complexType->wxsSuperType();

   727 

   728     // at this point simple types have been resolved already, so we care about

   729     // complex types here only

   730     if (baseType->isComplexType() && baseType->isDefinedBySchema())

   731         resolveComplexContentComplexTypes(XsdComplexType::Ptr(baseType), visitedTypes);

   732 

   733 

   734     // @see http://www.w3.org/TR/xmlschema11-1/#dcl.ctd.ctcc.common

   735 

   736     // 3

   737     XsdParticle::Ptr effectiveContent;

   738     if (!item.explicitContent) { // 3.1

   739         if (item.effectiveMixed == true) { // 3.1.1

   740             const XsdParticle::Ptr particle(new XsdParticle());

   741             particle->setMinimumOccurs(1);

   742             particle->setMaximumOccurs(1);

   743             particle->setMaximumOccursUnbounded(false);

   744 

   745             const XsdModelGroup::Ptr sequence(new XsdModelGroup());

   746             sequence->setCompositor(XsdModelGroup::SequenceCompositor);

   747             particle->setTerm(sequence);

   748 

   749             effectiveContent = particle;

   750         } else { // 3.1.2

   751             effectiveContent = XsdParticle::Ptr();

   752         }

   753     } else { // 3.2

   754         effectiveContent = item.explicitContent;

   755     }

   756 

   757     // 4

   758     XsdComplexType::ContentType::Ptr explicitContentType(new XsdComplexType::ContentType());

   759     if (item.complexType->derivationMethod() == XsdComplexType::DerivationRestriction) { // 4.1

   760         if (!effectiveContent) { // 4.1.1

   761             explicitContentType->setVariety(XsdComplexType::ContentType::Empty);

   762         } else { // 4.1.2

   763             if (item.effectiveMixed == true)

   764                 explicitContentType->setVariety(XsdComplexType::ContentType::Mixed);

   765             else

   766                 explicitContentType->setVariety(XsdComplexType::ContentType::ElementOnly);

   767 

   768             explicitContentType->setParticle(effectiveContent);

   769         }

   770     } else if (item.complexType->derivationMethod() == XsdComplexType::DerivationExtension) { // 4.2

   771         const SchemaType::Ptr baseType = item.complexType->wxsSuperType();

   772         if (baseType->isSimpleType() || (baseType->isComplexType() && baseType->isDefinedBySchema() && (XsdComplexType::Ptr(baseType)->contentType()->variety() == XsdComplexType::ContentType::Empty ||

   773                                                                                                         XsdComplexType::Ptr(baseType)->contentType()->variety() == XsdComplexType::ContentType::Simple))) { // 4.2.1

   774             if (!effectiveContent) {

   775                 explicitContentType->setVariety(XsdComplexType::ContentType::Empty);

   776             } else {

   777                 if (item.effectiveMixed == true)

   778                     explicitContentType->setVariety(XsdComplexType::ContentType::Mixed);

   779                 else

   780                     explicitContentType->setVariety(XsdComplexType::ContentType::ElementOnly);

   781 

   782                 explicitContentType->setParticle(effectiveContent);

   783             }

   784         } else if (baseType->isComplexType() && baseType->isDefinedBySchema() && (XsdComplexType::Ptr(baseType)->contentType()->variety() == XsdComplexType::ContentType::ElementOnly ||

   785                                                  XsdComplexType::Ptr(baseType)->contentType()->variety() == XsdComplexType::ContentType::Mixed) && !effectiveContent) { // 4.2.2

   786             const XsdComplexType::Ptr complexBaseType(baseType);

   787 

   788             explicitContentType = complexBaseType->contentType();

   789         } else { // 4.2.3

   790             explicitContentType->setVariety(item.effectiveMixed ? XsdComplexType::ContentType::Mixed : XsdComplexType::ContentType::ElementOnly);

   791 

   792             XsdParticle::Ptr baseParticle;

   793             if (baseType == BuiltinTypes::xsAnyType) {

   794                 // we need a workaround here, since the xsAnyType is no real (aka XsdComplexType) complex type...

   795 

   796                 baseParticle = XsdParticle::Ptr(new XsdParticle());

   797                 baseParticle->setMinimumOccurs(1);

   798                 baseParticle->setMaximumOccurs(1);

   799                 baseParticle->setMaximumOccursUnbounded(false);

   800 

   801                 const XsdModelGroup::Ptr group(new XsdModelGroup());

   802                 group->setCompositor(XsdModelGroup::SequenceCompositor);

   803 

   804                 const XsdParticle::Ptr particle(new XsdParticle());

   805                 particle->setMinimumOccurs(0);

   806                 particle->setMaximumOccursUnbounded(true);

   807 

   808                 const XsdWildcard::Ptr wildcard(new XsdWildcard());

   809                 wildcard->namespaceConstraint()->setVariety(XsdWildcard::NamespaceConstraint::Any);

   810                 wildcard->setProcessContents(XsdWildcard::Lax);

   811 

   812                 particle->setTerm(wildcard);

   813                 XsdParticle::List particles;

   814                 particles.append(particle);

   815                 group->setParticles(particles);

   816                 baseParticle->setTerm(group);

   817             } else {

   818                 const XsdComplexType::Ptr complexBaseType(baseType);

   819                 baseParticle = complexBaseType->contentType()->particle();

   820             }

   821             if (baseParticle && baseParticle->term()->isModelGroup() && (XsdModelGroup::Ptr(baseParticle->term())->compositor() == XsdModelGroup::AllCompositor) &&

   822                 (!item.explicitContent)) { // 4.2.3.1

   823 

   824                 explicitContentType->setParticle(baseParticle);

   825             } else if (baseParticle && baseParticle->term()->isModelGroup() && (XsdModelGroup::Ptr(baseParticle->term())->compositor() == XsdModelGroup::AllCompositor) &&

   826                        (effectiveContent->term()->isModelGroup() && (XsdModelGroup::Ptr(effectiveContent->term())->compositor() == XsdModelGroup::AllCompositor))) { // 4.2.3.2

   827                 const XsdParticle::Ptr particle(new XsdParticle());

   828                 particle->setMinimumOccurs(effectiveContent->minimumOccurs());

   829                 particle->setMaximumOccurs(1);

   830                 particle->setMaximumOccursUnbounded(false);

   831 

   832                 const XsdModelGroup::Ptr group(new XsdModelGroup());

   833                 group->setCompositor(XsdModelGroup::AllCompositor);

   834                 XsdParticle::List particles = XsdModelGroup::Ptr(baseParticle->term())->particles();

   835                 particles << XsdModelGroup::Ptr(effectiveContent->term())->particles();

   836                 group->setParticles(particles);

   837                 particle->setTerm(group);

   838 

   839                 explicitContentType->setParticle(particle);

   840             } else { // 4.2.3.3

   841                 const XsdParticle::Ptr particle(new XsdParticle());

   842                 particle->setMinimumOccurs(1);

   843                 particle->setMaximumOccurs(1);

   844                 particle->setMaximumOccursUnbounded(false);

   845 

   846                 const XsdModelGroup::Ptr group(new XsdModelGroup());

   847                 group->setCompositor(XsdModelGroup::SequenceCompositor);

   848 

   849                 if (effectiveContent && effectiveContent->term()->isModelGroup() && XsdModelGroup::Ptr(effectiveContent->term())->compositor() == XsdModelGroup::AllCompositor) {

   850                     m_context->error(QtXmlPatterns::tr("Content model of complex type %1 contains %2 element so it cannot be derived by extension from a non-empty type.")

   851                                                       .arg(formatType(m_namePool, complexType)).arg(formatKeyword("all")), XsdSchemaContext::XSDError, sourceLocation(complexType));

   852                     return;

   853                 }

   854 

   855                 if (baseParticle && baseParticle->term()->isModelGroup() && XsdModelGroup::Ptr(baseParticle->term())->compositor() == XsdModelGroup::AllCompositor) {

   856                     m_context->error(QtXmlPatterns::tr("Complex type %1 cannot be derived by extension from %2 as the latter contains %3 element in its content model.")

   857                                                       .arg(formatType(m_namePool, complexType))

   858                                                       .arg(formatType(m_namePool, baseType))

   859                                                       .arg(formatKeyword("all")), XsdSchemaContext::XSDError, sourceLocation(complexType));

   860                     return;

   861                 }

   862 

   863                 XsdParticle::List particles;

   864                 if (baseParticle)

   865                     particles << baseParticle;

   866                 if (effectiveContent)

   867                     particles << effectiveContent;

   868                 group->setParticles(particles);

   869                 particle->setTerm(group);

   870 

   871                 explicitContentType->setParticle(particle);

   872             }

   873 

   874             if (baseType->isDefinedBySchema()) { // xs:anyType has no open content

   875                 const XsdComplexType::Ptr complexBaseType(baseType);

   876                 explicitContentType->setOpenContent(complexBaseType->contentType()->openContent());

   877             }

   878         }

   879     }

   880 

   881     // 5

   882     XsdComplexType::OpenContent::Ptr wildcardElement;

   883     if (item.complexType->contentType()->openContent()) { // 5.1

   884         wildcardElement = item.complexType->contentType()->openContent();

   885     } else {

   886         if (m_defaultOpenContent) { // 5.2

   887             if ((explicitContentType->variety() != XsdComplexType::ContentType::Empty) || // 5.2.1

   888                 (explicitContentType->variety() == XsdComplexType::ContentType::Empty && m_defaultOpenContentAppliesToEmpty)) { // 5.2.2

   889                 wildcardElement = m_defaultOpenContent;

   890             }

   891         }

   892     }

   893 

   894     // 6

   895     if (!wildcardElement) { // 6.1

   896         item.complexType->setContentType(explicitContentType);

   897     } else {

   898         if (wildcardElement->mode() == XsdComplexType::OpenContent::None) { // 6.2

   899             const XsdComplexType::ContentType::Ptr contentType(new XsdComplexType::ContentType());

   900             contentType->setVariety(explicitContentType->variety());

   901             contentType->setParticle(explicitContentType->particle());

   902 

   903             item.complexType->setContentType(contentType);

   904         } else { // 6.3

   905             const XsdComplexType::ContentType::Ptr contentType(new XsdComplexType::ContentType());

   906 

   907             if (explicitContentType->variety() == XsdComplexType::ContentType::Empty)

   908                 contentType->setVariety(XsdComplexType::ContentType::ElementOnly);

   909             else

   910                 contentType->setVariety(explicitContentType->variety());

   911 

   912             if (explicitContentType->variety() == XsdComplexType::ContentType::Empty) {

   913                 const XsdParticle::Ptr particle(new XsdParticle());

   914                 particle->setMinimumOccurs(1);

   915                 particle->setMaximumOccurs(1);

   916                 const XsdModelGroup::Ptr sequence(new XsdModelGroup());

   917                 sequence->setCompositor(XsdModelGroup::SequenceCompositor);

   918                 particle->setTerm(sequence);

   919                 contentType->setParticle(particle);

   920             } else {

   921                 contentType->setParticle(explicitContentType->particle());

   922             }

   923 

   924             const XsdComplexType::OpenContent::Ptr openContent(new XsdComplexType::OpenContent());

   925             if (wildcardElement)

   926                 openContent->setMode(wildcardElement->mode());

   927             else

   928                 openContent->setMode(XsdComplexType::OpenContent::Interleave);

   929 

   930             if (wildcardElement)

   931                 openContent->setWildcard(wildcardElement->wildcard());

   932 

   933             item.complexType->setContentType(contentType);

   934         }

   935     }

   936 }

   937 

   938 void XsdSchemaResolver::resolveAttributeTypes()

   939 {

   940     for (int i = 0; i < m_attributeTypes.count(); ++i) {

   941         const AttributeType item = m_attributeTypes.at(i);

   942 

   943         SchemaType::Ptr type = m_schema->type(item.typeName);

   944         if (!type) {

   945             // maybe it's a basic type...

   946             type = m_context->schemaTypeFactory()->createSchemaType(item.typeName);

   947             if (!type) {

   948                 m_context->error(QtXmlPatterns::tr("Type %1 of %2 element cannot be resolved.")

   949                                                   .arg(formatType(m_namePool, item.typeName))

   950                                                   .arg(formatElement("attribute")),

   951                                  XsdSchemaContext::XSDError, item.location);

   952                 return;

   953             }

   954         }

   955 

   956         if (!type->isSimpleType() && type->category() != SchemaType::None) {

   957             m_context->error(QtXmlPatterns::tr("Type of %1 element must be a simple type, %2 is not.")

   958                                               .arg(formatElement("attribute"))

   959                                               .arg(formatType(m_namePool, item.typeName)),

   960                              XsdSchemaContext::XSDError, item.location);

   961             return;

   962         }

   963 

   964         item.attribute->setType(type);

   965     }

   966 }

   967 

   968 void XsdSchemaResolver::resolveAlternativeTypes()

   969 {

   970     for (int i = 0; i < m_alternativeTypes.count(); ++i) {

   971         const AlternativeType item = m_alternativeTypes.at(i);

   972 

   973         SchemaType::Ptr type = m_schema->type(item.typeName);

   974         if (!type) {

   975             // maybe it's a basic type...

   976             type = m_context->schemaTypeFactory()->createSchemaType(item.typeName);

   977             if (!type) {

   978                 m_context->error(QtXmlPatterns::tr("Type %1 of %2 element cannot be resolved.")

   979                                                   .arg(formatType(m_namePool, item.typeName))

   980                                                   .arg(formatElement("alternative")),

   981                                  XsdSchemaContext::XSDError, item.location);

   982                 return;

   983             }

   984         }

   985 

   986         item.alternative->setType(type);

   987     }

   988 

   989     for (int i = 0; i < m_alternativeTypeElements.count(); ++i) {

   990         const AlternativeTypeElement item = m_alternativeTypeElements.at(i);

   991         item.alternative->setType(item.element->type());

   992     }

   993 }

   994 

   995 bool hasCircularSubstitutionGroup(const XsdElement::Ptr &current, const XsdElement::Ptr &head, const NamePool::Ptr &namePool)

   996 {

   997     if (current == head)

   998         return true;

   999     else {

  1000         const XsdElement::List elements = current->substitutionGroupAffiliations();

  1001         for (int i = 0; i < elements.count(); ++i) {

  1002             if (hasCircularSubstitutionGroup(elements.at(i), head, namePool))

  1003                 return true;

  1004         }

  1005     }

  1006 

  1007     return false;

  1008 }

  1009 

  1010 void XsdSchemaResolver::resolveSubstitutionGroupAffiliations()

  1011 {

  1012     for (int i = 0; i < m_substitutionGroupAffiliations.count(); ++i) {

  1013         const SubstitutionGroupAffiliation item = m_substitutionGroupAffiliations.at(i);

  1014 

  1015         XsdElement::List affiliations;

  1016         for (int j = 0; j < item.elementNames.count(); ++j) {

  1017             const XsdElement::Ptr element = m_schema->element(item.elementNames.at(j));

  1018             if (!element) {

  1019                 m_context->error(QtXmlPatterns::tr("Substitution group %1 of %2 element cannot be resolved.")

  1020                                                   .arg(formatKeyword(m_namePool, item.elementNames.at(j)))

  1021                                                   .arg(formatElement("element")),

  1022                                  XsdSchemaContext::XSDError, item.location);

  1023                 return;

  1024             }

  1025 

  1026             // @see http://www.w3.org/TR/xmlschema11-1/#e-props-correct 5)

  1027             if (hasCircularSubstitutionGroup(element, item.element, m_namePool)) {

  1028                 m_context->error(QtXmlPatterns::tr("Substitution group %1 has circular definition.").arg(formatKeyword(m_namePool, item.elementNames.at(j))), XsdSchemaContext::XSDError, item.location);

  1029                 return;

  1030             }

  1031 

  1032             affiliations.append(element);

  1033         }

  1034 

  1035         item.element->setSubstitutionGroupAffiliations(affiliations);

  1036     }

  1037 

  1038     for (int i = 0; i < m_substitutionGroupTypes.count(); ++i) {

  1039         const XsdElement::Ptr element = m_substitutionGroupTypes.at(i);

  1040         element->setType(element->substitutionGroupAffiliations().first()->type());

  1041     }

  1042 }

  1043 

  1044 bool isSubstGroupHeadOf(const XsdElement::Ptr &head, const XsdElement::Ptr &element, const NamePool::Ptr &namePool)

  1045 {

  1046     if (head->name(namePool) == element->name(namePool))

  1047         return true;

  1048 

  1049     const XsdElement::List affiliations = element->substitutionGroupAffiliations();

  1050     for (int i = 0; i < affiliations.count(); ++i) {

  1051         if (isSubstGroupHeadOf(head, affiliations.at(i), namePool))

  1052             return true;

  1053     }

  1054 

  1055     return false;

  1056 }

  1057 

  1058 void XsdSchemaResolver::resolveSubstitutionGroups()

  1059 {

  1060     const XsdElement::List elements = m_schema->elements();

  1061     for (int i = 0; i < elements.count(); ++i) {

  1062         const XsdElement::Ptr element = elements.at(i);

  1063 

  1064         // the element is always itself in the substitution group

  1065         element->addSubstitutionGroup(element);

  1066 

  1067         for (int j = 0; j < elements.count(); ++j) {

  1068             if (i == j)

  1069                 continue;

  1070 

  1071             if (isSubstGroupHeadOf(element, elements.at(j), m_namePool))

  1072                 element->addSubstitutionGroup(elements.at(j));

  1073         }

  1074     }

  1075 }

  1076 

  1077 void XsdSchemaResolver::resolveTermReferences()

  1078 {

  1079     // first the global complex types

  1080     const SchemaType::List types = m_schema->types();

  1081     for (int i = 0; i < types.count(); ++i) {

  1082         if (!(types.at(i)->isComplexType()) || !types.at(i)->isDefinedBySchema())

  1083             continue;

  1084 

  1085         const XsdComplexType::Ptr complexType = types.at(i);

  1086         if (complexType->contentType()->variety() != XsdComplexType::ContentType::ElementOnly && complexType->contentType()->variety() != XsdComplexType::ContentType::Mixed)

  1087             continue;

  1088 

  1089         resolveTermReference(complexType->contentType()->particle(), QSet<QXmlName>());

  1090     }

  1091 

  1092     // then all anonymous complex types

  1093     const SchemaType::List anonymousTypes = m_schema->anonymousTypes();

  1094     for (int i = 0; i < anonymousTypes.count(); ++i) {

  1095         if (!(anonymousTypes.at(i)->isComplexType()) || !anonymousTypes.at(i)->isDefinedBySchema())

  1096             continue;

  1097 

  1098         const XsdComplexType::Ptr complexType = anonymousTypes.at(i);

  1099         if (complexType->contentType()->variety() != XsdComplexType::ContentType::ElementOnly && complexType->contentType()->variety() != XsdComplexType::ContentType::Mixed)

  1100             continue;

  1101 

  1102         resolveTermReference(complexType->contentType()->particle(), QSet<QXmlName>());

  1103     }

  1104 

  1105     const XsdModelGroup::List groups = m_schema->elementGroups();

  1106     for (int i = 0; i < groups.count(); ++i) {

  1107         const XsdParticle::Ptr particle(new XsdParticle());

  1108         particle->setTerm(groups.at(i));

  1109         resolveTermReference(particle, QSet<QXmlName>());

  1110     }

  1111 }

  1112 

  1113 void XsdSchemaResolver::resolveTermReference(const XsdParticle::Ptr &particle, QSet<QXmlName> visitedGroups)

  1114 {

  1115     if (!particle)

  1116         return;

  1117 

  1118     const XsdTerm::Ptr term = particle->term();

  1119 

  1120     // if it is a model group, we iterate over it recursive...

  1121     if (term->isModelGroup()) {

  1122         const XsdModelGroup::Ptr modelGroup = term;

  1123         const XsdParticle::List particles = modelGroup->particles();

  1124 

  1125         for (int i = 0; i < particles.count(); ++i) {

  1126             resolveTermReference(particles.at(i), visitedGroups);

  1127         }

  1128 

  1129         // check for unique names of elements inside all compositor

  1130         if (modelGroup->compositor() != XsdModelGroup::ChoiceCompositor) {

  1131             for (int i = 0; i < particles.count(); ++i) {

  1132                 const XsdParticle::Ptr particle = particles.at(i);

  1133                 const XsdTerm::Ptr term = particle->term();

  1134 

  1135                 if (!(term->isElement()))