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

     2 **

     3 ** Copyright (C) 2009 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::setIncludedSchemas(const NamespaceSet &schemas)

   268 {

   269     m_includedSchemas = schemas;

   270 }

   271 

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

   273 {

   274     m_importedSchemas = schemas;

   275 }

   276 

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

   278 {

   279     m_redefinedSchemas = schemas;

   280 }

   281 

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

   283 {

   284     m_targetNamespace = targetNamespace;

   285 }

   286 

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

   288 {

   289     m_targetNamespace = targetNamespace;

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

   291 }

   292 

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

   294 {

   295     m_documentURI = uri;

   296 

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

   298     m_includedSchemas.insert(uri);

   299     m_importedSchemas.insert(uri);

   300 }

   301 

   302 QUrl XsdSchemaParser::documentURI() const

   303 {

   304     return m_documentURI;

   305 }

   306 

   307 bool XsdSchemaParser::isAnyAttributeAllowed() const

   308 {

   309     return false;

   310 }

   311 

   312 bool XsdSchemaParser::parse(ParserType parserType)

   313 {

   314     m_componentLocationHash.clear();

   315 

   316     while (!atEnd()) {

   317         readNext();

   318 

   319         if (isStartElement()) {

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

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

   322 

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

   324                 parseSchema(parserType);

   325             } else {

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

   327             }

   328         }

   329     }

   330 

   331     m_schemaResolver->addComponentLocationHash(m_componentLocationHash);

   332     m_schemaResolver->setDefaultOpenContent(m_defaultOpenContent, m_defaultOpenContentAppliesToEmpty);

   333 

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

   335         error(errorString());

   336 

   337     return true;

   338 }

   339 

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

   341 {

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

   343 }

   344 

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

   346 {

   347     if (type) {

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

   349                                .arg(formatAttribute(attributeName))

   350                                .arg(formatElement(elementName))

   351                                .arg(formatData(value))

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

   353     } else {

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

   355                                .arg(formatAttribute(attributeName))

   356                                .arg(formatElement(elementName))

   357                                .arg(formatData(value)));

   358     }

   359 }

   360 

   361 void XsdSchemaParser::parseSchema(ParserType parserType)

   362 {

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

   364 

   365     validateElement(XsdTagScope::Schema);

   366 

   367     // parse attributes

   368 

   369     if (parserType == TopLevelParser) {

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

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

   372         }

   373     } else if (parserType == IncludeParser) {

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

   375 

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

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

   378 

   379             if (m_targetNamespace != targetNamespace) {

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

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

   382                 return;

   383             }

   384         }

   385     } else if (parserType == ImportParser) {

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

   387 

   388         QString targetNamespace;

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

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

   391         }

   392 

   393         if (m_targetNamespace != targetNamespace) {

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

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

   396             return;

   397         }

   398     } else if (parserType == RedefineParser) {

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

   400 

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

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

   403 

   404             if (m_targetNamespace != targetNamespace) {

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

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

   407                 return;

   408             }

   409         }

   410     }

   411 

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

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

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

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

   416             return;

   417         }

   418 

   419         m_attributeFormDefault = value;

   420     } else {

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

   422     }

   423 

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

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

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

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

   428             return;

   429         }

   430 

   431         m_elementFormDefault = value;

   432     } else {

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

   434     }

   435 

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

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

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

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

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

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

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

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

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

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

   446                 return;

   447             }

   448         }

   449 

   450         m_blockDefault = blockDefault;

   451     }

   452 

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

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

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

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

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

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

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

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

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

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

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

   464                 return;

   465             }

   466         }

   467 

   468         m_finalDefault = finalDefault;

   469     }

   470 

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

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

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

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

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

   476             if (!isValidUri(xpathDefaultNamespace)) {

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

   478                 return;

   479             }

   480         }

   481         m_xpathDefaultNamespace = xpathDefaultNamespace;

   482     } else {

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

   484     }

   485 

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

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

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

   489     }

   490 

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

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

   493     }

   494 

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

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

   497 

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

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

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

   501             return;

   502         }

   503     }

   504 

   505     validateIdAttribute("schema");

   506 

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

   508 

   509     while (!atEnd()) {

   510         readNext();

   511 

   512         if (isEndElement())

   513             break;

   514 

   515         if (isStartElement()) {

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

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

   518 

   519             tagValidator.validate(token);

   520 

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

   522                 parseInclude();

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

   524                 parseImport();

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

   526                 parseRedefine();

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

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

   529                 m_schema->addAnnotation(annotation);

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

   531                 parseDefaultOpenContent();

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

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

   534                 addType(type);

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

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

   537                 addType(type);

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

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

   540                 addElementGroup(group);

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

   542                 XsdAttributeGroup::Ptr attributeGroup = parseNamedAttributeGroup();

   543                 addAttributeGroup(attributeGroup);

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

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

   546                 addElement(element);

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

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

   549                 addAttribute(attribute);

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

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

   552                 addNotation(notation);

   553             } else {

   554                 parseUnknown();

   555             }

   556         }

   557     }

   558 

   559     tagValidator.finalize();

   560 

   561     m_schema->setTargetNamespace(m_targetNamespace);

   562 }

   563 

   564 void XsdSchemaParser::parseInclude()

   565 {

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

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

   568 

   569     validateElement(XsdTagScope::Include);

   570 

   571     // parse attributes

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

   573 

   574     QUrl url(schemaLocation);

   575     if (url.isRelative()) {

   576         Q_ASSERT(m_documentURI.isValid());

   577 

   578         url = m_documentURI.resolved(url);

   579     }

   580 

   581     if (m_includedSchemas.contains(url)) {

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

   583         // allowed to silently skip it.

   584     } else {

   585         m_includedSchemas.insert(url);

   586 

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

   588                                                                          m_context, AccelTreeResourceLoader::ContinueOnError));

   589         if (reply) {

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

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

   592             parser.setDocumentURI(url);

   593             parser.setTargetNamespaceExtended(m_targetNamespace);

   594             parser.setIncludedSchemas(m_includedSchemas);

   595             parser.setImportedSchemas(m_importedSchemas);

   596             parser.setRedefinedSchemas(m_redefinedSchemas);

   597             if (!parser.parse(XsdSchemaParser::IncludeParser))

   598                 return;

   599         }

   600     }

   601 

   602     validateIdAttribute("include");

   603 

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

   605 

   606     while (!atEnd()) {

   607         readNext();

   608 

   609         if (isEndElement())

   610             break;

   611 

   612         if (isStartElement()) {

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

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

   615 

   616             tagValidator.validate(token);

   617 

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

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

   620                 m_schema->addAnnotation(annotation);

   621             } else {

   622                 parseUnknown();

   623             }

   624         }

   625     }

   626 

   627     tagValidator.finalize();

   628 }

   629 

   630 void XsdSchemaParser::parseImport()

   631 {

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

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

   634 

   635     validateElement(XsdTagScope::Import);

   636 

   637     // parse attributes

   638     QString importNamespace;

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

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

   641         if (importNamespace == m_targetNamespace) {

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

   643                                    .arg(formatElement("import"))

   644                                    .arg(formatAttribute("namespace"))

   645                                    .arg(formatURI(m_targetNamespace)));

   646             return;

   647         }

   648     } else {

   649         if (m_targetNamespace.isEmpty()) {

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

   651                                    .arg(formatElement("import"))

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

   653             return;

   654         }

   655     }

   656 

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

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

   659 

   660         QUrl url(schemaLocation);

   661         if (url.isRelative()) {

   662             Q_ASSERT(m_documentURI.isValid());

   663 

   664             url = m_documentURI.resolved(url);

   665         }

   666 

   667         if (m_importedSchemas.contains(url)) {

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

   669             // allowed to silently skip it.

   670         } else {

   671             m_importedSchemas.insert(url);

   672 

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

   674             // namespace we should add it as well

   675             m_importedSchemas.insert(importNamespace);

   676 

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

   678                                                                        m_context, AccelTreeResourceLoader::ContinueOnError));

   679             if (reply) {

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

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

   682                 parser.setDocumentURI(url);

   683                 parser.setTargetNamespace(importNamespace);

   684                 parser.setIncludedSchemas(m_includedSchemas);

   685                 parser.setImportedSchemas(m_importedSchemas);

   686                 parser.setRedefinedSchemas(m_redefinedSchemas);

   687                 if (!parser.parse(XsdSchemaParser::ImportParser))

   688                     return;

   689             }

   690         }

   691     } else {

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

   693         if (!importNamespace.isEmpty()) {

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

   695                 m_importedSchemas.insert(importNamespace);

   696 

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

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

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

   700                     parser.setDocumentURI(importNamespace);

   701                     parser.setTargetNamespace(importNamespace);

   702                     parser.setIncludedSchemas(m_includedSchemas);

   703                     parser.setImportedSchemas(m_importedSchemas);

   704                     parser.setRedefinedSchemas(m_redefinedSchemas);

   705                     if (!parser.parse(XsdSchemaParser::ImportParser))

   706                         return;

   707                 }

   708             }

   709         } else {

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

   711         }

   712     }

   713 

   714     validateIdAttribute("import");

   715 

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

   717 

   718     while (!atEnd()) {

   719         readNext();

   720 

   721         if (isEndElement())

   722             break;

   723 

   724         if (isStartElement()) {

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

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

   727 

   728             tagValidator.validate(token);

   729 

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

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

   732                 m_schema->addAnnotation(annotation);

   733             } else {

   734                 parseUnknown();

   735             }

   736         }

   737     }

   738 

   739     tagValidator.finalize();

   740 }

   741 

   742 void XsdSchemaParser::parseRedefine()

   743 {

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

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

   746 

   747     validateElement(XsdTagScope::Redefine);

   748 

   749     // parse attributes

   750     validateIdAttribute("redefine");

   751 

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

   753 

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

   755 

   756     XsdSimpleType::List redefinedSimpleTypes;

   757     XsdComplexType::List redefinedComplexTypes;

   758     XsdModelGroup::List redefinedGroups;

   759     XsdAttributeGroup::List redefinedAttributeGroups;

   760 

   761     while (!atEnd()) {

   762         readNext();

   763 

   764         if (isEndElement())

   765             break;

   766 

   767         if (isStartElement()) {

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

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

   770 

   771             tagValidator.validate(token);

   772 

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

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

   775                 m_schema->addAnnotation(annotation);

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

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

   778                 redefinedSimpleTypes.append(type);

   779 

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

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

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

   783                     return;

   784                 }

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

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

   787                 redefinedComplexTypes.append(type);

   788 

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

   790 

   791                 // 5

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

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

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

   795                     return;

   796                 }

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

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

   799                 redefinedGroups.append(group);

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

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

   802                 redefinedAttributeGroups.append(group);

   803 

   804             } else {

   805                 parseUnknown();

   806             }

   807         }

   808     }

   809 

   810     bool locationMustResolve = false;

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

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

   813         locationMustResolve = true;

   814     }

   815 

   816     QUrl url(schemaLocation);

   817     if (url.isRelative()) {

   818         Q_ASSERT(m_documentURI.isValid());

   819 

   820         url = m_documentURI.resolved(url);

   821     }

   822 

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

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

   825 

   826     if (m_redefinedSchemas.contains(url)) {

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

   828         // allowed to silently skip it.

   829     } else {

   830         m_redefinedSchemas.insert(url);

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

   832                                                              m_context,

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

   834         if (reply) {

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

   836             XsdSchemaParser parser(m_context, redefinedContext, reply);

   837             parser.setDocumentURI(url);

   838             parser.setTargetNamespaceExtended(m_targetNamespace);

   839             parser.setIncludedSchemas(m_includedSchemas);

   840             parser.setImportedSchemas(m_importedSchemas);

   841             parser.setRedefinedSchemas(m_redefinedSchemas);

   842             if (!parser.parse(XsdSchemaParser::RedefineParser))

   843                 return;

   844 

   845             delete reply;

   846         }

   847     }

   848 

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

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

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

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

   853 

   854     // now we do the actual redefinition:

   855 

   856     // iterate over all redefined simple types

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

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

   859 

   860         //TODONEXT: validation

   861 

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

   863         bool found = false;

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

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

   866 

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

   868                 found = true;

   869 

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

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

   872 

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

   874                 redefinedType->setWxsSuperType(contextType);

   875 

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

   877                 //    we have set the base type here explicitely

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

   879 

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

   881                 addType(redefinedType);

   882 

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

   884                 //    can resolve it further.

   885                 addAnonymousType(contextType);

   886 

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

   888                 contextSimpleTypes.removeAt(j);

   889 

   890                 break;

   891             }

   892         }

   893 

   894         if (!found) {

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

   896             return;

   897         }

   898     }

   899 

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

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

   902         addType(contextSimpleTypes.at(i));

   903     }

   904 

   905     // iterate over all redefined complex types

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

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

   908 

   909         //TODONEXT: validation

   910 

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

   912         bool found = false;

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

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

   915 

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

   917                 found = true;

   918 

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

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

   921 

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

   923                 redefinedType->setWxsSuperType(contextType);

   924 

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

   926                 //    we have set the base type here explicitely

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

   928 

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

   930                 addType(redefinedType);

   931 

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

   933                 //    can resolve its attribute uses etc.

   934                 addAnonymousType(contextType);

   935 

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

   937                 contextComplexTypes.removeAt(j);

   938 

   939                 break;

   940             }

   941         }

   942 

   943         if (!found) {

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

   945             return;

   946         }

   947     }

   948 

   949     // iterate over all redefined element groups

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

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

   952 

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

   954 

   955         // 6

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

   957         XsdParticle::Ptr referencedParticle;

   958         int sameNameCounter = 0;

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

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

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

   962                 referencedParticle = particles.at(i);

   963 

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

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

   966                     return;

   967                 }

   968                 sameNameCounter++;

   969             }

   970         }

   971 

   972         // 6.1.1

   973         if (sameNameCounter > 1) {

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

   975             return;

   976         }

   977 

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

   979         XsdModelGroup::Ptr contextGroup;

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

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

   982                 contextGroup = contextGroups.at(j);

   983                 break;

   984             }

   985         }

   986 

   987         if (!contextGroup) { // 6.2.1

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

   989             return;

   990         }

   991 

   992         if (sameNameCounter == 1) {

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

   994             // group from the included schema

   995 

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

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

   998 

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

  1000             referencedParticle->setTerm(contextGroup);

  1001 

  1002             addElementGroup(group);

  1003 

  1004             addElementGroup(contextGroup);

  1005             contextGroups.removeAll(contextGroup);

  1006         } else {

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

  1008 

  1009             // just add the redefined group...

  1010             addElementGroup(group);

  1011 

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

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

  1014             addElementGroup(contextGroup);

  1015 

  1016             m_schemaResolver->addRedefinedGroups(group, contextGroup);

  1017 

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

  1019             contextGroups.removeAll(contextGroup);

  1020         }

  1021     }

  1022 

  1023     // iterate over all redefined attribute groups

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

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

  1026 

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

  1028 

  1029         // 7

  1030 

  1031         // 7.1

  1032         int sameNameCounter = 0;

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

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

  1035             if (attributeUse->isReference()) {

  1036                 const XsdAttributeReference::Ptr reference(attributeUse);

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

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

  1039                         sameNameCounter++;

  1040                 }

  1041             }

  1042         }

  1043         if (sameNameCounter > 1) {

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

  1045             return;

  1046         }

  1047 

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

  1049         XsdAttributeGroup::Ptr baseGroup;

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

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

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

  1053                 baseGroup = contextGroup;

  1054                 break;

  1055             }

  1056         }

  1057 

  1058         if (!baseGroup) { // 7.2.1

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

  1060             return;

  1061         }

  1062 

  1063         if (sameNameCounter == 1) {

  1064 

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

  1066             // schema

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

  1068 

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

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

  1071             // included schema

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

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

  1074                 if (attributeUse->isReference()) {

  1075                     const XsdAttributeReference::Ptr reference(attributeUse);

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

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

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

  1079                             break;

  1080                         }

  1081                     }

  1082                 }

  1083             }

  1084 

  1085             // add both groups to the target schema

  1086             addAttributeGroup(baseGroup);

  1087             addAttributeGroup(group);

  1088 

  1089             contextAttributeGroups.removeAll(baseGroup);

  1090         }

  1091 

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

  1093 

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

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

  1096             addAttributeGroup(baseGroup);

  1097 

  1098             m_schemaResolver->addRedefinedAttributeGroups(group, baseGroup);

  1099 

  1100             // just add the redefined attribute group to the target schema...

  1101             addAttributeGroup(group);

  1102 

  1103             // ... and forget about the one from the included schema

  1104             contextAttributeGroups.removeAll(baseGroup);

  1105         }

  1106     }

  1107 

  1108     // add all remaining context complex types to the schema

  1109     for (int i = 0; i < contextComplexTypes.count(); ++i) {

  1110         addType(contextComplexTypes.at(i));

  1111     }

  1112 

  1113     // add all remaining context element groups to the schema

  1114     for (int i = 0; i < contextGroups.count(); ++i) {

  1115         addElementGroup(contextGroups.at(i));

  1116     }

  1117 

  1118     // add all remaining context attribute groups to the schema

  1119     for (int i = 0; i < contextAttributeGroups.count(); ++i) {

  1120         addAttributeGroup(contextAttributeGroups.at(i));

  1121     }

  1122 

  1123     // copy all elements, attributes and notations

  1124     const XsdElement::List contextElements = redefinedContext->schema()->elements();

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

  1126         addElement(contextElements.at(i));

  1127     }

  1128 

  1129     const XsdAttribute::List contextAttributes = redefinedContext->schema()->attributes();

  1130     for (int i = 0; i < contextAttributes.count(); ++i) {

  1131         addAttribute(contextAttributes.at(i));

  1132     }

  1133 

  1134     const XsdNotation::List contextNotations = redefinedContext->schema()->notations();