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

**

** 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$

**

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

//

//  W A R N I N G

//  -------------

//

// This file is not part of the Qt API.  It exists purely as an

// implementation detail.  This header file may change from version to

// version without notice, or even be removed.

//

// We mean it.

%{

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

**

** 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$

**

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

//

//  W A R N I N G

//  -------------

//

// This file is not part of the Qt API.  It exists purely as an

// implementation detail.  This header file may change from version to

// version without notice, or even be removed.

//

// We mean it.

#include <limits>

#include <QUrl>

#include "qabstractfloat_p.h"

#include "qandexpression_p.h"

#include "qanyuri_p.h"

#include "qapplytemplate_p.h"

#include "qargumentreference_p.h"

#include "qarithmeticexpression_p.h"

#include "qatomicstring_p.h"

#include "qattributeconstructor_p.h"

#include "qattributenamevalidator_p.h"

#include "qaxisstep_p.h"

#include "qbuiltintypes_p.h"

#include "qcalltemplate_p.h"

#include "qcastableas_p.h"

#include "qcastas_p.h"

#include "qcombinenodes_p.h"

#include "qcommentconstructor_p.h"

#include "qcommonnamespaces_p.h"

#include "qcommonsequencetypes_p.h"

#include "qcommonvalues_p.h"

#include "qcomputednamespaceconstructor_p.h"

#include "qcontextitem_p.h"

#include "qcopyof_p.h"

#include "qcurrentitemstore_p.h"

#include "qdebug_p.h"

#include "qdelegatingnamespaceresolver_p.h"

#include "qdocumentconstructor_p.h"

#include "qelementconstructor_p.h"

#include "qemptysequence_p.h"

#include "qemptysequencetype_p.h"

#include "qevaluationcache_p.h"

#include "qexpressionfactory_p.h"

#include "qexpressionsequence_p.h"

#include "qexpressionvariablereference_p.h"

#include "qexternalvariablereference_p.h"

#include "qforclause_p.h"

#include "qfunctioncall_p.h"

#include "qfunctionfactory_p.h"

#include "qfunctionsignature_p.h"

#include "qgeneralcomparison_p.h"

#include "qgenericpredicate_p.h"

#include "qgenericsequencetype_p.h"

#include "qifthenclause_p.h"

#include "qinstanceof_p.h"

#include "qletclause_p.h"

#include "qliteral_p.h"

#include "qlocalnametest_p.h"

#include "qnamespaceconstructor_p.h"

#include "qnamespacenametest_p.h"

#include "qncnameconstructor_p.h"

#include "qnodecomparison_p.h"

#include "qnodesort_p.h"

#include "qorderby_p.h"

#include "qorexpression_p.h"

#include "qparsercontext_p.h"

#include "qpath_p.h"

#include "qpatternistlocale_p.h"

#include "qpositionalvariablereference_p.h"

#include "qprocessinginstructionconstructor_p.h"

#include "qqnameconstructor_p.h"

#include "qqnametest_p.h"

#include "qqnamevalue_p.h"

#include "qquantifiedexpression_p.h"

#include "qrangeexpression_p.h"

#include "qrangevariablereference_p.h"

#include "qreturnorderby_p.h"

#include "qschemanumeric_p.h"

#include "qschematypefactory_p.h"

#include "qsimplecontentconstructor_p.h"

#include "qstaticbaseuristore_p.h"

#include "qstaticcompatibilitystore_p.h"

#include "qtemplateparameterreference_p.h"

#include "qtemplate_p.h"

#include "qtextnodeconstructor_p.h"

#include "qtokenizer_p.h"

#include "qtreatas_p.h"

#include "qtypechecker_p.h"

#include "qunaryexpression_p.h"

#include "qunresolvedvariablereference_p.h"

#include "quserfunctioncallsite_p.h"

#include "qvaluecomparison_p.h"

#include "qxpathhelper_p.h"

#include "qxsltsimplecontentconstructor_p.h"

/*

 * The cpp generated with bison 2.1 wants to

 * redeclare the C-like prototypes of 'malloc' and 'free', so we avoid that.

 */

#define YYMALLOC malloc

#define YYFREE free

QT_BEGIN_NAMESPACE

/* Due to Qt's QT_BEGIN_NAMESPACE magic, we can't use `using namespace', for some

 * undocumented reason. */

namespace QPatternist

{

/**

 * "Macro that you define with #define in the Bison declarations

 * section to request verbose, specific error message strings when

 * yyerror is called."

 */

#define YYERROR_VERBOSE 1

#undef YYLTYPE_IS_TRIVIAL

#define YYLTYPE_IS_TRIVIAL 0

/* Suppresses `warning: "YYENABLE_NLS" is not defined`

 * @c YYENABLE_NLS enables Bison internationalization, and we don't

 * use that, so disable it. See the Bison Manual, section 4.5 Parser Internationalization.

 */

#define YYENABLE_NLS 0

static inline QSourceLocation fromYYLTYPE(const YYLTYPE &sourceLocator,

                                          const ParserContext *const parseInfo)

{

    return QSourceLocation(parseInfo->tokenizer->queryURI(),

                           sourceLocator.first_line,

                           sourceLocator.first_column);

}

/**

 * @internal

 * @relates QXmlQuery

 */

typedef QFlags<QXmlQuery::QueryLanguage> QueryLanguages;

/**

 * @short Flags invalid expressions and declarations in the currently

 * parsed language.

 *

 * Since this grammar is used for several languages: XQuery 1.0, XSL-T 2.0, and

 * XPath 2.0 inside XSL-T, and field and selector patterns in W3C XML Schema's

 * identity constraints, it is the union of all the constructs in these

 * languages. However, when dealing with each language individually, we

 * regularly need to disallow some expressions, such as direct element

 * constructors when parsing XSL-T, or the typeswitch when parsing XPath.

 *

 * This is further complicated by that XSLTTokenizer sometimes generates code

 * which is allowed in XQuery but not in XPath. For that reason the token

 * INTERNAL is sometimes generated, which signals that an expression, for

 * instance the @c let clause, should not be flagged as an error, because it's

 * used for internal purposes.

 *

 * Hence, this function is called from each expression and declaration with @p

 * allowedLanguages stating what languages it is allowed in.

 *

 * If @p isInternal is @c true, no error is raised. Otherwise, if the current

 * language is not in @p allowedLanguages, an error is raised.

 */

static void allowedIn(const QueryLanguages allowedLanguages,

                      const ParserContext *const parseInfo,

                      const YYLTYPE &sourceLocator,

                      const bool isInternal = false)

{

    /* We treat XPath 2.0 as a subset of XSL-T 2.0, so if XPath 2.0 is allowed

     * and XSL-T is the language, it's ok. */

    if(!isInternal &&

       (!allowedLanguages.testFlag(parseInfo->languageAccent) && !(allowedLanguages.testFlag(QXmlQuery::XPath20) && parseInfo->languageAccent == QXmlQuery::XSLT20)))

    {

        QString langName;

        switch(parseInfo->languageAccent)

        {

            case QXmlQuery::XPath20:

                langName = QLatin1String("XPath 2.0");

                break;

            case QXmlQuery::XSLT20:

                langName = QLatin1String("XSL-T 2.0");

                break;

            case QXmlQuery::XQuery10:

                langName = QLatin1String("XQuery 1.0");

                break;

            case QXmlQuery::XmlSchema11IdentityConstraintSelector:

                langName = QtXmlPatterns::tr("W3C XML Schema identity constraint selector");

                break;

            case QXmlQuery::XmlSchema11IdentityConstraintField:

                langName = QtXmlPatterns::tr("W3C XML Schema identity constraint field");

                break;

        }

        parseInfo->staticContext->error(QtXmlPatterns::tr("A construct was encountered "

                                                          "which is disallowed in the current language(%1).").arg(langName),

                                        ReportContext::XPST0003,

                                        fromYYLTYPE(sourceLocator, parseInfo));

    }

}

static inline bool isVariableReference(const Expression::ID id)

{

    return    id == Expression::IDExpressionVariableReference

           || id == Expression::IDRangeVariableReference

           || id == Expression::IDArgumentReference;

}

class ReflectYYLTYPE : public SourceLocationReflection

{

public:

    inline ReflectYYLTYPE(const YYLTYPE &sourceLocator,

                          const ParserContext *const pi) : m_sl(sourceLocator)

                                                         , m_parseInfo(pi)

    {

    }

    virtual const SourceLocationReflection *actualReflection() const

    {

        return this;

    }

    virtual QSourceLocation sourceLocation() const

    {

        return fromYYLTYPE(m_sl, m_parseInfo);

    }

    virtual QString description() const

    {

        Q_ASSERT(false);

        return QString();

    }

private:

    const YYLTYPE &m_sl;

    const ParserContext *const m_parseInfo;

};

/**

 * @short Centralizes a translation string for the purpose of increasing consistency.

 */

static inline QString unknownType()

{

    return QtXmlPatterns::tr("%1 is an unknown schema type.");

}

static inline Expression::Ptr create(Expression *const expr,

                                     const YYLTYPE &sourceLocator,

                                     const ParserContext *const parseInfo)

{

    parseInfo->staticContext->addLocation(expr, fromYYLTYPE(sourceLocator, parseInfo));

    return Expression::Ptr(expr);

}

static inline Template::Ptr create(Template *const expr,

                                   const YYLTYPE &sourceLocator,

                                   const ParserContext *const parseInfo)

{

    parseInfo->staticContext->addLocation(expr, fromYYLTYPE(sourceLocator, parseInfo));

    return Template::Ptr(expr);

}

static inline Expression::Ptr create(const Expression::Ptr &expr,

                                     const YYLTYPE &sourceLocator,

                                     const ParserContext *const parseInfo)

{

    parseInfo->staticContext->addLocation(expr.data(), fromYYLTYPE(sourceLocator, parseInfo));

    return expr;

}

static Expression::Ptr createSimpleContent(const Expression::Ptr &source,

                                           const YYLTYPE &sourceLocator,

                                           const ParserContext *const parseInfo)

{

    return create(parseInfo->isXSLT() ? new XSLTSimpleContentConstructor(source) : new SimpleContentConstructor(source),

                  sourceLocator,

                  parseInfo);

}

static void loadPattern(const Expression::Ptr &matchPattern,

                        TemplatePattern::Vector &ourPatterns,

                        const TemplatePattern::ID id,

                        const PatternPriority priority,

                        const Template::Ptr &temp)

{

    Q_ASSERT(temp);

    const PatternPriority effectivePriority = qIsNaN(priority) ? matchPattern->patternPriority() : priority;

    ourPatterns.append(TemplatePattern::Ptr(new TemplatePattern(matchPattern, effectivePriority, id, temp)));

}

static Expression::Ptr typeCheckTemplateBody(const Expression::Ptr &body,

                                             const SequenceType::Ptr &reqType,

                                             const ParserContext *const parseInfo)

{

    return TypeChecker::applyFunctionConversion(body, reqType,

                                                parseInfo->staticContext,

                                                ReportContext::XTTE0505,

                                                TypeChecker::Options(TypeChecker::AutomaticallyConvert | TypeChecker::GeneratePromotion));

}

static void registerNamedTemplate(const QXmlName &name,

                                  const Expression::Ptr &body,

                                  ParserContext *const parseInfo,

                                  const YYLTYPE &sourceLocator,

                                  const Template::Ptr &temp)

{

    Template::Ptr &e = parseInfo->namedTemplates[name];

    if(e)

    {

        parseInfo->staticContext->error(QtXmlPatterns::tr("A template by name %1 "

                                                          "has already been declared.")

                                        .arg(formatKeyword(parseInfo->staticContext->namePool(),

                                                                         name)),

                                        ReportContext::XTSE0660,

                                        fromYYLTYPE(sourceLocator, parseInfo));

    }

    else

    {

        e = temp;

        e->body = body;

    }

}

/**

 * @short Centralizes code for creating numeric literals.

 */

template<typename TNumberClass>

Expression::Ptr createNumericLiteral(const QString &in,

                                     const YYLTYPE &sl,

                                     const ParserContext *const parseInfo)

{

    const Item num(TNumberClass::fromLexical(in));

    if(num.template as<AtomicValue>()->hasError())

    {

        parseInfo->staticContext->error(QtXmlPatterns::tr("%1 is not a valid numeric literal.")

                                           .arg(formatData(in)),

                                        ReportContext::XPST0003, fromYYLTYPE(sl, parseInfo));

        return Expression::Ptr(); /* Avoid compiler warning. */

    }

    else

        return create(new Literal(num), sl, parseInfo);

}

/**

 * @short The generated Bison parser calls this function when there is a parse error.

 *

 * It is not called, nor should be, for logical errors(which the Bison not know about). For those,

 * ReportContext::error() is called.

 */

static int XPatherror(YYLTYPE *sourceLocator, const ParserContext *const parseInfo, const char *const msg)

{

    Q_UNUSED(sourceLocator);

    Q_ASSERT(parseInfo);

    parseInfo->staticContext->error(escape(QLatin1String(msg)), ReportContext::XPST0003, fromYYLTYPE(*sourceLocator, parseInfo));

    return 1;

}

/**

 * When we want to connect the OrderBy and ReturnOrderBy, it might be that we have other expressions, such

 * as @c where and @c let inbetween. We need to continue through them. This function does that.

 */

static ReturnOrderBy *locateReturnClause(const Expression::Ptr &expr)

{

    Q_ASSERT(expr);

    const Expression::ID id = expr->id();

    if(id == Expression::IDLetClause || id == Expression::IDIfThenClause || id == Expression::IDForClause)

        return locateReturnClause(expr->operands()[1]);

    else if(id == Expression::IDReturnOrderBy)

        return expr->as<ReturnOrderBy>();

    else

        return 0;

}

static inline bool isPredicate(const Expression::ID id)

{

    return id == Expression::IDGenericPredicate ||

           id == Expression::IDFirstItemPredicate;

}

/**

 * Assumes expr is an AxisStep wrapped in some kind of predicates or paths. Filters

 * through the predicates and returns the AxisStep.

 */

static Expression::Ptr findAxisStep(const Expression::Ptr &expr,

                                    const bool throughStructures = true)

{

    Q_ASSERT(expr);

    if(!throughStructures)

        return expr;

    Expression *candidate = expr.data();

    Expression::ID id = candidate->id();

    while(isPredicate(id) || id == Expression::IDPath)

    {

        const Expression::List &children = candidate->operands();

        if(children.isEmpty())

            return Expression::Ptr();

        else

        {

            candidate = children.first().data();

            id = candidate->id();

        }

    }

    if(id == Expression::IDEmptySequence)

        return Expression::Ptr();

    else

    {

        Q_ASSERT(candidate->is(Expression::IDAxisStep));

        return Expression::Ptr(candidate);

    }

}

static void changeToTopAxis(const Expression::Ptr &op)

{

    /* This axis must have been written away by now. */

    Q_ASSERT(op->as<AxisStep>()->axis() != QXmlNodeModelIndex::AxisChild);

    if(op->as<AxisStep>()->axis() != QXmlNodeModelIndex::AxisSelf)

        op->as<AxisStep>()->setAxis(QXmlNodeModelIndex::AxisAttributeOrTop);

}

/**

 * @short Writes @p operand1 and @p operand2, two operands in an XSL-T pattern,