/****************************************************************************

**

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

** All rights reserved.

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

**

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

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

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

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

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

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

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

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

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

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

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

**

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

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

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

**

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

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

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qxsdschemaparser_p.h"

#include "private/qxmlutils_p.h"

#include "qacceltreeresourceloader_p.h"

#include "qautoptr_p.h"

#include "qboolean_p.h"

#include "qcommonnamespaces_p.h"

#include "qderivedinteger_p.h"

#include "qderivedstring_p.h"

#include "qqnamevalue_p.h"

#include "qxmlquery_p.h"

#include "qxpathhelper_p.h"

#include "qxsdattributereference_p.h"

#include "qxsdreference_p.h"

#include "qxsdschematoken_p.h"

#include <QtCore/QFile>

#include <QtXmlPatterns/QXmlQuery>

QT_BEGIN_NAMESPACE

/**

 * @page schema_overview Overview

 * @section structure_and_components Structure and Components

 *

 * The schema validator code consists of 4 major components

 *

 * <dl>

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

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

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

 *      structure as C++ objects.

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

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

 *      for resolving at a later point in time.

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

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

 *

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

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

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

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

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

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

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

 *      of these groups.

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

 *

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

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

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

 *      of instance documents.</dd>

 *

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

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

 *      a valid compiled schema.</dd>

 * </dl>

 *

 * @ingroup Patternist_schema

 */

using namespace QPatternist;

namespace QPatternist

{

/**

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

 *

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

 */

class ElementNamespaceHandler

{

    public:

        /**

         * Creates a new element namespace handler object.

         *

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

         * context that contains the inherited and local namespace declarations.

         */

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

            : m_parser(parser)

        {

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

            Q_UNUSED(tag)

            m_parser->m_namespaceSupport.pushContext();

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

        }

        /**

         * Destroys the element namespace handler object.

         *

         * It destroys the local namespace context.

         */

        ~ElementNamespaceHandler()

        {

            m_parser->m_namespaceSupport.popContext();

        }

    private:

        XsdSchemaParser *m_parser;

};

/**

 * A helper class that checks for the right occurrence of

 * xml tags with the help of a DFA.

 */

class TagValidationHandler

{

    public:

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

            : m_parser(parser), m_machine(namePool)

        {

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

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

            m_machine.reset();

        }

        void validate(XsdSchemaToken::NodeName token)

        {

            if (token == XsdSchemaToken::NoKeyword) {

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

                QStringList elementNames;

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

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

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

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

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

                return;

            }

            if (!m_machine.proceed(token)) {

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

                QStringList elementNames;

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

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

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

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

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

                return;

            }

        }

        void finalize() const

        {

            if (!m_machine.inEndState()) {

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

                QStringList elementNames;

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

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

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

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

            }

        }

        private:

            XsdSchemaParser *m_parser;

            XsdStateMachine<XsdSchemaToken::NodeName> m_machine;

};

}

/**

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

 * the given unresolved @p group.

 */

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

{

    XsdParticle::List refParticles;

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

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

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

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

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

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

        }

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

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

        }

    }

    return refParticles;

}

/**

 * Helper function that works around the limited facilities of

 * QUrl/AnyURI::fromLexical to detect invalid URIs

 */

inline static bool isValidUri(const QString &string)

{

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

    if (string.isEmpty())

        return true;

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

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

        return false;

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

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

}

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

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

    , m_context(context)

    , m_parserContext(parserContext)

    , m_namePool(m_parserContext->namePool())

    , m_namespaceSupport(m_namePool)

{

    m_schema = m_parserContext->schema();

    m_schemaResolver = m_parserContext->resolver();

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

    setupStateMachines();

    setupBuiltinTypeNames();

}

void XsdSchemaParser::setIncludedSchemas(const NamespaceSet &schemas)

{

    m_includedSchemas = schemas;

}

void XsdSchemaParser::setImportedSchemas(const NamespaceSet &schemas)

{

    m_importedSchemas = schemas;

}

void XsdSchemaParser::setRedefinedSchemas(const NamespaceSet &schemas)

{

    m_redefinedSchemas = schemas;

}

void XsdSchemaParser::setTargetNamespace(const QString &targetNamespace)

{

    m_targetNamespace = targetNamespace;

}

void XsdSchemaParser::setTargetNamespaceExtended(const QString &targetNamespace)

{

    m_targetNamespace = targetNamespace;

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

}

void XsdSchemaParser::setDocumentURI(const QUrl &uri)

{

    m_documentURI = uri;

    // prevent to get included/imported/redefined twice

    m_includedSchemas.insert(uri);

    m_importedSchemas.insert(uri);

}

QUrl XsdSchemaParser::documentURI() const

{

    return m_documentURI;

}

bool XsdSchemaParser::isAnyAttributeAllowed() const

{

    return false;

}

bool XsdSchemaParser::parse(ParserType parserType)

{

    m_componentLocationHash.clear();

    while (!atEnd()) {

        readNext();

        if (isStartElement()) {

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

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

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

                parseSchema(parserType);

            } else {

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

            }

        }

    }

    m_schemaResolver->addComponentLocationHash(m_componentLocationHash);

    m_schemaResolver->setDefaultOpenContent(m_defaultOpenContent, m_defaultOpenContentAppliesToEmpty);

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

        error(errorString());

    return true;

}

void XsdSchemaParser::error(const QString &msg)

{

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

}

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

{

    if (type) {

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

                               .arg(formatAttribute(attributeName))

                               .arg(formatElement(elementName))

                               .arg(formatData(value))

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

    } else {

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

                               .arg(formatAttribute(attributeName))

                               .arg(formatElement(elementName))

                               .arg(formatData(value)));

    }

}

void XsdSchemaParser::parseSchema(ParserType parserType)

{

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

    validateElement(XsdTagScope::Schema);

    // parse attributes

    if (parserType == TopLevelParser) {

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

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

        }

    } else if (parserType == IncludeParser) {

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

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

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

            if (m_targetNamespace != targetNamespace) {

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

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

                return;

            }

        }

    } else if (parserType == ImportParser) {

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

        QString targetNamespace;

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

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

        }

        if (m_targetNamespace != targetNamespace) {

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

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

            return;

        }

    } else if (parserType == RedefineParser) {

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

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

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

            if (m_targetNamespace != targetNamespace) {

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

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

                return;

            }

        }

    }

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

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

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

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

            return;

        }

        m_attributeFormDefault = value;

    } else {

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

    }

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

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

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

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

            return;

        }

        m_elementFormDefault = value;

    } else {

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

    }

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

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

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

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

            const QString value = blockDefaultList.at(i);

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

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

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

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

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

                return;

            }

        }

        m_blockDefault = blockDefault;

    }

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

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

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

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

            const QString value = finalDefaultList.at(i);

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

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

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

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

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

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

                return;

            }

        }

        m_finalDefault = finalDefault;

    }

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

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

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

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

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

            if (!isValidUri(xpathDefaultNamespace)) {

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

                return;

            }

        }

        m_xpathDefaultNamespace = xpathDefaultNamespace;

    } else {

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

    }

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

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

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

    }

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

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

    }

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

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

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

        if (!exp.exactMatch(value)) {

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

            return;

        }

    }

    validateIdAttribute("schema");

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

    while (!atEnd()) {

        readNext();

        if (isEndElement())

            break;

        if (isStartElement()) {

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

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

            tagValidator.validate(token);

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

                parseInclude();

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

                parseImport();

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

                parseRedefine();

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

                const XsdAnnotation::Ptr annotation = parseAnnotation();