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

**

** Copyright (C) 2010 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 <QStringList>

#include "qbuiltintypes_p.h"

#include "qcommonnamespaces_p.h"

#include "qquerytransformparser_p.h"

#include "qxquerytokenizer_p.h"

#include "qpatternistlocale_p.h"

#include "qxslttokenizer_p.h"

QT_BEGIN_NAMESPACE

using namespace QPatternist;

Tokenizer::Token SingleTokenContainer::nextToken(YYLTYPE *const location)

{

    if(m_hasDelivered)

        return Tokenizer::Token(END_OF_FILE);

    else

    {

        *location = m_location;

        m_hasDelivered = true;

        return m_token;

    }

}

XSLTTokenizer::XSLTTokenizer(QIODevice *const queryDevice,

                             const QUrl &location,

                             const ReportContext::Ptr &context,

                             const NamePool::Ptr &np) : Tokenizer(location)

                                                      , MaintainingReader<XSLTTokenLookup>(createElementDescriptions(), createStandardAttributes(), context, queryDevice)

                                                      , m_location(location)

                                                      , m_namePool(np)

                                                      /* We initialize after all name constants. */

                                                      , m_validationAlternatives(createValidationAlternatives())

                                                      , m_parseInfo(0)

{

    Q_ASSERT(m_namePool);

    pushState(OutsideDocumentElement);

}

bool XSLTTokenizer::isAnyAttributeAllowed() const

{

    return m_processingMode.top() == ForwardCompatible;

}

void XSLTTokenizer::setParserContext(const ParserContext::Ptr &parseInfo)

{

    m_parseInfo = parseInfo;

}

void XSLTTokenizer::validateElement() const

{

    MaintainingReader<XSLTTokenLookup>::validateElement(currentElementName());

}

QSet<XSLTTokenizer::NodeName> XSLTTokenizer::createStandardAttributes()

{

    QSet<NodeName> retval;

    enum

    {

        ReservedForAttributes = 6

    };

    retval.reserve(6);

    retval.insert(DefaultCollation);

    retval.insert(ExcludeResultPrefixes);

    retval.insert(ExtensionElementPrefixes);

    retval.insert(UseWhen);

    retval.insert(Version);

    retval.insert(XpathDefaultNamespace);

    Q_ASSERT(retval.count() == ReservedForAttributes);

    return retval;

}

ElementDescription<XSLTTokenLookup>::Hash XSLTTokenizer::createElementDescriptions()

