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

     2 **

     3 ** Copyright (C) 2010 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 "qxsdschemaparser_p.h"

    43 

    44 #include "private/qxmlutils_p.h"

    45 #include "qacceltreeresourceloader_p.h"

    46 #include "qautoptr_p.h"

    47 #include "qboolean_p.h"

    48 #include "qcommonnamespaces_p.h"

    49 #include "qderivedinteger_p.h"

    50 #include "qderivedstring_p.h"

    51 #include "qqnamevalue_p.h"

    52 #include "qxmlquery_p.h"

    53 #include "qxpathhelper_p.h"

    54 #include "qxsdattributereference_p.h"

    55 #include "qxsdreference_p.h"

    56 #include "qxsdschematoken_p.h"

    57 

    58 #include <QtCore/QFile>

    59 #include <QtXmlPatterns/QXmlQuery>

    60 

    61 QT_BEGIN_NAMESPACE

    62 

    63 /**

    64  * @page schema_overview Overview

    65  * @section structure_and_components Structure and Components

    66  *

    67  * The schema validator code consists of 4 major components

    68  *

    69  * <dl>

    70  *  <dt>The schema parser (QPatternist::XsdSchemaParser)</dt>

    71  *  <dd>This component parses a XML document that is supplied via a QIODevice. It creates

    72  *      a so called (incomplete) 'compiled schema', which is a representation of the XML Schema

    73  *      structure as C++ objects.

    74  *      As the parser is a streaming parser, it can't resolve references to types or elements/attributes

    75  *      in place, therefor it creates resolver tasks which are passed to the schema resolver component

    76  *      for resolving at a later point in time.

    77  *      The parser does furthermore the basic XML structure constraint checking, e.g. if all required

    78  *      attributes are available or the order of the elements is correct.</dd>

    79  *

    80  *  <dt>The schema resolver (QPatternist::XsdSchemaResolver)</dt>

    81  *  <dd>This component is activated after the schema parser component has been finished the parsing

    82  *      of all schemas. The resolver has been supplied with resolve tasks by the schema parser that

    83  *      it will resolve in this step now. Between working on the single resolver tasks, the resolver

    84  *      calls check methods from the schema checker component to make sure that some assertions are

    85  *      valid (e.g. no circular inheritance of types), so that the resolver can work without hassle.

    86  *      During resoving references to attribute or element groups it also checks for circular references

    87  *      of these groups.

    88  *      At the end of that phase we have a compiled schema that is fully resolved (not necessarily valid though).</dd>

    89  *

    90  *  <dt>The schema checker (QPatternist::XsdSchemaChecker)</dt>

    91  *  <dd>This component does all the schema constraint checking as given by the Schema specification.

    92  *      At the end of that phase we have fully resolved and valid compiled schema that can be used for validation

    93  *      of instance documents.</dd>

    94  *

    95  *  <dt>The validator (QPatternist::XsdValidatingInstanceReader)</dt>

    96  *  <dd>This component is responsible for validating a XML instance document, provided via a QIODevice, against

    97  *      a valid compiled schema.</dd>

    98  * </dl>

    99  *

   100  * @ingroup Patternist_schema

   101  */

   102 

   103 using namespace QPatternist;

   104 

   105 namespace QPatternist

   106 {

   107 

   108 /**

   109  * @short A helper class for automatically handling namespace scopes of elements.

   110  *

   111  * This class should be instantiated at the beginning of each parse XYZ method.

   112  */

   113 class ElementNamespaceHandler

   114 {

   115     public:

   116         /**

   117          * Creates a new element namespace handler object.

   118          *

   119          * It checks whether the @p parser is on the right @p tag and it creates a new namespace

   120          * context that contains the inherited and local namespace declarations.

   121          */

   122         ElementNamespaceHandler(const XsdSchemaToken::NodeName &tag, XsdSchemaParser *parser)

   123             : m_parser(parser)

   124         {

   125             Q_ASSERT(m_parser->isStartElement() && (XsdSchemaToken::toToken(m_parser->name()) == tag) && (XsdSchemaToken::toToken(m_parser->namespaceUri()) == XsdSchemaToken::XML_NS_SCHEMA_URI));

   126             Q_UNUSED(tag)

   127             m_parser->m_namespaceSupport.pushContext();

   128             m_parser->m_namespaceSupport.setPrefixes(m_parser->namespaceDeclarations());

   129         }

   130 

   131         /**

   132          * Destroys the element namespace handler object.

   133          *

   134          * It destroys the local namespace context.

   135          */

   136         ~ElementNamespaceHandler()

   137         {

   138             m_parser->m_namespaceSupport.popContext();

   139         }

   140 

   141     private:

   142         XsdSchemaParser *m_parser;

   143 };

   144 

   145 /**

   146  * A helper class that checks for the right occurrence of

   147  * xml tags with the help of a DFA.

   148  */

   149 class TagValidationHandler

   150 {

   151     public:

   152         TagValidationHandler(XsdTagScope::Type tag, XsdSchemaParser *parser, const NamePool::Ptr &namePool)

   153             : m_parser(parser), m_machine(namePool)

   154         {

   155             Q_ASSERT(m_parser->m_stateMachines.contains(tag));

   156 

   157             m_machine = m_parser->m_stateMachines.value(tag);

   158             m_machine.reset();

   159         }

   160 

   161         void validate(XsdSchemaToken::NodeName token)

   162         {

   163             if (token == XsdSchemaToken::NoKeyword) {

   164                 const QList<XsdSchemaToken::NodeName> tokens = m_machine.possibleTransitions();

   165 

   166                 QStringList elementNames;

   167                 for (int i = 0; i < tokens.count(); ++i)

   168                     elementNames.append(formatElement(XsdSchemaToken::toString(tokens.at(i))));

   169 

   170                 m_parser->error(QtXmlPatterns::tr("Can not process unknown element %1, expected elements are: %2.")

   171                                                  .arg(formatElement(m_parser->name().toString()))

   172                                                  .arg(elementNames.join(QLatin1String(", "))));

   173                 return;

   174             }

   175 

   176             if (!m_machine.proceed(token)) {

   177                 const QList<XsdSchemaToken::NodeName> tokens = m_machine.possibleTransitions();

   178 

   179                 QStringList elementNames;

   180                 for (int i = 0; i < tokens.count(); ++i)

   181                     elementNames.append(formatElement(XsdSchemaToken::toString(tokens.at(i))));

   182 

   183                 m_parser->error(QtXmlPatterns::tr("Element %1 is not allowed in this scope, possible elements are: %2.")

   184                                                  .arg(formatElement(XsdSchemaToken::toString(token)))

   185                                                  .arg(elementNames.join(QLatin1String(", "))));

   186                 return;

   187             }

   188         }

   189 

   190         void finalize() const

   191         {

   192             if (!m_machine.inEndState()) {

   193                 const QList<XsdSchemaToken::NodeName> tokens = m_machine.possibleTransitions();

   194 

   195                 QStringList elementNames;

   196                 for (int i = 0; i < tokens.count(); ++i)

   197                     elementNames.append(formatElement(XsdSchemaToken::toString(tokens.at(i))));

   198 

   199                 m_parser->error(QtXmlPatterns::tr("Child element is missing in that scope, possible child elements are: %1.")

   200                                                  .arg(elementNames.join(QLatin1String(", "))));

   201             }

   202         }

   203 

   204         private:

   205             XsdSchemaParser *m_parser;

   206             XsdStateMachine<XsdSchemaToken::NodeName> m_machine;

   207 };

   208 

   209 }

   210 

   211 /**

   212  * Returns a list of all particles with group references that appear at any level of

   213  * the given unresolved @p group.

   214  */

   215 static XsdParticle::List collectGroupRef(const XsdModelGroup::Ptr &group)

   216 {

   217     XsdParticle::List refParticles;

   218 

   219     XsdParticle::List particles = group->particles();

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

   221         if (particles.at(i)->term()->isReference()) {

   222             const XsdReference::Ptr reference(particles.at(i)->term());

   223             if (reference->type() == XsdReference::ModelGroup)

   224                 refParticles.append(particles.at(i));

   225         }

   226         if (particles.at(i)->term()->isModelGroup()) {

   227             refParticles << collectGroupRef(XsdModelGroup::Ptr(particles.at(i)->term()));

   228         }

   229     }

   230 

   231     return refParticles;

   232 }

   233 

   234 /**

   235  * Helper function that works around the limited facilities of

   236  * QUrl/AnyURI::fromLexical to detect invalid URIs

   237  */

   238 inline static bool isValidUri(const QString &string)

   239 {

   240     // an empty URI points to the current document as defined in RFC 2396 (4.2)

   241     if (string.isEmpty())

   242         return true;

   243 

   244     // explicit check as that is not checked by the code below

   245     if (string.startsWith(QLatin1String("##")))

   246         return false;

   247 

   248     const AnyURI::Ptr uri = AnyURI::fromLexical(string);

   249     return (!(uri->hasError()));

   250 }

   251 

   252 XsdSchemaParser::XsdSchemaParser(const XsdSchemaContext::Ptr &context, const XsdSchemaParserContext::Ptr &parserContext, QIODevice *device)

   253     : MaintainingReader<XsdSchemaToken, XsdTagScope::Type>(parserContext->elementDescriptions(), QSet<XsdSchemaToken::NodeName>(), context, device)

   254     , m_context(context)

   255     , m_parserContext(parserContext)

   256     , m_namePool(m_parserContext->namePool())

   257     , m_namespaceSupport(m_namePool)

   258 {

   259     m_schema = m_parserContext->schema();

   260     m_schemaResolver = m_parserContext->resolver();

   261     m_idCache = XsdIdCache::Ptr(new XsdIdCache());

   262 

   263     setupStateMachines();

   264     setupBuiltinTypeNames();

   265 }

   266 

   267 void XsdSchemaParser::addIncludedSchemas(const NamespaceSet &schemas)

   268 {

   269     m_includedSchemas += schemas;

   270 }

   271 

   272 void XsdSchemaParser::setIncludedSchemas(const NamespaceSet &schemas)

   273 {

   274     m_includedSchemas = schemas;

   275 }

   276 

   277 void XsdSchemaParser::addImportedSchemas(const NamespaceSet &schemas)

   278 {

   279     m_importedSchemas += schemas;

   280 }

   281 

   282 void XsdSchemaParser::setImportedSchemas(const NamespaceSet &schemas)

   283 {

   284     m_importedSchemas = schemas;

   285 }

   286 

   287 void XsdSchemaParser::addRedefinedSchemas(const NamespaceSet &schemas)

   288 {

   289     m_redefinedSchemas += schemas;

   290 }

   291 

   292 void XsdSchemaParser::setRedefinedSchemas(const NamespaceSet &schemas)

   293 {

   294     m_redefinedSchemas = schemas;

   295 }

   296 

   297 void XsdSchemaParser::setTargetNamespace(const QString &targetNamespace)

   298 {

   299     m_targetNamespace = targetNamespace;

   300 }

   301 

   302 void XsdSchemaParser::setTargetNamespaceExtended(const QString &targetNamespace)

   303 {

   304     m_targetNamespace = targetNamespace;

   305     m_namespaceSupport.setTargetNamespace(m_namePool->allocateNamespace(m_targetNamespace));

   306 }

   307 

   308 void XsdSchemaParser::setDocumentURI(const QUrl &uri)

   309 {

   310     m_documentURI = uri;

   311 

   312     // prevent to get included/imported/redefined twice

   313     m_includedSchemas.insert(uri);

   314     m_importedSchemas.insert(uri);

   315     m_redefinedSchemas.insert(uri);

   316 }

   317 

   318 QUrl XsdSchemaParser::documentURI() const

   319 {

   320     return m_documentURI;

   321 }

   322 

   323 bool XsdSchemaParser::isAnyAttributeAllowed() const

   324 {

   325     return false;

   326 }

   327 

   328 bool XsdSchemaParser::parse(ParserType parserType)

   329 {

   330     m_componentLocationHash.clear();

   331 

   332     while (!atEnd()) {

   333         readNext();

   334 

   335         if (isStartElement()) {

   336             const XsdSchemaToken::NodeName token = XsdSchemaToken::toToken(name());

   337             const XsdSchemaToken::NodeName namespaceToken = XsdSchemaToken::toToken(namespaceUri());

   338 

   339             if (isSchemaTag(XsdSchemaToken::Schema, token, namespaceToken)) {

   340                 parseSchema(parserType);

   341             } else {

   342                 error(QtXmlPatterns::tr("Document is not a XML schema."));

   343             }

   344         }

   345     }

   346 

   347     m_schemaResolver->addComponentLocationHash(m_componentLocationHash);

   348     m_schemaResolver->setDefaultOpenContent(m_defaultOpenContent, m_defaultOpenContentAppliesToEmpty);

   349 

   350     if (QXmlStreamReader::error() != QXmlStreamReader::NoError)

   351         error(errorString());

   352 

   353     return true;

   354 }

   355 

   356 void XsdSchemaParser::error(const QString &msg)

   357 {

   358     MaintainingReader<XsdSchemaToken, XsdTagScope::Type>::error(msg, XsdSchemaContext::XSDError);

   359 }

   360 

   361 void XsdSchemaParser::attributeContentError(const char *attributeName, const char *elementName, const QString &value, const SchemaType::Ptr &type)

   362 {

   363     if (type) {

   364         error(QtXmlPatterns::tr("%1 attribute of %2 element contains invalid content: {%3} is not a value of type %4.")

   365                                .arg(formatAttribute(attributeName))

   366                                .arg(formatElement(elementName))

   367                                .arg(formatData(value))

   368                                .arg(formatType(m_namePool, type)));

   369     } else {

   370         error(QtXmlPatterns::tr("%1 attribute of %2 element contains invalid content: {%3}.")

   371                                .arg(formatAttribute(attributeName))

   372                                .arg(formatElement(elementName))

   373                                .arg(formatData(value)));

   374     }

   375 }

   376 

   377 void XsdSchemaParser::parseSchema(ParserType parserType)

   378 {

   379     const ElementNamespaceHandler namespaceHandler(XsdSchemaToken::Schema, this);

   380 

   381     validateElement(XsdTagScope::Schema);

   382 

   383     // parse attributes

   384 

   385     if (parserType == TopLevelParser) {

   386         if (hasAttribute(QString::fromLatin1("targetNamespace"))) {

   387             m_targetNamespace = readNamespaceAttribute(QString::fromLatin1("targetNamespace"), "schema");

   388         }

   389     } else if (parserType == IncludeParser) {

   390         // m_targetNamespace is set to the target namespace of the including schema at this point

   391 

   392         if (hasAttribute(QString::fromLatin1("targetNamespace"))) {

   393             const QString targetNamespace = readNamespaceAttribute(QString::fromLatin1("targetNamespace"), "schema");

   394 

   395             if (m_targetNamespace != targetNamespace) {

   396                 error(QtXmlPatterns::tr("Target namespace %1 of included schema is different from the target namespace %2 as defined by the including schema.")

   397                                        .arg(formatURI(targetNamespace)).arg(formatURI(m_targetNamespace)));

   398                 return;

   399             }

   400         }

   401     } else if (parserType == ImportParser) {

   402         // m_targetNamespace is set to the target namespace from the namespace attribute of the <import> tag at this point

   403 

   404         QString targetNamespace;

   405         if (hasAttribute(QString::fromLatin1("targetNamespace"))) {

   406             targetNamespace = readNamespaceAttribute(QString::fromLatin1("targetNamespace"), "schema");

   407         }

   408 

   409         if (m_targetNamespace != targetNamespace) {

   410             error(QtXmlPatterns::tr("Target namespace %1 of imported schema is different from the target namespace %2 as defined by the importing schema.")

   411                                    .arg(formatURI(targetNamespace)).arg(formatURI(m_targetNamespace)));

   412             return;

   413         }

   414     } else if (parserType == RedefineParser) {

   415         // m_targetNamespace is set to the target namespace of the redefining schema at this point

   416 

   417         if (hasAttribute(QString::fromLatin1("targetNamespace"))) {

   418             const QString targetNamespace = readNamespaceAttribute(QString::fromLatin1("targetNamespace"), "schema");

   419 

   420             if (m_targetNamespace != targetNamespace) {

   421                 error(QtXmlPatterns::tr("Target namespace %1 of imported schema is different from the target namespace %2 as defined by the importing schema.")

   422                                        .arg(formatURI(targetNamespace)).arg(formatURI(m_targetNamespace)));

   423                 return;

   424             }

   425         }

   426     }

   427 

   428     if (hasAttribute(QString::fromLatin1("attributeFormDefault"))) {

   429         const QString value = readAttribute(QString::fromLatin1("attributeFormDefault"));

   430         if (value != QString::fromLatin1("qualified") && value != QString::fromLatin1("unqualified")) {

   431             attributeContentError("attributeFormDefault", "schema", value);

   432             return;

   433         }

   434 

   435         m_attributeFormDefault = value;

   436     } else {

   437         m_attributeFormDefault = QString::fromLatin1("unqualified");

   438     }

   439 

   440     if (hasAttribute(QString::fromLatin1("elementFormDefault"))) {

   441         const QString value = readAttribute(QString::fromLatin1("elementFormDefault"));

   442         if (value != QString::fromLatin1("qualified") && value != QString::fromLatin1("unqualified")) {

   443             attributeContentError("elementFormDefault", "schema", value);

   444             return;

   445         }

   446 

   447         m_elementFormDefault = value;

   448     } else {

   449         m_elementFormDefault = QString::fromLatin1("unqualified");

   450     }

   451 

   452     if (hasAttribute(QString::fromLatin1("blockDefault"))) {

   453         const QString blockDefault = readAttribute(QString::fromLatin1("blockDefault"));

   454         const QStringList blockDefaultList = blockDefault.split(QLatin1Char(' '), QString::SkipEmptyParts);

   455         for (int i = 0; i < blockDefaultList.count(); ++i) {

   456             const QString value = blockDefaultList.at(i);

   457             if (value != QString::fromLatin1("#all") &&

   458                 value != QString::fromLatin1("extension") &&

   459                 value != QString::fromLatin1("restriction") &&

   460                 value != QString::fromLatin1("substitution")) {

   461                 attributeContentError("blockDefault", "schema", value);

   462                 return;

   463             }

   464         }

   465 

   466         m_blockDefault = blockDefault;

   467     }

   468 

   469     if (hasAttribute(QString::fromLatin1("finalDefault"))) {

   470         const QString finalDefault = readAttribute(QString::fromLatin1("finalDefault"));

   471         const QStringList finalDefaultList = finalDefault.split(QLatin1Char(' '), QString::SkipEmptyParts);

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

   473             const QString value = finalDefaultList.at(i);

   474             if (value != QString::fromLatin1("#all") &&

   475                 value != QString::fromLatin1("extension") &&

   476                 value != QString::fromLatin1("restriction") &&

   477                 value != QString::fromLatin1("list") &&

   478                 value != QString::fromLatin1("union")) {

   479                 attributeContentError("finalDefault", "schema", value);

   480                 return;

   481             }

   482         }

   483 

   484         m_finalDefault = finalDefault;

   485     }

   486 

   487     if (hasAttribute(QString::fromLatin1("xpathDefaultNamespace"))) {

   488         const QString xpathDefaultNamespace = readAttribute(QString::fromLatin1("xpathDefaultNamespace"));

   489         if (xpathDefaultNamespace != QString::fromLatin1("##defaultNamespace") &&

   490             xpathDefaultNamespace != QString::fromLatin1("##targetNamespace") &&

   491             xpathDefaultNamespace != QString::fromLatin1("##local")) {

   492             if (!isValidUri(xpathDefaultNamespace)) {

   493                 attributeContentError("xpathDefaultNamespace", "schema", xpathDefaultNamespace);

   494                 return;

   495             }

   496         }

   497         m_xpathDefaultNamespace = xpathDefaultNamespace;

   498     } else {

   499         m_xpathDefaultNamespace = QString::fromLatin1("##local");

   500     }

   501 

   502     if (hasAttribute(QString::fromLatin1("defaultAttributes"))) {

   503         const QString attrGroupName = readQNameAttribute(QString::fromLatin1("defaultAttributes"), "schema");

   504         convertName(attrGroupName, NamespaceSupport::ElementName, m_defaultAttributes); // translate qualified name into QXmlName

   505     }

   506 

   507     if (hasAttribute(QString::fromLatin1("version"))) {

   508         const QString version = readAttribute(QString::fromLatin1("version"));

   509     }

   510 

   511     if (hasAttribute(CommonNamespaces::XML, QString::fromLatin1("lang"))) {

   512         const QString value = readAttribute(QString::fromLatin1("lang"), CommonNamespaces::XML);

   513 

   514         const QRegExp exp(QString::fromLatin1("[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*"));

   515         if (!exp.exactMatch(value)) {

   516             attributeContentError("xml:lang", "schema", value);

   517             return;

   518         }

   519     }

   520 

   521     validateIdAttribute("schema");

   522 

   523     TagValidationHandler tagValidator(XsdTagScope::Schema, this, m_namePool);

   524 

   525     while (!atEnd()) {

   526         readNext();

   527 

   528         if (isEndElement())

   529             break;

   530 

   531         if (isStartElement()) {

   532             const XsdSchemaToken::NodeName token = XsdSchemaToken::toToken(name());

   533             const XsdSchemaToken::NodeName namespaceToken = XsdSchemaToken::toToken(namespaceUri());

   534 

   535             tagValidator.validate(token);

   536 

   537             if (isSchemaTag(XsdSchemaToken::Include, token, namespaceToken)) {

   538                 parseInclude();

   539             } else if (isSchemaTag(XsdSchemaToken::Import, token, namespaceToken)) {

   540                 parseImport();

   541             } else if (isSchemaTag(XsdSchemaToken::Redefine, token, namespaceToken)) {

   542                 parseRedefine();

   543             } else if (isSchemaTag(XsdSchemaToken::Annotation, token, namespaceToken)) {

   544                 const XsdAnnotation::Ptr annotation = parseAnnotation();

   545                 m_schema->addAnnotation(annotation);

   546             } else if (isSchemaTag(XsdSchemaToken::DefaultOpenContent, token, namespaceToken)) {

   547                 parseDefaultOpenContent();

   548             } else if (isSchemaTag(XsdSchemaToken::SimpleType, token, namespaceToken)) {

   549                 const XsdSimpleType::Ptr type = parseGlobalSimpleType();

   550                 addType(type);

   551             } else if (isSchemaTag(XsdSchemaToken::ComplexType, token, namespaceToken)) {

   552                 const XsdComplexType::Ptr type = parseGlobalComplexType();

   553                 addType(type);

   554             } else if (isSchemaTag(XsdSchemaToken::Group, token, namespaceToken)) {

   555                 const XsdModelGroup::Ptr group = parseNamedGroup();

   556                 addElementGroup(group);

   557             } else if (isSchemaTag(XsdSchemaToken::AttributeGroup, token, namespaceToken)) {

   558                 XsdAttributeGroup::Ptr attributeGroup = parseNamedAttributeGroup();

   559                 addAttributeGroup(attributeGroup);

   560             } else if (isSchemaTag(XsdSchemaToken::Element, token, namespaceToken)) {

   561                 const XsdElement::Ptr element = parseGlobalElement();

   562                 addElement(element);

   563             } else if (isSchemaTag(XsdSchemaToken::Attribute, token, namespaceToken)) {

   564                 const XsdAttribute::Ptr attribute = parseGlobalAttribute();

   565                 addAttribute(attribute);

   566             } else if (isSchemaTag(XsdSchemaToken::Notation, token, namespaceToken)) {

   567                 const XsdNotation::Ptr notation = parseNotation();

   568                 addNotation(notation);

   569             } else {

   570                 parseUnknown();

   571             }

   572         }

   573     }

   574 

   575     tagValidator.finalize();

   576 

   577     m_schema->setTargetNamespace(m_targetNamespace);

   578 }

   579 

   580 void XsdSchemaParser::parseInclude()

   581 {

   582     Q_ASSERT(isStartElement() && XsdSchemaToken::toToken(name()) == XsdSchemaToken::Include &&

   583                                  XsdSchemaToken::toToken(namespaceUri()) == XsdSchemaToken::XML_NS_SCHEMA_URI);

   584 

   585     validateElement(XsdTagScope::Include);

   586 

   587     // parse attributes

   588     const QString schemaLocation = readAttribute(QString::fromLatin1("schemaLocation"));

   589 

   590     QUrl url(schemaLocation);

   591     if (url.isRelative()) {

   592         Q_ASSERT(m_documentURI.isValid());

   593 

   594         url = m_documentURI.resolved(url);

   595     }

   596 

   597     if (m_includedSchemas.contains(url)) {

   598         // we have included that file already, according to the schema spec we are

   599         // allowed to silently skip it.

   600     } else {

   601         m_includedSchemas.insert(url);

   602 

   603         const AutoPtr<QNetworkReply> reply(AccelTreeResourceLoader::load(url, m_context->networkAccessManager(),

   604                                                                          m_context, AccelTreeResourceLoader::ContinueOnError));

   605         if (reply) {

   606             // parse the included schema by a different parser but with the same context

   607             XsdSchemaParser parser(m_context, m_parserContext, reply.data());

   608             parser.setDocumentURI(url);

   609             parser.setTargetNamespaceExtended(m_targetNamespace);

   610             parser.setIncludedSchemas(m_includedSchemas);

   611             parser.setImportedSchemas(m_importedSchemas);

   612             parser.setRedefinedSchemas(m_redefinedSchemas);

   613             if (!parser.parse(XsdSchemaParser::IncludeParser)) {

   614                 return;

   615             } else {

   616                 // add indirectly loaded schemas to the list of already loaded ones

   617                 addIncludedSchemas(parser.m_includedSchemas);

   618                 addImportedSchemas(parser.m_importedSchemas);

   619                 addRedefinedSchemas(parser.m_redefinedSchemas);

   620             }

   621         }

   622     }

   623 

   624     validateIdAttribute("include");

   625 

   626     TagValidationHandler tagValidator(XsdTagScope::Include, this, m_namePool);

   627 

   628     while (!atEnd()) {

   629         readNext();

   630 

   631         if (isEndElement())

   632             break;

   633 

   634         if (isStartElement()) {

   635             const XsdSchemaToken::NodeName token = XsdSchemaToken::toToken(name());

   636             const XsdSchemaToken::NodeName namespaceToken = XsdSchemaToken::toToken(namespaceUri());

   637 

   638             tagValidator.validate(token);

   639 

   640             if (isSchemaTag(XsdSchemaToken::Annotation, token, namespaceToken)) {

   641                 const XsdAnnotation::Ptr annotation = parseAnnotation();

   642                 m_schema->addAnnotation(annotation);

   643             } else {

   644                 parseUnknown();

   645             }

   646         }

   647     }

   648 

   649     tagValidator.finalize();

   650 }

   651 

   652 void XsdSchemaParser::parseImport()

   653 {

   654     Q_ASSERT(isStartElement() && XsdSchemaToken::toToken(name()) == XsdSchemaToken::Import &&

   655                                  XsdSchemaToken::toToken(namespaceUri()) == XsdSchemaToken::XML_NS_SCHEMA_URI);

   656 

   657     validateElement(XsdTagScope::Import);

   658 

   659     // parse attributes

   660     QString importNamespace;

   661     if (hasAttribute(QString::fromLatin1("namespace"))) {

   662         importNamespace = readAttribute(QString::fromLatin1("namespace"));

   663         if (importNamespace == m_targetNamespace) {

   664             error(QtXmlPatterns::tr("%1 element is not allowed to have the same %2 attribute value as the target namespace %3.")

   665                                    .arg(formatElement("import"))

   666                                    .arg(formatAttribute("namespace"))

   667                                    .arg(formatURI(m_targetNamespace)));

   668             return;

   669         }

   670     } else {

   671         if (m_targetNamespace.isEmpty()) {

   672             error(QtXmlPatterns::tr("%1 element without %2 attribute is not allowed inside schema without target namespace.")

   673                                    .arg(formatElement("import"))

   674                                    .arg(formatAttribute("namespace")));

   675             return;

   676         }

   677     }

   678 

   679     if (hasAttribute(QString::fromLatin1("schemaLocation"))) {

   680         const QString schemaLocation = readAttribute(QString::fromLatin1("schemaLocation"));

   681 

   682         QUrl url(schemaLocation);

   683         if (url.isRelative()) {

   684             Q_ASSERT(m_documentURI.isValid());

   685 

   686             url = m_documentURI.resolved(url);

   687         }

   688 

   689         if (m_importedSchemas.contains(url)) {

   690             // we have imported that file already, according to the schema spec we are

   691             // allowed to silently skip it.

   692         } else {

   693             m_importedSchemas.insert(url);

   694 

   695             // as it is possible that well known schemas (e.g. XSD for XML) are only referenced by

   696             // namespace we should add it as well

   697             m_importedSchemas.insert(importNamespace);

   698 

   699             AutoPtr<QNetworkReply> reply(AccelTreeResourceLoader::load(url, m_context->networkAccessManager(),

   700                                                                        m_context, AccelTreeResourceLoader::ContinueOnError));

   701             if (reply) {

   702                 // parse the included schema by a different parser but with the same context

   703                 XsdSchemaParser parser(m_context, m_parserContext, reply.data());

   704                 parser.setDocumentURI(url);

   705                 parser.setTargetNamespace(importNamespace);

   706                 parser.setIncludedSchemas(m_includedSchemas);

   707                 parser.setImportedSchemas(m_importedSchemas);

   708                 parser.setRedefinedSchemas(m_redefinedSchemas);

   709                 if (!parser.parse(XsdSchemaParser::ImportParser)) {

   710                     return;

   711                 } else {

   712                     // add indirectly loaded schemas to the list of already loaded ones

   713                     addIncludedSchemas(parser.m_includedSchemas);

   714                     addImportedSchemas(parser.m_importedSchemas);

   715                     addRedefinedSchemas(parser.m_redefinedSchemas);

   716                 }

   717             }

   718         }

   719     } else {

   720         // check whether it is a known namespace we have a builtin schema for

   721         if (!importNamespace.isEmpty()) {

   722             if (!m_importedSchemas.contains(importNamespace)) {

   723                 m_importedSchemas.insert(importNamespace);

   724 

   725                 QFile file(QString::fromLatin1(":") + importNamespace);

   726                 if (file.open(QIODevice::ReadOnly)) {

   727                     XsdSchemaParser parser(m_context, m_parserContext, &file);

   728                     parser.setDocumentURI(importNamespace);

   729                     parser.setTargetNamespace(importNamespace);

   730                     parser.setIncludedSchemas(m_includedSchemas);

   731                     parser.setImportedSchemas(m_importedSchemas);

   732                     parser.setRedefinedSchemas(m_redefinedSchemas);

   733                     if (!parser.parse(XsdSchemaParser::ImportParser)) {

   734                         return;

   735                     } else {

   736                         // add indirectly loaded schemas to the list of already loaded ones

   737                         addIncludedSchemas(parser.m_includedSchemas);

   738                         addImportedSchemas(parser.m_importedSchemas);

   739                         addRedefinedSchemas(parser.m_redefinedSchemas);

   740                     }

   741                 }

   742             }

   743         } else {

   744             // we don't import anything... that is valid according to the schema

   745         }

   746     }

   747 

   748     validateIdAttribute("import");

   749 

   750     TagValidationHandler tagValidator(XsdTagScope::Import, this, m_namePool);

   751 

   752     while (!atEnd()) {

   753         readNext();

   754 

   755         if (isEndElement())

   756             break;

   757 

   758         if (isStartElement()) {

   759             const XsdSchemaToken::NodeName token = XsdSchemaToken::toToken(name());

   760             const XsdSchemaToken::NodeName namespaceToken = XsdSchemaToken::toToken(namespaceUri());

   761 

   762             tagValidator.validate(token);

   763 

   764             if (isSchemaTag(XsdSchemaToken::Annotation, token, namespaceToken)) {

   765                 const XsdAnnotation::Ptr annotation = parseAnnotation();

   766                 m_schema->addAnnotation(annotation);

   767             } else {

   768                 parseUnknown();

   769             }

   770         }

   771     }

   772 

   773     tagValidator.finalize();

   774 }

   775 

   776 void XsdSchemaParser::parseRedefine()

   777 {

   778     Q_ASSERT(isStartElement() && XsdSchemaToken::toToken(name()) == XsdSchemaToken::Redefine &&

   779                                  XsdSchemaToken::toToken(namespaceUri()) == XsdSchemaToken::XML_NS_SCHEMA_URI);

   780 

   781     validateElement(XsdTagScope::Redefine);

   782 

   783     // parse attributes

   784     validateIdAttribute("redefine");

   785 

   786     const QString schemaLocation = readAttribute(QString::fromLatin1("schemaLocation"));

   787 

   788     TagValidationHandler tagValidator(XsdTagScope::Redefine, this, m_namePool);

   789 

   790     XsdSimpleType::List redefinedSimpleTypes;

   791     XsdComplexType::List redefinedComplexTypes;

   792     XsdModelGroup::List redefinedGroups;

   793     XsdAttributeGroup::List redefinedAttributeGroups;

   794 

   795     while (!atEnd()) {

   796         readNext();

   797 

   798         if (isEndElement())

   799             break;

   800 

   801         if (isStartElement()) {

   802             const XsdSchemaToken::NodeName token = XsdSchemaToken::toToken(name());

   803             const XsdSchemaToken::NodeName namespaceToken = XsdSchemaToken::toToken(namespaceUri());

   804 

   805             tagValidator.validate(token);

   806 

   807             if (isSchemaTag(XsdSchemaToken::Annotation, token, namespaceToken)) {

   808                 const XsdAnnotation::Ptr annotation = parseAnnotation();

   809                 m_schema->addAnnotation(annotation);

   810             } else if (isSchemaTag(XsdSchemaToken::SimpleType, token, namespaceToken)) {

   811                 const XsdSimpleType::Ptr type = parseGlobalSimpleType();

   812                 redefinedSimpleTypes.append(type);

   813 

   814                 const QXmlName baseTypeName = m_parserContext->resolver()->baseTypeNameOfType(type);

   815                 if (baseTypeName != type->name(m_namePool)) {

   816                     error(QString::fromLatin1("redefined simple type %1 must have itself as base type").arg(formatType(m_namePool, type)));

   817                     return;

   818                 }

   819             } else if (isSchemaTag(XsdSchemaToken::ComplexType, token, namespaceToken)) {

   820                 const XsdComplexType::Ptr type = parseGlobalComplexType();

   821                 redefinedComplexTypes.append(type);

   822 

   823                 // @see http://www.w3.org/TR/xmlschema11-1/#src-redefine

   824 

   825                 // 5

   826                 const QXmlName baseTypeName = m_parserContext->resolver()->baseTypeNameOfType(type);

   827                 if (baseTypeName != type->name(m_namePool)) {

   828                     error(QString::fromLatin1("redefined complex type %1 must have itself as base type").arg(formatType(m_namePool, type)));

   829                     return;

   830                 }

   831             } else if (isSchemaTag(XsdSchemaToken::Group, token, namespaceToken)) {

   832                 const XsdModelGroup::Ptr group = parseNamedGroup();

   833                 redefinedGroups.append(group);

   834             } else if (isSchemaTag(XsdSchemaToken::AttributeGroup, token, namespaceToken)) {

   835                 const XsdAttributeGroup::Ptr group = parseNamedAttributeGroup();

   836                 redefinedAttributeGroups.append(group);

   837 

   838             } else {

   839                 parseUnknown();

   840             }

   841         }

   842     }

   843 

   844     bool locationMustResolve = false;

   845     if (!redefinedSimpleTypes.isEmpty() || !redefinedComplexTypes.isEmpty() ||

   846         !redefinedGroups.isEmpty() || !redefinedAttributeGroups.isEmpty()) {

   847         locationMustResolve = true;

   848     }

   849 

   850     QUrl url(schemaLocation);

   851     if (url.isRelative()) {

   852         Q_ASSERT(m_documentURI.isValid());

   853 

   854         url = m_documentURI.resolved(url);

   855     }

   856 

   857     // we parse the schema given in the redefine tag into its own context

   858     const XsdSchemaParserContext::Ptr redefinedContext(new XsdSchemaParserContext(m_namePool, m_context));

   859 

   860     if (m_redefinedSchemas.contains(url)) {

   861         // we have redefined that file already, according to the schema spec we are

   862         // allowed to silently skip it.

   863     } else {

   864         m_redefinedSchemas.insert(url);

   865         QNetworkReply *reply = AccelTreeResourceLoader::load(url, m_context->networkAccessManager(),

   866                                                              m_context,

   867                                                              (locationMustResolve ? AccelTreeResourceLoader::FailOnError : AccelTreeResourceLoader::ContinueOnError));

   868         if (reply) {

   869             // parse the included schema by a different parser but with the same context

   870             XsdSchemaParser parser(m_context, redefinedContext, reply);

   871             parser.setDocumentURI(url);

   872             parser.setTargetNamespaceExtended(m_targetNamespace);

   873             parser.setIncludedSchemas(m_includedSchemas);

   874             parser.setImportedSchemas(m_importedSchemas);

   875             parser.setRedefinedSchemas(m_redefinedSchemas);

   876             if (!parser.parse(XsdSchemaParser::RedefineParser)) {

   877                 return;

   878             } else {

   879                 // add indirectly loaded schemas to the list of already loaded ones

   880                 addIncludedSchemas(parser.m_includedSchemas);

   881                 addImportedSchemas(parser.m_importedSchemas);

   882                 addRedefinedSchemas(parser.m_redefinedSchemas);

   883             }

   884 

   885             delete reply;

   886         }

   887     }

   888 

   889     XsdSimpleType::List contextSimpleTypes = redefinedContext->schema()->simpleTypes();

   890     XsdComplexType::List contextComplexTypes = redefinedContext->schema()->complexTypes();

   891     XsdModelGroup::List contextGroups = redefinedContext->schema()->elementGroups();

   892     XsdAttributeGroup::List contextAttributeGroups = redefinedContext->schema()->attributeGroups();

   893 

   894     // now we do the actual redefinition:

   895 

   896     // iterate over all redefined simple types

   897     for (int i = 0; i < redefinedSimpleTypes.count(); ++i) {

   898         XsdSimpleType::Ptr redefinedType = redefinedSimpleTypes.at(i);

   899 

   900         //TODONEXT: validation

   901 

   902         // search the definition they override in the context types

   903         bool found = false;

   904         for (int j = 0; j < contextSimpleTypes.count(); ++j) {

   905             XsdSimpleType::Ptr contextType = contextSimpleTypes.at(j);

   906 

   907             if (redefinedType->name(m_namePool) == contextType->name(m_namePool)) { // we found the right type

   908                 found = true;

   909 

   910                 // 1) set name of context type to empty name

   911                 contextType->setName(m_parserContext->createAnonymousName(QString()));

   912 

   913                 // 2) set the context type as base type for the redefined type

   914                 redefinedType->setWxsSuperType(contextType);

   915 

   916                 // 3) remove the base type resolving job from the resolver as

   917                 //    we have set the base type here explicitely

   918                 m_parserContext->resolver()->removeSimpleRestrictionBase(redefinedType);

   919 

   920                 // 4) add the redefined type to the schema

   921                 addType(redefinedType);

   922 

   923                 // 5) add the context type as anonymous type, so the resolver

   924                 //    can resolve it further.

   925                 addAnonymousType(contextType);

   926 

   927                 // 6) remove the context type from the list

   928                 contextSimpleTypes.removeAt(j);

   929 

   930                 break;

   931             }

   932         }

   933 

   934         if (!found) {

   935             error(QString::fromLatin1("no matching type found to redefine simple type %1").arg(formatType(m_namePool, redefinedType)));

   936             return;

   937         }

   938     }

   939 

   940     // add all remaining context simple types to the schema

   941     for (int i = 0; i < contextSimpleTypes.count(); ++i) {

   942         addType(contextSimpleTypes.at(i));

   943     }

   944 

   945     // iterate over all redefined complex types

   946     for (int i = 0; i < redefinedComplexTypes.count(); ++i) {

   947         XsdComplexType::Ptr redefinedType = redefinedComplexTypes.at(i);

   948 

   949         //TODONEXT: validation

   950 

   951         // search the definition they override in the context types

   952         bool found = false;

   953         for (int j = 0; j < contextComplexTypes.count(); ++j) {

   954             XsdComplexType::Ptr contextType = contextComplexTypes.at(j);

   955 

   956             if (redefinedType->name(m_namePool) == contextType->name(m_namePool)) { // we found the right type

   957                 found = true;

   958 

   959                 // 1) set name of context type to empty name

   960                 contextType->setName(m_parserContext->createAnonymousName(QString()));

   961 

   962                 // 2) set the context type as base type for the redefined type

   963                 redefinedType->setWxsSuperType(contextType);

   964 

   965                 // 3) remove the base type resolving job from the resolver as

   966                 //    we have set the base type here explicitely

   967                 m_parserContext->resolver()->removeComplexBaseType(redefinedType);

   968 

   969                 // 4) add the redefined type to the schema

   970                 addType(redefinedType);

   971 

   972                 // 5) add the context type as anonymous type, so the resolver

   973                 //    can resolve its attribute uses etc.

   974                 addAnonymousType(contextType);

   975 

   976                 // 6) remove the context type from the list

   977                 contextComplexTypes.removeAt(j);

   978 

   979                 break;

   980             }

   981         }

   982 

   983         if (!found) {

   984             error(QString::fromLatin1("no matching type found to redefine complex type %1").arg(formatType(m_namePool, redefinedType)));

   985             return;

   986         }

   987     }

   988 

   989     // iterate over all redefined element groups

   990     for (int i = 0; i < redefinedGroups.count(); ++i) {

   991         const XsdModelGroup::Ptr group(redefinedGroups.at(i));

   992 

   993         // @see http://www.w3.org/TR/xmlschema11-1/#src-redefine

   994 

   995         // 6

   996         const XsdParticle::List particles = collectGroupRef(group);

   997         XsdParticle::Ptr referencedParticle;

   998         int sameNameCounter = 0;

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

  1000             const XsdReference::Ptr ref(particles.at(i)->term());

  1001             if (ref->referenceName() == group->name(m_namePool)) {

  1002                 referencedParticle = particles.at(i);

  1003 

  1004                 if (referencedParticle->minimumOccurs() != 1 || referencedParticle->maximumOccurs() != 1 || referencedParticle->maximumOccursUnbounded()) { // 6.1.2

  1005                     error(QString::fromLatin1("redefined group %1 can not contain reference to itself with minOccurs or maxOccurs != 1").arg(formatKeyword(group->displayName(m_namePool))));

  1006                     return;

  1007                 }

  1008                 sameNameCounter++;

  1009             }

  1010         }

  1011 

  1012         // 6.1.1

  1013         if (sameNameCounter > 1) {

  1014             error(QString::fromLatin1("redefined group %1 can not contain multiple references to itself").arg(formatKeyword(group->displayName(m_namePool))));

  1015             return;

  1016         }

  1017 

  1018         // search the group definition in the included schema (S2)

  1019         XsdModelGroup::Ptr contextGroup;

  1020         for (int j = 0; j < contextGroups.count(); ++j) {

  1021             if (group->name(m_namePool) == contextGroups.at(j)->name(m_namePool)) {

  1022                 contextGroup = contextGroups.at(j);

  1023                 break;

  1024             }

  1025         }

  1026 

  1027         if (!contextGroup) { // 6.2.1

  1028             error(QString::fromLatin1("redefined group %1 has no occurrence in included schema").arg(formatKeyword(group->displayName(m_namePool))));

  1029             return;

  1030         }

  1031 

  1032         if (sameNameCounter == 1) {

  1033             // there was a self reference in the redefined group, so use the

  1034             // group from the included schema

  1035 

  1036             // set a anonymous name to the group of the included schema

  1037             contextGroup->setName(m_parserContext->createAnonymousName(m_namePool->stringForNamespace(contextGroup->name(m_namePool).namespaceURI())));

  1038 

  1039             // replace the self-reference with the group from the included schema

  1040             referencedParticle->setTerm(contextGroup);

  1041 

  1042             addElementGroup(group);

  1043 

  1044             addElementGroup(contextGroup);

  1045             contextGroups.removeAll(contextGroup);

  1046         } else {

  1047             // there was no self reference in the redefined group

  1048 

  1049             // just add the redefined group...

  1050             addElementGroup(group);

  1051 

  1052             // we have to add them, otherwise it is not resolved and we can't validate it later

  1053             contextGroup->setName(m_parserContext->createAnonymousName(m_namePool->stringForNamespace(contextGroup->name(m_namePool).namespaceURI())));

  1054             addElementGroup(contextGroup);

  1055 

  1056             m_schemaResolver->addRedefinedGroups(group, contextGroup);

  1057 

  1058             // ...and forget about the group from the included schema

  1059             contextGroups.removeAll(contextGroup);

  1060         }

  1061     }

  1062 

  1063     // iterate over all redefined attribute groups

  1064     for (int i = 0; i < redefinedAttributeGroups.count(); ++i) {

  1065         const XsdAttributeGroup::Ptr group(redefinedAttributeGroups.at(i));

  1066 

  1067         // @see http://www.w3.org/TR/xmlschema11-1/#src-redefine

  1068 

  1069         // 7

  1070 

  1071         // 7.1

  1072         int sameNameCounter = 0;

  1073         for (int j = 0; j < group->attributeUses().count(); ++j) {

  1074             const XsdAttributeUse::Ptr attributeUse(group->attributeUses().at(j));

  1075             if (attributeUse->isReference()) {

  1076                 const XsdAttributeReference::Ptr reference(attributeUse);

  1077                 if (reference->type() == XsdAttributeReference::AttributeGroup) {

  1078                     if (group->name(m_namePool) == reference->referenceName())

  1079                         sameNameCounter++;

  1080                 }

  1081             }

  1082         }

  1083         if (sameNameCounter > 1) {

  1084             error(QString::fromLatin1("redefined attribute group %1 can not contain multiple references to itself").arg(formatKeyword(group->displayName(m_namePool))));

  1085             return;

  1086         }

  1087 

  1088         // search the attribute group definition in the included schema (S2)

  1089         XsdAttributeGroup::Ptr baseGroup;

  1090         for (int j = 0; j < contextAttributeGroups.count(); ++j) {

  1091             const XsdAttributeGroup::Ptr contextGroup(contextAttributeGroups.at(j));

  1092             if (group->name(m_namePool) == contextGroup->name(m_namePool)) {

  1093                 baseGroup = contextGroup;

  1094                 break;

  1095             }

  1096         }

  1097 

  1098         if (!baseGroup) { // 7.2.1

  1099             error(QString::fromLatin1("redefined attribute group %1 has no occurrence in included schema").arg(formatKeyword(group->displayName(m_namePool))));

  1100             return;

  1101         }

  1102 

  1103         if (sameNameCounter == 1) {

  1104 

  1105             // first set an anonymous name to the attribute group from the included

  1106             // schema

  1107             baseGroup->setName(m_parserContext->createAnonymousName(m_namePool->stringForNamespace(baseGroup->name(m_namePool).namespaceURI())));

  1108 

  1109             // iterate over the attribute uses of the redefined attribute group

  1110             // and replace the self-reference with the attribute group from the

  1111             // included schema

  1112             for (int j = 0; j < group->attributeUses().count(); ++j) {

  1113                 const XsdAttributeUse::Ptr attributeUse(group->attributeUses().at(j));

  1114                 if (attributeUse->isReference()) {

  1115                     const XsdAttributeReference::Ptr reference(attributeUse);

  1116                     if (reference->type() == XsdAttributeReference::AttributeGroup) {

  1117                         if (group->name(m_namePool) == reference->referenceName()) {

  1118                             reference->setReferenceName(baseGroup->name(m_namePool));

  1119                             break;

  1120                         }

  1121                     }

  1122                 }

  1123             }

  1124 

  1125             // add both groups to the target schema

  1126             addAttributeGroup(baseGroup);

  1127             addAttributeGroup(group);

  1128 

  1129             contextAttributeGroups.removeAll(baseGroup);

  1130         }

  1131 

  1132         if (sameNameCounter == 0) { // 7.2

  1133 

  1134             // we have to add them, otherwise it is not resolved and we can't validate it later

  1135             baseGroup->setName(m_parserContext->createAnonymousName(m_namePool->stringForNamespace(baseGroup->name(m_namePool).namespaceURI())));