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 "qxsdschemachecker_p.h"

    43 

    44 #include "qderivedinteger_p.h"

    45 #include "qderivedstring_p.h"

    46 #include "qpatternplatform_p.h"

    47 #include "qqnamevalue_p.h"

    48 #include "qsourcelocationreflection_p.h"

    49 #include "qvaluefactory_p.h"

    50 #include "qxsdattributereference_p.h"

    51 #include "qxsdparticlechecker_p.h"

    52 #include "qxsdreference_p.h"

    53 #include "qxsdschemacontext_p.h"

    54 #include "qxsdschemahelper_p.h"

    55 #include "qxsdschemaparsercontext_p.h"

    56 #include "qxsdschematypesfactory_p.h"

    57 #include "qxsdtypechecker_p.h"

    58 

    59 #include "qxsdschemachecker_helper.cpp"

    60 

    61 QT_BEGIN_NAMESPACE

    62 

    63 using namespace QPatternist;

    64 

    65 XsdSchemaChecker::XsdSchemaChecker(const QExplicitlySharedDataPointer<XsdSchemaContext> &context, const XsdSchemaParserContext *parserContext)

    66     : m_context(context)

    67     , m_namePool(parserContext->namePool())

    68     , m_schema(parserContext->schema())

    69 {

    70     setupAllowedAtomicFacets();

    71 }

    72 

    73 XsdSchemaChecker::~XsdSchemaChecker()

    74 {

    75 }

    76 

    77 /*

    78  * This method is called after the resolver has set the base type for every

    79  * type and information about deriavtion and 'is simple type vs. is complex type'

    80  * are available.

    81  */

    82 void XsdSchemaChecker::basicCheck()

    83 {

    84     // first check that there is no circular inheritance, only the

    85     // wxsSuperType is used here

    86     checkBasicCircularInheritances();

    87 

    88     // check the basic constraints like simple type can not inherit from complex type etc.

    89     checkBasicSimpleTypeConstraints();

    90     checkBasicComplexTypeConstraints();

    91 }

    92 

    93 void XsdSchemaChecker::check()

    94 {

    95     checkCircularInheritances();

    96     checkInheritanceRestrictions();

    97     checkSimpleDerivationRestrictions();

    98     checkSimpleTypeConstraints();

    99     checkComplexTypeConstraints();

   100     checkDuplicatedAttributeUses();

   101 

   102     checkElementConstraints();

   103     checkAttributeConstraints();

   104     checkAttributeUseConstraints();

   105 //    checkElementDuplicates();

   106 }

   107 

   108 void XsdSchemaChecker::addComponentLocationHash(const ComponentLocationHash &hash)

   109 {

   110     m_componentLocationHash.unite(hash);

   111 }

   112 

   113 /**

   114  * Checks whether the @p otherType is the same as @p myType or if one of its

   115  * ancestors is the same as @p myType.

   116  */

   117 static bool matchesType(const SchemaType::Ptr &myType, const SchemaType::Ptr &otherType, QSet<SchemaType::Ptr> visitedTypes)

   118 {

   119     bool retval = false;

   120 

   121     if (otherType) {

   122         if (visitedTypes.contains(otherType)) {

   123             return true;

   124         } else {

   125             visitedTypes.insert(otherType);

   126         }

   127         // simple types can have different varieties, so we have to check each of them

   128         if (otherType->isSimpleType()) {

   129             const XsdSimpleType::Ptr simpleType = otherType;

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

   131                 // for atomic type we use the same test as in SchemaType::wxsTypeMatches

   132                 retval = (myType == simpleType ? true : matchesType(myType, simpleType->wxsSuperType(), visitedTypes));

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

   134                 // for list type we test against the itemType property

   135                 retval = (myType == simpleType->itemType() ? true : matchesType(myType, simpleType->itemType()->wxsSuperType(), visitedTypes));

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

   137                 // for union type we test against each member type

   138                 const XsdSimpleType::List members = simpleType->memberTypes();

   139                 for (int i = 0; i < members.count(); ++i) {

   140                     if (myType == members.at(i) ? true : matchesType(myType, members.at(i)->wxsSuperType(), visitedTypes)) {

   141                         retval = true;

   142                         break;

   143                     }

   144                 }

   145             } else {

   146                 // reached xsAnySimple type whichs category is None

   147                 retval = false;

   148             }

   149         } else {

   150             // if no simple type we handle it like in SchemaType::wxsTypeMatches

   151             retval = (myType == otherType ? true : matchesType(myType, otherType->wxsSuperType(), visitedTypes));

   152         }

   153     } else // if otherType is null it doesn't match

   154         retval = false;

   155 

   156     return retval;

   157 }

   158 

   159 /**

   160  * Checks whether there is a circular inheritance for the union inheritance.

   161  */

   162 static bool hasCircularUnionInheritance(const XsdSimpleType::Ptr &type, const SchemaType::Ptr &otherType, NamePool::Ptr &namePool)

   163 {

   164     if (type == otherType) {

   165         return true;

   166     }

   167 

   168     if (!otherType->isSimpleType() || !otherType->isDefinedBySchema()) {

   169         return false;

   170     }

   171 

   172     const XsdSimpleType::Ptr simpleOtherType = otherType;

   173 

   174     if (simpleOtherType->category() == XsdSimpleType::SimpleTypeUnion) {

   175         const XsdSimpleType::List memberTypes = simpleOtherType->memberTypes();

   176         for (int i = 0; i < memberTypes.count(); ++i) {

   177             if (otherType->wxsSuperType() == type) {

   178                 return true;

   179             }

   180             if (hasCircularUnionInheritance(type, memberTypes.at(i), namePool)) {

   181                 return true;

   182             }

   183         }

   184     }

   185 

   186     return false;

   187 }

   188 

   189 static inline bool wxsTypeMatches(const SchemaType::Ptr &type, const SchemaType::Ptr &otherType, QSet<SchemaType::Ptr> &visitedTypes, SchemaType::Ptr &conflictingType)

   190 {

   191     if (!otherType)

   192         return false;

   193 

   194     if (visitedTypes.contains(otherType)) { // inheritance loop detected

   195         conflictingType = otherType;

   196         return true;

   197     } else {

   198         visitedTypes.insert(otherType);

   199     }

   200 

   201     if (type == otherType)

   202         return true;

   203 

   204     return wxsTypeMatches(type, otherType->wxsSuperType(), visitedTypes, conflictingType);

   205 }

   206 

   207 void XsdSchemaChecker::checkBasicCircularInheritances()

   208 {

   209     // check all global types...

   210     SchemaType::List types = m_schema->types();

   211 

   212     // .. and anonymous types

   213     types << m_schema->anonymousTypes();

   214 

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

   216         const SchemaType::Ptr type = types.at(i);

   217         const QSourceLocation location = sourceLocationForType(type);

   218 

   219         // @see http://www.w3.org/TR/xmlschema11-1/#ct-props-correct 3)

   220 

   221         // check normal base type inheritance

   222         QSet<SchemaType::Ptr> visitedTypes;

   223         SchemaType::Ptr conflictingType;

   224 

   225         if (wxsTypeMatches(type, type->wxsSuperType(), visitedTypes, conflictingType)) {

   226             if (conflictingType)

   227                 m_context->error(QtXmlPatterns::tr("%1 has inheritance loop in its base type %2.")

   228                                                   .arg(formatType(m_namePool, type))

   229                                                   .arg(formatType(m_namePool, conflictingType)),

   230                                  XsdSchemaContext::XSDError, location);

   231             else

   232                 m_context->error(QtXmlPatterns::tr("Circular inheritance of base type %1.").arg(formatType(m_namePool, type)), XsdSchemaContext::XSDError, location);

   233 

   234             return;

   235         }

   236     }

   237 }

   238 

   239 void XsdSchemaChecker::checkCircularInheritances()

   240 {

   241     // check all global types...

   242     SchemaType::List types = m_schema->types();

   243 

   244     // .. and anonymous types

   245     types << m_schema->anonymousTypes();

   246 

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

   248         const SchemaType::Ptr type = types.at(i);

   249         const QSourceLocation location = sourceLocationForType(type);

   250 

   251         // @see http://www.w3.org/TR/xmlschema11-1/#ct-props-correct 3)

   252 

   253         // check normal base type inheritance

   254         QSet<SchemaType::Ptr> visitedTypes;

   255         if (matchesType(type, type->wxsSuperType(), visitedTypes)) {

   256             m_context->error(QtXmlPatterns::tr("Circular inheritance of base type %1.").arg(formatType(m_namePool, type)), XsdSchemaContext::XSDError, location);

   257             return;

   258         }

   259 

   260         // check union member inheritance

   261         if (type->isSimpleType() && type->isDefinedBySchema()) {

   262             const XsdSimpleType::Ptr simpleType = type;

   263             if (simpleType->category() == XsdSimpleType::SimpleTypeUnion) {

   264                 const XsdSimpleType::List memberTypes = simpleType->memberTypes();

   265                 for (int j = 0; j < memberTypes.count(); ++j) {

   266                     if (hasCircularUnionInheritance(simpleType, memberTypes.at(j), m_namePool)) {

   267                         m_context->error(QtXmlPatterns::tr("Circular inheritance of union %1.").arg(formatType(m_namePool, type)), XsdSchemaContext::XSDError, location);

   268                         return;

   269                     }

   270                 }

   271             }

   272         }

   273     }

   274 }

   275 

   276 void XsdSchemaChecker::checkInheritanceRestrictions()

   277 {

   278     // check all global types...

   279     SchemaType::List types = m_schema->types();

   280 

   281     // .. and anonymous types

   282     types << m_schema->anonymousTypes();

   283 

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

   285         const SchemaType::Ptr type = types.at(i);

   286         const QSourceLocation location = sourceLocationForType(type);

   287 

   288         // check inheritance restrictions given by final property of base class

   289         const SchemaType::Ptr baseType = type->wxsSuperType();

   290         if (baseType->isDefinedBySchema()) {

   291             if ((type->derivationMethod() == SchemaType::DerivationRestriction) && (baseType->derivationConstraints() & SchemaType::RestrictionConstraint)) {

   292                 m_context->error(QtXmlPatterns::tr("%1 is not allowed to derive from %2 by restriction as the latter defines it as final.")

   293                                                   .arg(formatType(m_namePool, type))

   294                                                   .arg(formatType(m_namePool, baseType)), XsdSchemaContext::XSDError, location);

   295                 return;

   296             } else if ((type->derivationMethod() == SchemaType::DerivationExtension) && (baseType->derivationConstraints() & SchemaType::ExtensionConstraint)) {

   297                 m_context->error(QtXmlPatterns::tr("%1 is not allowed to derive from %2 by extension as the latter defines it as final.")

   298                                                   .arg(formatType(m_namePool, type))

   299                                                   .arg(formatType(m_namePool, baseType)), XsdSchemaContext::XSDError, location);

   300                 return;

   301             }

   302         }

   303     }

   304 }

   305 

   306 void XsdSchemaChecker::checkBasicSimpleTypeConstraints()

   307 {

   308     // check all global types...

   309     SchemaType::List types = m_schema->types();

   310 

   311     // .. and anonymous types

   312     types << m_schema->anonymousTypes();

   313 

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

   315         const SchemaType::Ptr type = types.at(i);

   316 

   317         if (!type->isSimpleType())

   318             continue;

   319 

   320         const XsdSimpleType::Ptr simpleType = type;

   321 

   322         const QSourceLocation location = sourceLocation(simpleType);

   323 

   324         // check inheritance restrictions of simple type defined by schema constraints

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

   326 

   327         if (baseType->isComplexType() && (simpleType->name(m_namePool) != BuiltinTypes::xsAnySimpleType->name(m_namePool))) {

   328             m_context->error(QtXmlPatterns::tr("Base type of simple type %1 cannot be complex type %2.")

   329                                               .arg(formatType(m_namePool, simpleType))

   330                                               .arg(formatType(m_namePool, baseType)),

   331                              XsdSchemaContext::XSDError, location);

   332             return;

   333         }

   334 

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

   336             if (type->name(m_namePool) != BuiltinTypes::xsAnySimpleType->name(m_namePool)) {

   337                 m_context->error(QtXmlPatterns::tr("Simple type %1 cannot have direct base type %2.")

   338                                                   .arg(formatType(m_namePool, simpleType))

   339                                                   .arg(formatType(m_namePool, BuiltinTypes::xsAnyType)),

   340                                  XsdSchemaContext::XSDError, location);

   341                 return;

   342             }

   343         }

   344     }

   345 }

   346 

   347 void XsdSchemaChecker::checkSimpleTypeConstraints()

   348 {

   349     // check all global types...

   350     SchemaType::List types = m_schema->types();

   351 

   352     // .. and anonymous types

   353     types << m_schema->anonymousTypes();

   354 

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

   356         const SchemaType::Ptr type = types.at(i);

   357 

   358         if (!type->isSimpleType())

   359             continue;

   360 

   361         const XsdSimpleType::Ptr simpleType = type;

   362 

   363         const QSourceLocation location = sourceLocation(simpleType);

   364 

   365         if (simpleType->category() == XsdSimpleType::None) {

   366             // additional checks

   367             // check that no user defined type has xs:AnySimpleType as base type (except xs:AnyAtomicType)

   368             if (simpleType->wxsSuperType()->name(m_namePool) == BuiltinTypes::xsAnySimpleType->name(m_namePool)) {

   369                 if (simpleType->name(m_namePool) != BuiltinTypes::xsAnyAtomicType->name(m_namePool)) {

   370                     m_context->error(QtXmlPatterns::tr("Simple type %1 is not allowed to have base type %2.")

   371                                                       .arg(formatType(m_namePool, simpleType))

   372                                                       .arg(formatType(m_namePool, simpleType->wxsSuperType())),

   373                                      XsdSchemaContext::XSDError, location);

   374                     return;

   375                 }

   376             }

   377             // check that no user defined type has xs:AnyAtomicType as base type

   378             if (simpleType->wxsSuperType()->name(m_namePool) == BuiltinTypes::xsAnyAtomicType->name(m_namePool)) {

   379                 m_context->error(QtXmlPatterns::tr("Simple type %1 is not allowed to have base type %2.")

   380                                                   .arg(formatType(m_namePool, simpleType))

   381                                                   .arg(formatType(m_namePool, simpleType->wxsSuperType())),

   382                                  XsdSchemaContext::XSDError, location);

   383                 return;

   384             }

   385         }

   386 

   387         // @see http://www.w3.org/TR/xmlschema11-1/#d0e37310

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

   389             // 1.1

   390             if ((simpleType->wxsSuperType()->category() != XsdSimpleType::SimpleTypeAtomic) && (simpleType->name(m_namePool) != BuiltinTypes::xsAnyAtomicType->name(m_namePool))) {

   391                 m_context->error(QtXmlPatterns::tr("Simple type %1 can only have simple atomic type as base type.")

   392                                                   .arg(formatType(m_namePool, simpleType)),

   393                                  XsdSchemaContext::XSDError, location);

   394             }

   395             // 1.2

   396             if (simpleType->wxsSuperType()->derivationConstraints() & SchemaType::RestrictionConstraint) {

   397                 m_context->error(QtXmlPatterns::tr("Simple type %1 cannot derive from %2 as the latter defines restriction as final.")

   398                                                   .arg(formatType(m_namePool, simpleType->wxsSuperType()))

   399                                                   .arg(formatType(m_namePool, simpleType)),

   400                                  XsdSchemaContext::XSDError, location);

   401             }

   402 

   403             // 1.3

   404             // checked by checkConstrainingFacets  already

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

   406             const AnySimpleType::Ptr itemType = simpleType->itemType();

   407 

   408             // 2.1 or @see http://www.w3.org/TR/xmlschema-2/#cos-list-of-atomic

   409             if (itemType->category() != SchemaType::SimpleTypeAtomic && itemType->category() != SchemaType::SimpleTypeUnion) {

   410                 m_context->error(QtXmlPatterns::tr("Variety of item type of %1 must be either atomic or union.").arg(formatType(m_namePool, simpleType)), XsdSchemaContext::XSDError, location);

   411                 return;

   412             }

   413 

   414             // 2.1 second part

   415             if (itemType->category() == SchemaType::SimpleTypeUnion && itemType->isDefinedBySchema()) {

   416                 const XsdSimpleType::Ptr simpleItemType = itemType;

   417                 const AnySimpleType::List memberTypes = simpleItemType->memberTypes();

   418                 for (int j = 0; j < memberTypes.count(); ++j) {

   419                     if (memberTypes.at(j)->category() != SchemaType::SimpleTypeAtomic) {

   420                         m_context->error(QtXmlPatterns::tr("Variety of member types of %1 must be atomic.").arg(formatType(m_namePool, simpleItemType)), XsdSchemaContext::XSDError, location);

   421                         return;

   422                     }

   423                 }

   424             }

   425 

   426             // 2.2.1

   427             if (simpleType->wxsSuperType()->name(m_namePool) == BuiltinTypes::xsAnySimpleType->name(m_namePool)) {

   428                 if (itemType->isSimpleType() && itemType->isDefinedBySchema()) {

   429                     const XsdSimpleType::Ptr simpleItemType = itemType;

   430 

   431                     // 2.2.1.1

   432                     if (simpleItemType->derivationConstraints() & XsdSimpleType::ListConstraint) {

   433                         m_context->error(QtXmlPatterns::tr("%1 is not allowed to derive from %2 by list as the latter defines it as final.")

   434                                                           .arg(formatType(m_namePool, simpleType))

   435                                                           .arg(formatType(m_namePool, simpleItemType)), XsdSchemaContext::XSDError, location);

   436                         return;

   437                     }

   438 

   439                     // 2.2.1.2

   440                     const XsdFacet::Hash facets = simpleType->facets();

   441                     XsdFacet::HashIterator it(facets);

   442 

   443                     bool invalidFacetFound = false;

   444                     while (it.hasNext()) {

   445                         it.next();

   446                         if (it.key() != XsdFacet::WhiteSpace) {

   447                             invalidFacetFound = true;

   448                             break;

   449                         }

   450                     }

   451 

   452                     if (invalidFacetFound) {

   453                         m_context->error(QtXmlPatterns::tr("Simple type %1 is only allowed to have %2 facet.")

   454                                                           .arg(formatType(m_namePool, simpleType))

   455                                                           .arg(formatKeyword("whiteSpace")),

   456                                          XsdSchemaContext::XSDError, location);

   457                         return;

   458                     }

   459                 }

   460             } else { // 2.2.2

   461                 // 2.2.2.1

   462                 if (simpleType->wxsSuperType()->category() != XsdSimpleType::SimpleTypeList) {

   463                     m_context->error(QtXmlPatterns::tr("Base type of simple type %1 must have variety of type list.").arg(formatType(m_namePool, simpleType)), XsdSchemaContext::XSDError, location);

   464                     return;

   465                 }

   466 

   467                 // 2.2.2.2

   468                 if (simpleType->wxsSuperType()->derivationConstraints() & SchemaType::RestrictionConstraint) {

   469                     m_context->error(QtXmlPatterns::tr("Base type of simple type %1 has defined derivation by restriction as final.").arg(formatType(m_namePool, simpleType)), XsdSchemaContext::XSDError, location);

   470                     return;

   471                 }

   472 

   473                 // 2.2.2.3

   474                 if (!XsdSchemaHelper::isSimpleDerivationOk(itemType, XsdSimpleType::Ptr(simpleType->wxsSuperType())->itemType(), SchemaType::DerivationConstraints())) {

   475                     m_context->error(QtXmlPatterns::tr("Item type of base type does not match item type of %1.").arg(formatType(m_namePool, simpleType)), XsdSchemaContext::XSDError, location);

   476                     return;

   477                 }

   478 

   479                 // 2.2.2.4

   480                 const XsdFacet::Hash facets = simpleType->facets();

   481                 XsdFacet::HashIterator it(facets);

   482 

   483                 bool invalidFacetFound = false;

   484                 XsdFacet::Type invalidFacetType = XsdFacet::None;

   485                 while (it.hasNext()) {

   486                     it.next();

   487                     const XsdFacet::Type facetType = it.key();

   488                     if (facetType != XsdFacet::Length &&

   489                         facetType != XsdFacet::MinimumLength &&

   490                         facetType != XsdFacet::MaximumLength &&

   491                         facetType != XsdFacet::WhiteSpace &&

   492                         facetType != XsdFacet::Pattern &&

   493                         facetType != XsdFacet::Enumeration) {

   494                         invalidFacetType = facetType;

   495                         invalidFacetFound = true;

   496                         break;

   497                     }

   498                 }

   499 

   500                 if (invalidFacetFound) {

   501                     m_context->error(QtXmlPatterns::tr("Simple type %1 contains not allowed facet type %2.")

   502                                                       .arg(formatType(m_namePool, simpleType))

   503                                                       .arg(formatKeyword(XsdFacet::typeName(invalidFacetType))),

   504                                      XsdSchemaContext::XSDError, location);

   505                     return;

   506                 }

   507 

   508                 // 2.2.2.5

   509                 // TODO: check value constraints

   510             }

   511 

   512 

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

   514             const AnySimpleType::List memberTypes = simpleType->memberTypes();

   515 

   516             if (simpleType->wxsSuperType()->name(m_namePool) == BuiltinTypes::xsAnySimpleType->name(m_namePool)) { // 3.1.1

   517                 // 3.3.1.1

   518                 for (int i = 0; i < memberTypes.count(); ++i) {

   519                     const AnySimpleType::Ptr memberType = memberTypes.at(i);

   520 

   521                     if (memberType->derivationConstraints() & XsdSimpleType::UnionConstraint) {

   522                         m_context->error(QtXmlPatterns::tr("%1 is not allowed to derive from %2 by union as the latter defines it as final.")

   523                                                           .arg(formatType(m_namePool, simpleType))

   524                                                           .arg(formatType(m_namePool, memberType)), XsdSchemaContext::XSDError, location);

   525                         return;

   526                     }

   527                 }

   528 

   529                 // 3.3.1.2

   530                 if (!simpleType->facets().isEmpty()) {

   531                     m_context->error(QtXmlPatterns::tr("%1 is not allowed to have any facets.")

   532                                                       .arg(formatType(m_namePool, simpleType)),

   533                                      XsdSchemaContext::XSDError, location);

   534                     return;

   535                 }

   536             } else {

   537                 // 3.1.2.1

   538                 if (simpleType->wxsSuperType()->category() != SchemaType::SimpleTypeUnion) {

   539                     m_context->error(QtXmlPatterns::tr("Base type %1 of simple type %2 must have variety of union.")

   540                                                       .arg(formatType(m_namePool, simpleType->wxsSuperType()))

   541                                                       .arg(formatType(m_namePool, simpleType)),

   542                                      XsdSchemaContext::XSDError, location);

   543                     return;

   544                 }

   545 

   546                 // 3.1.2.2

   547                 if (simpleType->wxsSuperType()->derivationConstraints() & SchemaType::DerivationRestriction) {

   548                     m_context->error(QtXmlPatterns::tr("Base type %1 of simple type %2 is not allowed to have restriction in %3 attribute.")

   549                                                       .arg(formatType(m_namePool, simpleType->wxsSuperType()))

   550                                                       .arg(formatType(m_namePool, simpleType))

   551                                                       .arg(formatAttribute("final")),

   552                                      XsdSchemaContext::XSDError, location);

   553                     return;

   554                 }

   555 

   556                 //3.1.2.3

   557                 if (simpleType->wxsSuperType()->isDefinedBySchema()) {

   558                     const XsdSimpleType::Ptr simpleBaseType(simpleType->wxsSuperType());

   559 

   560                     AnySimpleType::List baseMemberTypes = simpleBaseType->memberTypes();

   561                     for (int i = 0; i < memberTypes.count(); ++i) {

   562                         const AnySimpleType::Ptr memberType = memberTypes.at(i);

   563                         const AnySimpleType::Ptr baseMemberType = baseMemberTypes.at(i);

   564 

   565                         if (!XsdSchemaHelper::isSimpleDerivationOk(memberType, baseMemberType, SchemaType::DerivationConstraints())) {

   566                             m_context->error(QtXmlPatterns::tr("Member type %1 cannot be derived from member type %2 of %3's base type %4.")

   567                                                               .arg(formatType(m_namePool, memberType))

   568                                                               .arg(formatType(m_namePool, baseMemberType))

   569                                                               .arg(formatType(m_namePool, simpleType))

   570                                                               .arg(formatType(m_namePool, simpleBaseType)),

   571                                              XsdSchemaContext::XSDError, location);

   572                         }

   573                     }

   574                 }

   575 

   576                 // 3.1.2.4

   577                 const XsdFacet::Hash facets = simpleType->facets();

   578                 XsdFacet::HashIterator it(facets);

   579 

   580                 bool invalidFacetFound = false;

   581                 XsdFacet::Type invalidFacetType = XsdFacet::None;

   582                 while (it.hasNext()) {

   583                     it.next();

   584                     const XsdFacet::Type facetType = it.key();

   585                     if (facetType != XsdFacet::Pattern &&

   586                         facetType != XsdFacet::Enumeration) {

   587                         invalidFacetType = facetType;

   588                         invalidFacetFound = true;

   589                         break;

   590                     }

   591                 }

   592 

   593                 if (invalidFacetFound) {

   594                     m_context->error(QtXmlPatterns::tr("Simple type %1 contains not allowed facet type %2.")

   595                                                       .arg(formatType(m_namePool, simpleType))

   596                                                       .arg(formatKeyword(XsdFacet::typeName(invalidFacetType))),

   597                                      XsdSchemaContext::XSDError, location);

   598                     return;

   599                 }

   600 

   601                 // 3.1.2.5

   602                 // TODO: check value constraints

   603             }

   604         }

   605     }

   606 }

   607 

   608 void XsdSchemaChecker::checkBasicComplexTypeConstraints()

   609 {

   610     // check all global types...

   611     SchemaType::List types = m_schema->types();

   612 

   613     // .. and anonymous types

   614     types << m_schema->anonymousTypes();

   615 

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

   617         const SchemaType::Ptr type = types.at(i);

   618 

   619         if (!type->isComplexType() || !type->isDefinedBySchema())

   620             continue;

   621 

   622         const XsdComplexType::Ptr complexType = type;

   623 

   624         const QSourceLocation location = sourceLocation(complexType);

   625 

   626         // check inheritance restrictions of complex type defined by schema constraints

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

   628 

   629         // @see http://www.w3.org/TR/xmlschema11-1/#ct-props-correct 2)

   630         if (baseType->isSimpleType() && (complexType->derivationMethod() != XsdComplexType::DerivationExtension)) {

   631             m_context->error(QtXmlPatterns::tr("Derivation method of %1 must be extension because the base type %2 is a simple type.")

   632                                               .arg(formatType(m_namePool, complexType))

   633                                               .arg(formatType(m_namePool, baseType)),

   634                              XsdSchemaContext::XSDError, location);

   635             return;

   636         }

   637     }

   638 }

   639 

   640 void XsdSchemaChecker::checkComplexTypeConstraints()

   641 {

   642     // check all global types...

   643     SchemaType::List types = m_schema->types();

   644 

   645     // .. and anonymous types

   646     types << m_schema->anonymousTypes();

   647 

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

   649         const SchemaType::Ptr type = types.at(i);

   650 

   651         if (!type->isComplexType() || !type->isDefinedBySchema())

   652             continue;

   653 

   654         const XsdComplexType::Ptr complexType = type;

   655 

   656         const QSourceLocation location = sourceLocation(complexType);

   657 

   658         if (complexType->contentType()->particle()) {

   659             XsdElement::Ptr duplicatedElement;

   660             if (XsdParticleChecker::hasDuplicatedElements(complexType->contentType()->particle(), m_namePool, duplicatedElement)) {

   661                 m_context->error(QtXmlPatterns::tr("Complex type %1 has duplicated element %2 in its content model.")

   662                                                   .arg(formatType(m_namePool, complexType))

   663                                                   .arg(formatKeyword(duplicatedElement->displayName(m_namePool))),

   664                                  XsdSchemaContext::XSDError, location);

   665                 return;

   666             }

   667 

   668             if (!XsdParticleChecker::isUPAConform(complexType->contentType()->particle(), m_namePool)) {

   669                 m_context->error(QtXmlPatterns::tr("Complex type %1 has non-deterministic content.")

   670                                                   .arg(formatType(m_namePool, complexType)),

   671                                  XsdSchemaContext::XSDError, location);

   672                 return;

   673             }

   674         }

   675 

   676         // check inheritance restrictions of complex type defined by schema constraints

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

   678 

   679         // @see http://www.w3.org/TR/xmlschema11-1/#cos-ct-extends

   680         if (complexType->derivationMethod() == XsdComplexType::DerivationExtension) {

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

   682                 const XsdComplexType::Ptr complexBaseType = baseType;

   683 

   684                 // we can skip 1.1 here, as it is tested in checkInheritanceRestrictions() already

   685 

   686                 // 1.2 and 1.3

   687                 QString errorMsg;

   688                 if (!XsdSchemaHelper::isValidAttributeUsesExtension(complexType->attributeUses(), complexBaseType->attributeUses(),

   689                                                                     complexType->attributeWildcard(), complexBaseType->attributeWildcard(), m_context, errorMsg)) {

   690                     m_context->error(QtXmlPatterns::tr("Attributes of complex type %1 are not a valid extension of the attributes of base type %2: %3.")

   691                                                       .arg(formatType(m_namePool, complexType))

   692                                                       .arg(formatType(m_namePool, baseType))

   693                                                       .arg(errorMsg),

   694                                      XsdSchemaContext::XSDError, location);

   695                     return;

   696                 }

   697 

   698                 // 1.4

   699                 bool validContentType = false;

   700                 if (complexType->contentType()->variety() == XsdComplexType::ContentType::Simple && complexBaseType->contentType()->variety() == XsdComplexType::ContentType::Simple) {

   701                     if (complexType->contentType()->simpleType() == complexBaseType->contentType()->simpleType()) {

   702                         validContentType = true; // 1.4.1

   703                     }

   704                 } else if (complexType->contentType()->variety() == XsdComplexType::ContentType::Empty && complexBaseType->contentType()->variety() == XsdComplexType::ContentType::Empty) {

   705                     validContentType = true; // 1.4.2

   706                 } else { // 1.4.3

   707                     if (complexType->contentType()->variety() == XsdComplexType::ContentType::ElementOnly || complexType->contentType()->variety() == XsdComplexType::ContentType::Mixed) { // 1.4.3.1

   708                         if (complexBaseType->contentType()->variety() == XsdComplexType::ContentType::Empty) {

   709                             validContentType = true; // 1.4.3.2.1

   710                         } else { // 1.4.3.2.2

   711                             if (complexType->contentType()->particle()) {  // our own check

   712                                 if ((complexType->contentType()->variety() == XsdComplexType::ContentType::ElementOnly && complexBaseType->contentType()->variety() == XsdComplexType::ContentType::ElementOnly) ||

   713                                            (complexType->contentType()->variety() == XsdComplexType::ContentType::Mixed && complexBaseType->contentType()->variety() == XsdComplexType::ContentType::Mixed)) {  // 1.4.3.2.2.1

   714                                     if (isValidParticleExtension(complexType->contentType()->particle(), complexBaseType->contentType()->particle())) {

   715                                         validContentType = true; // 1.4.3.2.2.2

   716                                     }

   717                                 }

   718                             }

   719                             // 1.4.3.2.2.3  and 1.4.3.2.2.4 handle 'open content' that we do not support yet

   720                         }

   721                     }

   722                 }

   723 

   724                 // 1.5 WTF?!?

   725 

   726                 if (!validContentType) {

   727                     m_context->error(QtXmlPatterns::tr("Content model of complex type %1 is not a valid extension of content model of %2.")

   728                                                       .arg(formatType(m_namePool, complexType))

   729                                                       .arg(formatType(m_namePool, complexBaseType)),

   730                                      XsdSchemaContext::XSDError, location);

   731                     return;

   732                 }

   733 

   734             } else if (baseType->isSimpleType()) {

   735                 // 2.1

   736                 if (complexType->contentType()->variety() != XsdComplexType::ContentType::Simple) {

   737                     m_context->error(QtXmlPatterns::tr("Complex type %1 must have simple content.")

   738                                                       .arg(formatType(m_namePool, complexType)),

   739                                      XsdSchemaContext::XSDError, location);

   740                     return;

   741                 }

   742 

   743                 if (complexType->contentType()->simpleType() != baseType) {

   744                     m_context->error(QtXmlPatterns::tr("Complex type %1 must have the same simple type as its base class %2.")

   745                                                       .arg(formatType(m_namePool, complexType))

   746                                                       .arg(formatType(m_namePool, baseType)),

   747                                      XsdSchemaContext::XSDError, location);

   748                     return;

   749                 }

   750 

   751                 // 2.2 tested in checkInheritanceRestrictions() already

   752             }

   753         } else if (complexType->derivationMethod() == XsdComplexType::DerivationRestriction) {

   754             // @see http://www.w3.org/TR/xmlschema11-1/#d0e21402

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

   756 

   757             bool derivationOk = false;

   758             QString errorMsg;

   759 

   760             // we can partly skip 1 here, as it is tested in checkInheritanceRestrictions() already

   761             if (baseType->isComplexType()) {

   762 

   763                 // 2.1

   764                 if (baseType->name(m_namePool) == BuiltinTypes::xsAnyType->name(m_namePool)) {

   765                     derivationOk = true;

   766                 }

   767 

   768                 if (baseType->isDefinedBySchema()) {

   769                     const XsdComplexType::Ptr complexBaseType(baseType);

   770 

   771                     // 2.2.1

   772                     if (complexType->contentType()->variety() == XsdComplexType::ContentType::Simple) {

   773                         // 2.2.2.1

   774                         if (XsdSchemaHelper::isSimpleDerivationOk(complexType->contentType()->simpleType(), complexBaseType->contentType()->simpleType(), SchemaType::DerivationConstraints()))

   775                             derivationOk = true;

   776 

   777                         // 2.2.2.2

   778                         if (complexBaseType->contentType()->variety() == XsdComplexType::ContentType::Mixed) {

   779                             if (XsdSchemaHelper::isParticleEmptiable(complexBaseType->contentType()->particle()))

   780                                 derivationOk = true;

   781                         }

   782                     }

   783 

   784                     // 2.3.1

   785                     if (complexType->contentType()->variety() == XsdComplexType::ContentType::Empty) {

   786                         // 2.3.2.1

   787                         if (complexBaseType->contentType()->variety() == XsdComplexType::ContentType::Empty)

   788                             derivationOk = true;

   789 

   790                         // 2.3.2.2

   791                         if (complexBaseType->contentType()->variety() == XsdComplexType::ContentType::ElementOnly || complexBaseType->contentType()->variety() == XsdComplexType::ContentType::Mixed) {

   792                             if (XsdSchemaHelper::isParticleEmptiable(complexBaseType->contentType()->particle()))

   793                                 derivationOk = true;

   794                         }

   795                     }

   796 

   797                     // 2.4.1.1

   798                     if (((complexType->contentType()->variety() == XsdComplexType::ContentType::ElementOnly) &&

   799                          (complexBaseType->contentType()->variety() == XsdComplexType::ContentType::ElementOnly || complexBaseType->contentType()->variety() == XsdComplexType::ContentType::Mixed)) ||

   800                         // 2.4.1.2

   801                         (complexType->contentType()->variety() == XsdComplexType::ContentType::Mixed && complexBaseType->contentType()->variety() == XsdComplexType::ContentType::Mixed)) {

   802 

   803                         // 2.4.2

   804                         if (XsdParticleChecker::subsumes(complexBaseType->contentType()->particle(), complexType->contentType()->particle(), m_context, errorMsg))

   805                             derivationOk = true;

   806                     }

   807                 }

   808             }

   809 

   810             if (!derivationOk) {

   811                 m_context->error(QtXmlPatterns::tr("Complex type %1 cannot be derived from base type %2%3.")

   812                                                   .arg(formatType(m_namePool, complexType))

   813                                                   .arg(formatType(m_namePool, baseType))

   814                                                   .arg(errorMsg.isEmpty() ? QString() : QLatin1String(": ") + errorMsg),

   815                                  XsdSchemaContext::XSDError, location);

   816                 return;

   817             }

   818 

   819             if (baseType->isDefinedBySchema()) {

   820                 const XsdComplexType::Ptr complexBaseType(baseType);

   821 

   822                 QString errorMsg;

   823                 if (!XsdSchemaHelper::isValidAttributeUsesRestriction(complexType->attributeUses(), complexBaseType->attributeUses(),

   824                                                                       complexType->attributeWildcard(), complexBaseType->attributeWildcard(), m_context, errorMsg)) {

   825                     m_context->error(QtXmlPatterns::tr("Attributes of complex type %1 are not a valid restriction from the attributes of base type %2: %3.")

   826                                                       .arg(formatType(m_namePool, complexType))

   827                                                       .arg(formatType(m_namePool, baseType))

   828                                                       .arg(errorMsg),

   829                                      XsdSchemaContext::XSDError, location);

   830                     return;

   831                 }

   832             }

   833         }

   834 

   835         // check that complex type with simple content is not allowed to inherit from

   836         // built in complex type xs:AnyType

   837         if (complexType->contentType()->variety() == XsdComplexType::ContentType::Simple) {

   838             if (baseType->name(m_namePool) == BuiltinTypes::xsAnyType->name(m_namePool)) {

   839                 m_context->error(QtXmlPatterns::tr("Complex type %1 with simple content cannot be derived from complex base type %2.")

   840                                                   .arg(formatType(m_namePool, complexType))

   841                                                   .arg(formatType(m_namePool, baseType)),

   842                                  XsdSchemaContext::XSDError, location);

   843                 return;

   844             }

   845         }

   846     }

   847 }

   848 

   849 void XsdSchemaChecker::checkSimpleDerivationRestrictions()

   850 {

   851     // check all global types...

   852     SchemaType::List types = m_schema->types();

   853 

   854     // .. and anonymous types

   855     types << m_schema->anonymousTypes();

   856 

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

   858         const SchemaType::Ptr type = types.at(i);

   859 

   860         if (type->isComplexType())

   861             continue;

   862 

   863         if (type->category() != SchemaType::SimpleTypeList && type->category() != SchemaType::SimpleTypeUnion)

   864             continue;

   865 

   866         const XsdSimpleType::Ptr simpleType = type;

   867         const QSourceLocation location = sourceLocation(simpleType);

   868 

   869         // check all simple types derived by list

   870         if (simpleType->category() == XsdSimpleType::SimpleTypeList) {

   871             const AnySimpleType::Ptr itemType = simpleType->itemType();

   872 

   873             if (itemType->isComplexType()) {

   874                 m_context->error(QtXmlPatterns::tr("Item type of simple type %1 cannot be a complex type.")

   875                                                   .arg(formatType(m_namePool, simpleType)),

   876                                  XsdSchemaContext::XSDError, location);

   877                 return;

   878             }

   879 

   880 

   881             if (itemType->isSimpleType() && itemType->isDefinedBySchema()) {

   882                 const XsdSimpleType::Ptr simpleItemType = itemType;

   883                 if (simpleItemType->derivationConstraints() & XsdSimpleType::ListConstraint) {

   884                     m_context->error(QtXmlPatterns::tr("%1 is not allowed to derive from %2 by list as the latter defines it as final.")

   885                                                       .arg(formatType(m_namePool, simpleType))

   886                                                       .arg(formatType(m_namePool, simpleItemType)),

   887                                      XsdSchemaContext::XSDError, location);

   888                     return;

   889                 }

   890             }

   891 

   892             // @see http://www.w3.org/TR/xmlschema-2/#cos-list-of-atomic

   893             if (itemType->category() != SchemaType::SimpleTypeAtomic && itemType->category() != SchemaType::SimpleTypeUnion) {

   894                 m_context->error(QtXmlPatterns::tr("Variety of item type of %1 must be either atomic or union.").arg(formatType(m_namePool, simpleType)), XsdSchemaContext::XSDError, location);

   895                 return;

   896             }

   897 

   898             if (itemType->category() == SchemaType::SimpleTypeUnion && itemType->isDefinedBySchema()) {

   899                 const XsdSimpleType::Ptr simpleItemType = itemType;

   900                 const AnySimpleType::List memberTypes = simpleItemType->memberTypes();

   901                 for (int j = 0; j < memberTypes.count(); ++j) {

   902                     if (memberTypes.at(j)->category() != SchemaType::SimpleTypeAtomic) {

   903                         m_context->error(QtXmlPatterns::tr("Variety of member types of %1 must be atomic.").arg(formatType(m_namePool, simpleItemType)), XsdSchemaContext::XSDError, location);

   904                         return;

   905                     }

   906                 }

   907             }

   908         }

   909 

   910         // check all simple types derived by union

   911         if (simpleType->category() == XsdSimpleType::SimpleTypeUnion) {

   912             const AnySimpleType::List memberTypes = simpleType->memberTypes();

   913 

   914             for (int i = 0; i < memberTypes.count(); ++i) {

   915                 const AnySimpleType::Ptr memberType = memberTypes.at(i);

   916 

   917                 if (memberType->isComplexType()) {

   918                     m_context->error(QtXmlPatterns::tr("Member type of simple type %1 cannot be a complex type.")

   919                                                       .arg(formatType(m_namePool, simpleType)),

   920                                      XsdSchemaContext::XSDError, location);

   921                     return;

   922                 }

   923 

   924                 // @see http://www.w3.org/TR/xmlschema-2/#cos-no-circular-unions

   925                 if (simpleType->name(m_namePool) == memberType->name(m_namePool)) {

   926                     m_context->error(QtXmlPatterns::tr("%1 is not allowed to have a member type with the same name as itself.")

   927                                                       .arg(formatType(m_namePool, simpleType)),

   928                                      XsdSchemaContext::XSDError, location);

   929                     return;

   930                 }

   931 

   932                 if (memberType->isSimpleType() && memberType->isDefinedBySchema()) {

   933                     const XsdSimpleType::Ptr simpleMemberType = memberType;

   934                     if (simpleMemberType->derivationConstraints() & XsdSimpleType::UnionConstraint) {

   935                         m_context->error(QtXmlPatterns::tr("%1 is not allowed to derive from %2 by union as the latter defines it as final.")

   936                                                           .arg(formatType(m_namePool, simpleType))

   937                                                           .arg(formatType(m_namePool, simpleMemberType)),

   938                                          XsdSchemaContext::XSDError, location);

   939                         return;

   940                     }

   941                 }

   942             }

   943         }

   944     }

   945 }

   946 

   947 void XsdSchemaChecker::checkConstrainingFacets()

   948 {

   949     // first the global simple types

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

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

   952         if (!(types.at(i)->isSimpleType()) || !(types.at(i)->isDefinedBySchema()))

   953             continue;

   954 

   955         const XsdSimpleType::Ptr simpleType = types.at(i);

   956         checkConstrainingFacets(simpleType->facets(), simpleType);

   957     }

   958 

   959     // and afterwards all anonymous simple types

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

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

   962         if (!(anonymousTypes.at(i)->isSimpleType()) || !(anonymousTypes.at(i)->isDefinedBySchema()))

   963             continue;

   964 

   965         const XsdSimpleType::Ptr simpleType = anonymousTypes.at(i);

   966         checkConstrainingFacets(simpleType->facets(), simpleType);

   967     }

   968 }

   969 

   970 void XsdSchemaChecker::checkConstrainingFacets(const XsdFacet::Hash &facets, const XsdSimpleType::Ptr &simpleType)

   971 {

   972     if (facets.isEmpty())

   973         return;

   974 

   975     SchemaType::Ptr comparableBaseType;

   976     if (!simpleType->wxsSuperType()->isDefinedBySchema())

   977         comparableBaseType = simpleType->wxsSuperType();

   978     else

   979         comparableBaseType = simpleType->primitiveType();

   980 

   981     const XsdSchemaSourceLocationReflection reflection(sourceLocation(simpleType));

   982 

   983     // start checks

   984     if (facets.contains(XsdFacet::Length)) {

   985         const XsdFacet::Ptr lengthFacet = facets.value(XsdFacet::Length);

   986         const DerivedInteger<TypeNonNegativeInteger>::Ptr lengthValue = lengthFacet->value();

   987 

   988         // @see http://www.w3.org/TR/xmlschema-2/#length-minLength-maxLength

   989         if (facets.contains(XsdFacet::MinimumLength)) {

   990             const XsdFacet::Ptr minLengthFacet = facets.value(XsdFacet::MinimumLength);

   991             const DerivedInteger<TypeNonNegativeInteger>::Ptr minLengthValue = minLengthFacet->value();

   992 

   993             bool foundSuperMinimumLength = false;

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

   995             while (baseType) {

   996                 const XsdFacet::Hash baseFacets = m_context->facetsForType(baseType);

   997                 if (baseFacets.contains(XsdFacet::MinimumLength) && !baseFacets.contains(XsdFacet::Length)) {

   998                     const DerivedInteger<TypeNonNegativeInteger>::Ptr superValue(baseFacets.value(XsdFacet::MinimumLength)->value());

   999                     if (minLengthValue->toInteger() == superValue->toInteger()) {

  1000                         foundSuperMinimumLength = true;

  1001                         break;

  1002                     }

  1003                 }

  1004 

  1005                 baseType = baseType->wxsSuperType();

  1006             }

  1007 

  1008             if ((minLengthValue->toInteger() > lengthValue->toInteger()) || !foundSuperMinimumLength) {

  1009                 m_context->error(QtXmlPatterns::tr("%1 facet collides with %2 facet.")

  1010                                                   .arg(formatKeyword("length"))

  1011                                                   .arg(formatKeyword("minLength")),

  1012                                  XsdSchemaContext::XSDError, sourceLocation(simpleType));

  1013                 return;

  1014             }

  1015         }

  1016 

  1017         // @see http://www.w3.org/TR/xmlschema-2/#length-minLength-maxLength

  1018         if (facets.contains(XsdFacet::MaximumLength)) {

  1019             const XsdFacet::Ptr maxLengthFacet = facets.value(XsdFacet::MaximumLength);

  1020             const DerivedInteger<TypeNonNegativeInteger>::Ptr maxLengthValue = maxLengthFacet->value();

  1021 

  1022             bool foundSuperMaximumLength = false;

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

  1024             while (baseType) {

  1025                 const XsdFacet::Hash baseFacets = m_context->facetsForType(baseType);

  1026                 if (baseFacets.contains(XsdFacet::MaximumLength) && !baseFacets.contains(XsdFacet::Length)) {

  1027                     const DerivedInteger<TypeNonNegativeInteger>::Ptr superValue(baseFacets.value(XsdFacet::MaximumLength)->value());

  1028                     if (maxLengthValue->toInteger() == superValue->toInteger()) {

  1029                         foundSuperMaximumLength = true;

  1030                         break;

  1031                     }

  1032                 }

  1033 

  1034                 baseType = baseType->wxsSuperType();

  1035             }

  1036 

  1037             if ((maxLengthValue->toInteger() < lengthValue->toInteger()) || !foundSuperMaximumLength) {

  1038                 m_context->error(QtXmlPatterns::tr("%1 facet collides with %2 facet.")

  1039                                                   .arg(formatKeyword("length"))

  1040                                                   .arg(formatKeyword("maxLength")),

  1041                                  XsdSchemaContext::XSDError, sourceLocation(simpleType));

  1042                 return;

  1043             }

  1044         }

  1045 

  1046         // @see http://www.w3.org/TR/xmlschema-2/#length-valid-restriction

  1047         if (simpleType->derivationMethod() == XsdSimpleType::DerivationRestriction) {

  1048             const XsdFacet::Hash baseFacets = m_context->facetsForType(simpleType->wxsSuperType());

  1049             if (baseFacets.contains(XsdFacet::Length)) {

  1050                 const DerivedInteger<TypeNonNegativeInteger>::Ptr baseValue = baseFacets.value(XsdFacet::Length)->value();

  1051                 if (lengthValue->toInteger() != baseValue->toInteger()) {

  1052                     m_context->error(QtXmlPatterns::tr("%1 facet must have the same value as %2 facet of base type.")

  1053                                                       .arg(formatKeyword("length"))

  1054                                                       .arg(formatKeyword("length")),

  1055                                      XsdSchemaContext::XSDError, sourceLocation(simpleType));

  1056                     return;

  1057                 }

  1058             }

  1059         }

  1060     }

  1061 

  1062     if (facets.contains(XsdFacet::MinimumLength)) {

  1063         const XsdFacet::Ptr minLengthFacet = facets.value(XsdFacet::MinimumLength);

  1064         const DerivedInteger<TypeNonNegativeInteger>::Ptr minLengthValue = minLengthFacet->value();

  1065 

  1066         if (facets.contains(XsdFacet::MaximumLength)) {

  1067             const XsdFacet::Ptr maxLengthFacet = facets.value(XsdFacet::MaximumLength);

  1068             const DerivedInteger<TypeNonNegativeInteger>::Ptr maxLengthValue = maxLengthFacet->value();

  1069 

  1070             // @see http://www.w3.org/TR/xmlschema-2/#minLength-less-than-equal-to-maxLength

  1071             if (maxLengthValue->toInteger() < minLengthValue->toInteger()) {

  1072                 m_context->error(QtXmlPatterns::tr("%1 facet collides with %2 facet.")

  1073                                                   .arg(formatKeyword("minLength"))

  1074                                                   .arg(formatKeyword("maxLength")),

  1075                                  XsdSchemaContext::XSDError, sourceLocation(simpleType));

  1076                 return;

  1077             }

  1078 

  1079             // @see http://www.w3.org/TR/xmlschema-2/#minLength-valid-restriction

  1080             //TODO: check parent facets

  1081         }

  1082 

  1083         // @see http://www.w3.org/TR/xmlschema-2/#minLength-valid-restriction

  1084         if (simpleType->derivationMethod() == XsdSimpleType::DerivationRestriction) {

  1085             const XsdFacet::Hash baseFacets = m_context->facetsForType(simpleType->wxsSuperType());

  1086             if (baseFacets.contains(XsdFacet::MinimumLength)) {

  1087                 const DerivedInteger<TypeNonNegativeInteger>::Ptr baseValue = baseFacets.value(XsdFacet::MinimumLength)->value();

  1088                 if (minLengthValue->toInteger() < baseValue->toInteger()) {

  1089                     m_context->error(QtXmlPatterns::tr("%1 facet must be equal or greater than %2 facet of base type.")

  1090                                                       .arg(formatKeyword("minLength"))

  1091                                                       .arg(formatKeyword("minLength")),

  1092                                      XsdSchemaContext::XSDError, sourceLocation(simpleType));

  1093                     return;

  1094                 }

  1095             }

  1096         }

  1097     }

  1098     if (facets.contains(XsdFacet::MaximumLength)) {

  1099         const XsdFacet::Ptr maxLengthFacet = facets.value(XsdFacet::MaximumLength);

  1100         const DerivedInteger<TypeNonNegativeInteger>::Ptr maxLengthValue = maxLengthFacet->value();

  1101 

  1102         // @see http://www.w3.org/TR/xmlschema-2/#maxLength-valid-restriction

  1103         if (simpleType->derivationMethod() == XsdSimpleType::DerivationRestriction) {

  1104             const XsdFacet::Hash baseFacets = m_context->facetsForType(simpleType->wxsSuperType());

  1105             if (baseFacets.contains(XsdFacet::MaximumLength)) {

  1106                 const DerivedInteger<TypeNonNegativeInteger>::Ptr baseValue(baseFacets.value(XsdFacet::MaximumLength)->value());

  1107                 if (maxLengthValue->toInteger() > baseValue->toInteger()) {

  1108                     m_context->error(QtXmlPatterns::tr("%1 facet must be less than or equal to %2 facet of base type.")

  1109                                                       .arg(formatKeyword("maxLength"))

  1110                                                       .arg(formatKeyword("maxLength")),

  1111                                      XsdSchemaContext::XSDError, sourceLocation(simpleType));

  1112                     return;

  1113                 }

  1114             }

  1115         }

  1116     }

  1117     if (facets.contains(XsdFacet::Pattern)) {

  1118         //  we keep the patterns in separated facets

  1119         // @see http://www.w3.org/TR/xmlschema-2/#src-multiple-patterns

  1120 

  1121         // @see http://www.w3.org/TR/xmlschema-2/#cvc-pattern-valid

  1122         const XsdFacet::Ptr patternFacet = facets.value(XsdFacet::Pattern);

  1123         const AtomicValue::List multiValue = patternFacet->multiValue();

  1124 

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

  1126             const DerivedString<TypeString>::Ptr value = multiValue.at(i);

  1127             const QRegExp exp = PatternPlatform::parsePattern(value->stringValue(), m_context, &reflection);

  1128             if (!exp.isValid()) {

  1129                 m_context->error(QtXmlPatterns::tr("%1 facet contains invalid regular expression").arg(formatKeyword("pattern.")), XsdSchemaContext::XSDError, sourceLocation(simpleType));

  1130                 return;

  1131             }

  1132         }

  1133     }

  1134     if (facets.contains(XsdFacet::Enumeration)) {

  1135         // @see http://www.w3.org/TR/xmlschema-2/#src-multiple-enumerations