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

**

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

**

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

/* A Bison parser, made by GNU Bison 2.3a.  */

/* Skeleton implementation for Bison's Yacc-like parsers in C

   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006

   Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 2, or (at your option)

   any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 51 Franklin Street, Fifth Floor,

   Boston, MA 02110-1301, USA.  */

/* As a special exception, you may create a larger work that contains

   part or all of the Bison parser skeleton and distribute that work

   under terms of your choice, so long as that work isn't itself a

   parser generator using the skeleton or a modified version thereof

   as a parser skeleton.  Alternatively, if you modify or redistribute

   the parser skeleton itself, you may (at your option) remove this

   special exception, which will cause the skeleton and the resulting

   Bison output files to be licensed under the GNU General Public

   License without this special exception.

   This special exception was added by the Free Software Foundation in

   version 2.2 of Bison.  */

/* C LALR(1) parser skeleton written by Richard Stallman, by

   simplifying the original so-called "semantic" parser.  */

/* All symbols defined below should begin with yy or YY, to avoid

   infringing on user name space.  This should be done even for local

   variables, as they might otherwise be expanded by user macros.

   There are some unavoidable exceptions within include files to

   define necessary library symbols; they are noted "INFRINGES ON

   USER NAME SPACE" below.  */

/* Identify Bison output.  */

#define YYBISON 1

/* Bison version.  */

#define YYBISON_VERSION "2.3a"

/* Skeleton name.  */

#define YYSKELETON_NAME "yacc.c"

/* Pure parsers.  */

#define YYPURE 1

/* Using locations.  */

#define YYLSP_NEEDED 1

/* Substitute the variable and function names.  */

#define yyparse XPathparse

#define yylex   XPathlex

#define yyerror XPatherror

#define yylval  XPathlval

#define yychar  XPathchar

#define yydebug XPathdebug

#define yynerrs XPathnerrs

#define yylloc XPathlloc

/* Copy the first part of user declarations.  */

/* Line 164 of yacc.c.  */

#line 22 "querytransformparser.ypp"

#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 with 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);

    }

}