{

    ElementDescription<XSLTTokenLookup>::Hash result;

    enum

    {

        ReservedForElements = 40

    };

    result.reserve(ReservedForElements);

    /* xsl:apply-templates */

    {

        ElementDescription<XSLTTokenLookup> &e = result[ApplyTemplates];

        e.optionalAttributes.insert(Select);

        e.optionalAttributes.insert(Mode);

    }

    /* xsl:template */

    {

        ElementDescription<XSLTTokenLookup> &e = result[Template];

        e.optionalAttributes.insert(Match);

        e.optionalAttributes.insert(Name);

        e.optionalAttributes.insert(Mode);

        e.optionalAttributes.insert(Priority);

        e.optionalAttributes.insert(As);

    }

    /* xsl:text, xsl:choose and xsl:otherwise */

    {

        ElementDescription<XSLTTokenLookup> &e = result[Text];

        result.insert(Choose, e);

        result.insert(Otherwise, e);

    }

    /* xsl:stylesheet */

    {

        ElementDescription<XSLTTokenLookup> &e = result[Stylesheet];

        e.requiredAttributes.insert(Version);

        e.optionalAttributes.insert(Id);

        e.optionalAttributes.insert(ExtensionElementPrefixes);

        e.optionalAttributes.insert(ExcludeResultPrefixes);

        e.optionalAttributes.insert(XpathDefaultNamespace);

        e.optionalAttributes.insert(DefaultValidation);

        e.optionalAttributes.insert(DefaultCollation);

        e.optionalAttributes.insert(InputTypeAnnotations);

    }

    /* xsl:transform */

    {

        result[Transform] = result[Stylesheet];

    }

    /* xsl:value-of */

    {

        ElementDescription<XSLTTokenLookup> &e = result[ValueOf];

        e.optionalAttributes.insert(Separator);

        e.optionalAttributes.insert(Select);

    }

    /* xsl:variable */

    {

        ElementDescription<XSLTTokenLookup> &e = result[Variable];

        e.requiredAttributes.insert(Name);

        e.optionalAttributes.insert(Select);

        e.optionalAttributes.insert(As);

    }

    /* xsl:when & xsl:if */

    {

        ElementDescription<XSLTTokenLookup> &e = result[When];

        e.requiredAttributes.insert(Test);

        result.insert(If, e);

    }

    /* xsl:sequence, xsl:for-each */

    {

        ElementDescription<XSLTTokenLookup> &e = result[Sequence];

        e.requiredAttributes.insert(Select);

        result.insert(ForEach, e);

    }

    /* xsl:comment */

    {

        ElementDescription<XSLTTokenLookup> &e = result[XSLTTokenLookup::Comment];

        e.optionalAttributes.insert(Select);

    }

    /* xsl:processing-instruction */

    {

        ElementDescription<XSLTTokenLookup> &e = result[XSLTTokenLookup::ProcessingInstruction];

        e.requiredAttributes.insert(Name);

        e.optionalAttributes.insert(Select);

    }

    /* xsl:document */

    {

        ElementDescription<XSLTTokenLookup> &e = result[Document];

        e.optionalAttributes.insert(Validation);

        e.optionalAttributes.insert(Type);

    }

    /* xsl:element */

    {

        ElementDescription<XSLTTokenLookup> &e = result[Element];

        e.requiredAttributes.insert(Name);

        e.optionalAttributes.insert(Namespace);

        e.optionalAttributes.insert(InheritNamespaces);

        e.optionalAttributes.insert(UseAttributeSets);

        e.optionalAttributes.insert(Validation);

        e.optionalAttributes.insert(Type);

    }

    /* xsl:attribute */

    {

        ElementDescription<XSLTTokenLookup> &e = result[Attribute];

        e.requiredAttributes.insert(Name);

        e.optionalAttributes.insert(Namespace);

        e.optionalAttributes.insert(Select);

        e.optionalAttributes.insert(Separator);

        e.optionalAttributes.insert(Validation);

        e.optionalAttributes.insert(Type);

    }

    /* xsl:function */

    {

        ElementDescription<XSLTTokenLookup> &e = result[Function];

        e.requiredAttributes.insert(Name);

        e.optionalAttributes.insert(As);

        e.optionalAttributes.insert(Override);

    }

    /* xsl:param */

    {

        ElementDescription<XSLTTokenLookup> &e = result[Param];

        e.requiredAttributes.insert(Name);

        e.optionalAttributes.insert(Select);

        e.optionalAttributes.insert(As);

        e.optionalAttributes.insert(Required);

        e.optionalAttributes.insert(Tunnel);

    }

    /* xsl:namespace */

    {

        ElementDescription<XSLTTokenLookup> &e = result[Namespace];

        e.requiredAttributes.insert(Name);

        e.optionalAttributes.insert(Select);

    }

    /* xsl:call-template */

    {

        ElementDescription<XSLTTokenLookup> &e = result[CallTemplate];

        e.requiredAttributes.insert(Name);

    }

    /* xsl:perform-sort */

    {

        ElementDescription<XSLTTokenLookup> &e = result[PerformSort];

        e.requiredAttributes.insert(Select);

    }

    /* xsl:sort */

    {

        ElementDescription<XSLTTokenLookup> &e = result[Sort];

        e.optionalAttributes.reserve(7);

        e.optionalAttributes.insert(Select);

        e.optionalAttributes.insert(Lang);

        e.optionalAttributes.insert(Order);

        e.optionalAttributes.insert(Collation);

        e.optionalAttributes.insert(Stable);

        e.optionalAttributes.insert(CaseOrder);

        e.optionalAttributes.insert(DataType);

    }

    /* xsl:import-schema */

    {

        ElementDescription<XSLTTokenLookup> &e = result[ImportSchema];

        e.optionalAttributes.reserve(2);

        e.optionalAttributes.insert(Namespace);

        e.optionalAttributes.insert(SchemaLocation);

    }

    /* xsl:message */

    {

        ElementDescription<XSLTTokenLookup> &e = result[Message];

        e.optionalAttributes.reserve(2);

        e.optionalAttributes.insert(Select);

        e.optionalAttributes.insert(Terminate);

    }

    /* xsl:copy-of */

    {

        ElementDescription<XSLTTokenLookup> &e = result[CopyOf];

        e.requiredAttributes.insert(Select);

        e.optionalAttributes.reserve(2);

        e.optionalAttributes.insert(CopyNamespaces);

        e.optionalAttributes.insert(Type);

        e.optionalAttributes.insert(Validation);

    }

    /* xsl:copy */

    {

        ElementDescription<XSLTTokenLookup> &e = result[Copy];

        e.optionalAttributes.reserve(5);

        e.optionalAttributes.insert(CopyNamespaces);

        e.optionalAttributes.insert(InheritNamespaces);

        e.optionalAttributes.insert(UseAttributeSets);

        e.optionalAttributes.insert(Type);

        e.optionalAttributes.insert(Validation);

    }

    /* xsl:output */

    {

        ElementDescription<XSLTTokenLookup> &e = result[Output];

        e.optionalAttributes.reserve(17);

        e.optionalAttributes.insert(Name);

        e.optionalAttributes.insert(Method);

        e.optionalAttributes.insert(ByteOrderMark);

        e.optionalAttributes.insert(CdataSectionElements);

        e.optionalAttributes.insert(DoctypePublic);

        e.optionalAttributes.insert(DoctypeSystem);

        e.optionalAttributes.insert(Encoding);

        e.optionalAttributes.insert(EscapeUriAttributes);

        e.optionalAttributes.insert(IncludeContentType);

        e.optionalAttributes.insert(Indent);

        e.optionalAttributes.insert(MediaType);

        e.optionalAttributes.insert(NormalizationForm);

        e.optionalAttributes.insert(OmitXmlDeclaration);

        e.optionalAttributes.insert(Standalone);

        e.optionalAttributes.insert(UndeclarePrefixes);

        e.optionalAttributes.insert(UseCharacterMaps);

        e.optionalAttributes.insert(Version);

    }

    /* xsl:attribute-set */

    {

        ElementDescription<XSLTTokenLookup> &e = result[AttributeSet];

        e.requiredAttributes.insert(Name);

        e.optionalAttributes.insert(UseAttributeSets);

    }

    /* xsl:include and xsl:import. */

    {

        ElementDescription<XSLTTokenLookup> &e = result[Include];

        e.requiredAttributes.insert(Href);

        result[Import] = e;

    }

    /* xsl:with-param */

    {

        ElementDescription<XSLTTokenLookup> &e = result[WithParam];

        e.requiredAttributes.insert(Name);

        e.optionalAttributes.insert(Select);

        e.optionalAttributes.insert(As);

        e.optionalAttributes.insert(Tunnel);

    }

    /* xsl:strip-space */

    {

        ElementDescription<XSLTTokenLookup> &e = result[StripSpace];

        e.requiredAttributes.insert(Elements);

        result.insert(PreserveSpace, e);

    }

    /* xsl:result-document */

    {

        ElementDescription<XSLTTokenLookup> &e = result[ResultDocument];

        e.optionalAttributes.insert(ByteOrderMark);

        e.optionalAttributes.insert(CdataSectionElements);

        e.optionalAttributes.insert(DoctypePublic);

        e.optionalAttributes.insert(DoctypeSystem);

        e.optionalAttributes.insert(Encoding);

        e.optionalAttributes.insert(EscapeUriAttributes);

        e.optionalAttributes.insert(Format);

        e.optionalAttributes.insert(Href);

        e.optionalAttributes.insert(IncludeContentType);

        e.optionalAttributes.insert(Indent);

        e.optionalAttributes.insert(MediaType);

        e.optionalAttributes.insert(Method);

        e.optionalAttributes.insert(NormalizationForm);

        e.optionalAttributes.insert(OmitXmlDeclaration);

        e.optionalAttributes.insert(OutputVersion);

        e.optionalAttributes.insert(Standalone);

        e.optionalAttributes.insert(Type);

        e.optionalAttributes.insert(UndeclarePrefixes);

        e.optionalAttributes.insert(UseCharacterMaps);

        e.optionalAttributes.insert(Validation);

    }

    /* xsl:key */

    {

        ElementDescription<XSLTTokenLookup> &e = result[Key];

        e.requiredAttributes.insert(Name);

        e.requiredAttributes.insert(Match);

        e.optionalAttributes.insert(Use);

        e.optionalAttributes.insert(Collation);

    }

    /* xsl:analyze-string */

    {

        ElementDescription<XSLTTokenLookup> &e = result[AnalyzeString];

        e.requiredAttributes.insert(Select);

        e.requiredAttributes.insert(Regex);

        e.optionalAttributes.insert(Flags);

    }

    /* xsl:matching-substring */

    {

        /* We insert a default constructed value. */

        result[MatchingSubstring];

    }

    /* xsl:non-matching-substring */

    {

        /* We insert a default constructed value. */

        result[NonMatchingSubstring];

    }

    Q_ASSERT(result.count() == ReservedForElements);

    return result;

}

QHash<QString, int> XSLTTokenizer::createValidationAlternatives()

{

    QHash<QString, int> retval;

    retval.insert(QLatin1String("preserve"), 0);

    retval.insert(QLatin1String("strip"), 1);

    retval.insert(QLatin1String("strict"), 2);

    retval.insert(QLatin1String("lax"), 3);

    return retval;

}

bool XSLTTokenizer::whitespaceToSkip() const

{

    return m_stripWhitespace.top() && isWhitespace();

}

void XSLTTokenizer::unexpectedContent(const ReportContext::ErrorCode code) const

{

    QString message;

    ReportContext::ErrorCode effectiveCode = code;

    switch(tokenType())

    {

        case QXmlStreamReader::StartElement:

        {

            if(isXSLT())

            {

                switch(currentElementName())

                {

                    case Include:

                        effectiveCode = ReportContext::XTSE0170;

                        break;

                    case Import:

                        effectiveCode = ReportContext::XTSE0190;

                        break;

                    default:

                        ;

                }

            }

            message = QtXmlPatterns::tr("Element %1 is not allowed at this location.")

                                       .arg(formatKeyword(name()));

            break;

        }

        case QXmlStreamReader::Characters:

        {

            if(whitespaceToSkip())

                return;

            message = QtXmlPatterns::tr("Text nodes are not allowed at this location.");