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 /* A Bison parser, made by GNU Bison 2.3a.  */

    43 

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

    45 

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

    47    Free Software Foundation, Inc.

    48 

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

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

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

    52    any later version.

    53 

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

    55    but WITHOUT ANY WARRANTY; without even the implied warranty of

    56    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    57    GNU General Public License for more details.

    58 

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

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

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

    62    Boston, MA 02110-1301, USA.  */

    63 

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

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

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

    67    parser generator using the skeleton or a modified version thereof

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

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

    70    special exception, which will cause the skeleton and the resulting

    71    Bison output files to be licensed under the GNU General Public

    72    License without this special exception.

    73 

    74    This special exception was added by the Free Software Foundation in

    75    version 2.2 of Bison.  */

    76 

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

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

    79 

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

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

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

    83    There are some unavoidable exceptions within include files to

    84    define necessary library symbols; they are noted "INFRINGES ON

    85    USER NAME SPACE" below.  */

    86 

    87 /* Identify Bison output.  */

    88 #define YYBISON 1

    89 

    90 /* Bison version.  */

    91 #define YYBISON_VERSION "2.3a"

    92 

    93 /* Skeleton name.  */

    94 #define YYSKELETON_NAME "yacc.c"

    95 

    96 /* Pure parsers.  */

    97 #define YYPURE 1

    98 

    99 /* Using locations.  */

   100 #define YYLSP_NEEDED 1

   101 

   102 /* Substitute the variable and function names.  */

   103 #define yyparse XPathparse

   104 #define yylex   XPathlex

   105 #define yyerror XPatherror

   106 #define yylval  XPathlval

   107 #define yychar  XPathchar

   108 #define yydebug XPathdebug

   109 #define yynerrs XPathnerrs

   110 #define yylloc XPathlloc

   111 

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

   113 /* Line 164 of yacc.c.  */

   114 #line 22 "querytransformparser.ypp"

   115 

   116 #include <limits>

   117 

   118 #include <QUrl>

   119 

   120 #include "qabstractfloat_p.h"

   121 #include "qandexpression_p.h"

   122 #include "qanyuri_p.h"

   123 #include "qapplytemplate_p.h"

   124 #include "qargumentreference_p.h"

   125 #include "qarithmeticexpression_p.h"

   126 #include "qatomicstring_p.h"

   127 #include "qattributeconstructor_p.h"

   128 #include "qattributenamevalidator_p.h"

   129 #include "qaxisstep_p.h"

   130 #include "qbuiltintypes_p.h"

   131 #include "qcalltemplate_p.h"

   132 #include "qcastableas_p.h"

   133 #include "qcastas_p.h"

   134 #include "qcombinenodes_p.h"

   135 #include "qcommentconstructor_p.h"

   136 #include "qcommonnamespaces_p.h"

   137 #include "qcommonsequencetypes_p.h"

   138 #include "qcommonvalues_p.h"

   139 #include "qcomputednamespaceconstructor_p.h"

   140 #include "qcontextitem_p.h"

   141 #include "qcopyof_p.h"

   142 #include "qcurrentitemstore_p.h"

   143 #include "qdebug_p.h"

   144 #include "qdelegatingnamespaceresolver_p.h"

   145 #include "qdocumentconstructor_p.h"

   146 #include "qelementconstructor_p.h"

   147 #include "qemptysequence_p.h"

   148 #include "qemptysequencetype_p.h"

   149 #include "qevaluationcache_p.h"

   150 #include "qexpressionfactory_p.h"

   151 #include "qexpressionsequence_p.h"

   152 #include "qexpressionvariablereference_p.h"

   153 #include "qexternalvariablereference_p.h"

   154 #include "qforclause_p.h"

   155 #include "qfunctioncall_p.h"

   156 #include "qfunctionfactory_p.h"

   157 #include "qfunctionsignature_p.h"

   158 #include "qgeneralcomparison_p.h"

   159 #include "qgenericpredicate_p.h"

   160 #include "qgenericsequencetype_p.h"

   161 #include "qifthenclause_p.h"

   162 #include "qinstanceof_p.h"

   163 #include "qletclause_p.h"

   164 #include "qliteral_p.h"

   165 #include "qlocalnametest_p.h"

   166 #include "qnamespaceconstructor_p.h"

   167 #include "qnamespacenametest_p.h"

   168 #include "qncnameconstructor_p.h"

   169 #include "qnodecomparison_p.h"

   170 #include "qnodesort_p.h"

   171 #include "qorderby_p.h"

   172 #include "qorexpression_p.h"

   173 #include "qparsercontext_p.h"

   174 #include "qpath_p.h"

   175 #include "qpatternistlocale_p.h"

   176 #include "qpositionalvariablereference_p.h"

   177 #include "qprocessinginstructionconstructor_p.h"

   178 #include "qqnameconstructor_p.h"

   179 #include "qqnametest_p.h"

   180 #include "qqnamevalue_p.h"

   181 #include "qquantifiedexpression_p.h"

   182 #include "qrangeexpression_p.h"

   183 #include "qrangevariablereference_p.h"

   184 #include "qreturnorderby_p.h"

   185 #include "qschemanumeric_p.h"

   186 #include "qschematypefactory_p.h"

   187 #include "qsimplecontentconstructor_p.h"

   188 #include "qstaticbaseuristore_p.h"

   189 #include "qstaticcompatibilitystore_p.h"

   190 #include "qtemplateparameterreference_p.h"

   191 #include "qtemplate_p.h"

   192 #include "qtextnodeconstructor_p.h"

   193 #include "qtokenizer_p.h"

   194 #include "qtreatas_p.h"

   195 #include "qtypechecker_p.h"

   196 #include "qunaryexpression_p.h"

   197 #include "qunresolvedvariablereference_p.h"

   198 #include "quserfunctioncallsite_p.h"

   199 #include "qvaluecomparison_p.h"

   200 #include "qxpathhelper_p.h"

   201 #include "qxsltsimplecontentconstructor_p.h"

   202 

   203 /*

   204  * The cpp generated with bison 2.1 wants to

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

   206  */

   207 #define YYMALLOC malloc

   208 #define YYFREE free

   209 

   210 QT_BEGIN_NAMESPACE

   211 

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

   213  * undocumented reason. */

   214 namespace QPatternist

   215 {

   216 

   217 /**

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

   219  * section to request verbose, specific error message strings when

   220  * yyerror is called."

   221  */

   222 #define YYERROR_VERBOSE 1

   223 

   224 #undef YYLTYPE_IS_TRIVIAL

   225 #define YYLTYPE_IS_TRIVIAL 0

   226 

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

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

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

   230  */

   231 #define YYENABLE_NLS 0

   232 

   233 static inline QSourceLocation fromYYLTYPE(const YYLTYPE &sourceLocator,

   234                                           const ParserContext *const parseInfo)

   235 {

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

   237                            sourceLocator.first_line,

   238                            sourceLocator.first_column);

   239 }

   240 

   241 /**

   242  * @internal

   243  * @relates QXmlQuery

   244  */

   245 typedef QFlags<QXmlQuery::QueryLanguage> QueryLanguages;

   246 

   247 /**

   248  * @short Flags invalid expressions and declarations in the currently

   249  * parsed language.

   250  *

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

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

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

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

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

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

   257  *

   258  * This is further complicated by that XSLTTokenizer sometimes generates code

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

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

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

   262  * used for internal purposes.

   263  *

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

   265  * allowedLanguages stating what languages it is allowed in.

   266  *

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

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

   269  */

   270 static void allowedIn(const QueryLanguages allowedLanguages,

   271                       const ParserContext *const parseInfo,

   272                       const YYLTYPE &sourceLocator,

   273                       const bool isInternal = false)

   274 {

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

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

   277     if(!isInternal &&

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

   279     {

   280 

   281         QString langName;

   282 

   283         switch(parseInfo->languageAccent)

   284         {

   285             case QXmlQuery::XPath20:

   286                 langName = QLatin1String("XPath 2.0");

   287                 break;

   288             case QXmlQuery::XSLT20:

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

   290                 break;

   291             case QXmlQuery::XQuery10:

   292                 langName = QLatin1String("XQuery 1.0");

   293                 break;

   294             case QXmlQuery::XmlSchema11IdentityConstraintSelector:

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

   296                 break;

   297             case QXmlQuery::XmlSchema11IdentityConstraintField:

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

   299                 break;

   300         }

   301 

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

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

   304                                         ReportContext::XPST0003,

   305                                         fromYYLTYPE(sourceLocator, parseInfo));

   306 

   307     }

   308 }

   309 

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

   311 {

   312     return    id == Expression::IDExpressionVariableReference

   313            || id == Expression::IDRangeVariableReference

   314            || id == Expression::IDArgumentReference;

   315 }

   316 

   317 class ReflectYYLTYPE : public SourceLocationReflection

   318 {

   319 public:

   320     inline ReflectYYLTYPE(const YYLTYPE &sourceLocator,

   321                           const ParserContext *const pi) : m_sl(sourceLocator)

   322                                                          , m_parseInfo(pi)

   323     {

   324     }

   325 

   326     virtual const SourceLocationReflection *actualReflection() const

   327     {

   328         return this;

   329     }

   330 

   331     virtual QSourceLocation sourceLocation() const

   332     {

   333         return fromYYLTYPE(m_sl, m_parseInfo);

   334     }

   335 

   336     virtual QString description() const

   337     {

   338         Q_ASSERT(false);

   339         return QString();

   340     }

   341 

   342 private:

   343     const YYLTYPE &m_sl;

   344     const ParserContext *const m_parseInfo;

   345 };

   346 

   347 /**

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

   349  */

   350 static inline QString unknownType()

   351 {

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

   353 }

   354 

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

   356                                      const YYLTYPE &sourceLocator,

   357                                      const ParserContext *const parseInfo)

   358 {

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

   360     return Expression::Ptr(expr);

   361 }

   362 

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

   364                                    const YYLTYPE &sourceLocator,

   365                                    const ParserContext *const parseInfo)

   366 {

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

   368     return Template::Ptr(expr);

   369 }

   370 

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

   372                                      const YYLTYPE &sourceLocator,

   373                                      const ParserContext *const parseInfo)

   374 {

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

   376     return expr;

   377 }

   378 

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

   380                                            const YYLTYPE &sourceLocator,

   381                                            const ParserContext *const parseInfo)

   382 {

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

   384                   sourceLocator,

   385                   parseInfo);

   386 }

   387 

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

   389                         TemplatePattern::Vector &ourPatterns,

   390                         const TemplatePattern::ID id,

   391                         const PatternPriority priority,

   392                         const Template::Ptr &temp)

   393 {

   394     Q_ASSERT(temp);

   395 

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

   397 

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

   399 }

   400 

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

   402                                              const SequenceType::Ptr &reqType,

   403                                              const ParserContext *const parseInfo)

   404 {

   405     return TypeChecker::applyFunctionConversion(body, reqType,

   406                                                 parseInfo->staticContext,

   407                                                 ReportContext::XTTE0505,

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

   409 }

   410 

   411 static void registerNamedTemplate(const QXmlName &name,

   412                                   const Expression::Ptr &body,

   413                                   ParserContext *const parseInfo,

   414                                   const YYLTYPE &sourceLocator,

   415                                   const Template::Ptr &temp)

   416 {

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

   418 

   419     if(e)

   420     {

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

   422                                                           "has already been declared.")

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

   424                                                                          name)),

   425                                         ReportContext::XTSE0660,

   426                                         fromYYLTYPE(sourceLocator, parseInfo));

   427     }

   428     else

   429     {

   430         e = temp;

   431         e->body = body;

   432     }

   433 }

   434 

   435 /**

   436  * @short Centralizes code for creating numeric literals.

   437  */

   438 template<typename TNumberClass>

   439 Expression::Ptr createNumericLiteral(const QString &in,

   440                                      const YYLTYPE &sl,

   441                                      const ParserContext *const parseInfo)

   442 {

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

   444 

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

   446     {

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

   448                                            .arg(formatData(in)),

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

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

   451     }

   452     else

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

   454 }

   455 

   456 /**

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

   458  *

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

   460  * ReportContext::error() is called.

   461  */

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

   463 {

   464     Q_UNUSED(sourceLocator);

   465     Q_ASSERT(parseInfo);

   466 

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

   468     return 1;

   469 }

   470 

   471 /**

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

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

   474  */

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

   476 {

   477     Q_ASSERT(expr);

   478 

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

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

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

   482     else if(id == Expression::IDReturnOrderBy)

   483         return expr->as<ReturnOrderBy>();

   484     else

   485         return 0;

   486 }

   487 

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

   489 {

   490     return id == Expression::IDGenericPredicate ||

   491            id == Expression::IDFirstItemPredicate;

   492 }

   493 

   494 /**

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

   496  * through the predicates and returns the AxisStep.

   497  */

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

   499                                     const bool throughStructures = true)

   500 {

   501     Q_ASSERT(expr);

   502 

   503     if(!throughStructures)

   504         return expr;

   505 

   506     Expression *candidate = expr.data();

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

   508 

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

   510     {

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

   512         if(children.isEmpty())

   513             return Expression::Ptr();

   514         else

   515         {

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

   517             id = candidate->id();

   518         }

   519     }

   520 

   521     if(id == Expression::IDEmptySequence)

   522         return Expression::Ptr();

   523     else

   524     {

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

   526         return Expression::Ptr(candidate);

   527     }

   528 }

   529 

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

   531 {

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

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

   534 

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

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

   537 }

   538 

   539 /**

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

   541  * into an equivalent XPath expression.

   542  *

   543  * Essentially, the following rewrite is done:

   544  *

   545  * <tt>

   546  * axis1::test1(a)/axis2::test2(b)

   547  *              =>

   548  * child-or-top::test2(b)[parent::test1(a)]

   549  * </tt>

   550  *

   551  * Section 5.5.3 The Meaning of a Pattern talks about rewrites that are applied to

   552  * only the first step in a pattern, but since we're doing rewrites more radically,

   553  * its line of reasoning cannot be followed.

   554  *

   555  * Keep in mind the rewrites that non-terminal PatternStep do.

   556  *

   557  * @see createIdPatternPath()

   558  */

   559 static inline Expression::Ptr createPatternPath(const Expression::Ptr &operand1,

   560                                                 const Expression::Ptr &operand2,

   561                                                 const QXmlNodeModelIndex::Axis axis,

   562                                                 const YYLTYPE &sl,

   563                                                 const ParserContext *const parseInfo)

   564 {

   565     const Expression::Ptr operandL(findAxisStep(operand1, false));

   566 

   567     if(operandL->is(Expression::IDAxisStep))

   568         operandL->as<AxisStep>()->setAxis(axis);

   569     else

   570         findAxisStep(operand1)->as<AxisStep>()->setAxis(axis);

   571 

   572     return create(GenericPredicate::create(operand2, operandL,

   573                                            parseInfo->staticContext, fromYYLTYPE(sl, parseInfo)), sl, parseInfo);

   574 }

   575 

   576 /**

   577  * @short Performs the same role as createPatternPath(), but is tailored

   578  * for @c fn:key() and @c fn:id().

   579  *

   580  * @c fn:key() and @c fn:id() can be part of path patterns(only as the first step,

   581  * to be precise) and that poses a challenge to rewriting because what

   582  * createPatternPath() is not possible to express, since the functions cannot be

   583  * node tests. E.g, this rewrite is not possible:

   584  *

   585  * <tt>

   586  * id-or-key/abc

   587  *  =>

   588  * child-or-top::abc[parent::id-or-key]

   589  * </tt>

   590  *

   591  * Our approach is to rewrite like this:

   592  *

   593  * <tt>

   594  * id-or-key/abc

   595  * =>

   596  * child-or-top::abc[parent::node is id-or-key]

   597  * </tt>

   598  *

   599  * @p operand1 is the call to @c fn:key() or @c fn:id(), @p operand2

   600  * the right operand, and @p axis the target axis to rewrite to.

   601  *

   602  * @see createPatternPath()

   603  */

   604 static inline Expression::Ptr createIdPatternPath(const Expression::Ptr &operand1,

   605                                                   const Expression::Ptr &operand2,

   606                                                   const QXmlNodeModelIndex::Axis axis,

   607                                                   const YYLTYPE &sl,

   608                                                   const ParserContext *const parseInfo)

   609 {

   610     const Expression::Ptr operandR(findAxisStep(operand2));

   611     Q_ASSERT(operandR);

   612     changeToTopAxis(operandR);

   613 

   614     const Expression::Ptr parentStep(create(new AxisStep(axis, BuiltinTypes::node),

   615                                             sl,

   616                                             parseInfo));

   617     const Expression::Ptr isComp(create(new NodeComparison(parentStep,

   618                                                            QXmlNodeModelIndex::Is,

   619                                                            operand1),

   620                                          sl,

   621                                          parseInfo));

   622 

   623     return create(GenericPredicate::create(operandR, isComp,

   624                                            parseInfo->staticContext, fromYYLTYPE(sl, parseInfo)), sl, parseInfo);

   625 }

   626 

   627 /**

   628  * @short Centralizes a translation message, for the

   629  * purpose of consistency and modularization.

   630  */

   631 static inline QString prologMessage(const char *const msg)

   632 {

   633     Q_ASSERT(msg);

   634     return QtXmlPatterns::tr("Only one %1 declaration can occur in the query prolog.").arg(formatKeyword(msg));

   635 }

   636 

   637 /**

   638  * @short Resolves against the static base URI and checks that @p collation

   639  * is a supported Unicode Collation.

   640  *

   641  * "If a default collation declaration specifies a collation by a

   642  *  relative URI, that relative URI is resolved to an absolute

   643  *  URI using the base URI in the static context."

   644  *

   645  * @returns the Unicode Collation properly resolved, if @p collation is a valid collation

   646  */

   647 template<const ReportContext::ErrorCode errorCode>

   648 static QUrl resolveAndCheckCollation(const QString &collation,

   649                                      const ParserContext *const parseInfo,

   650                                      const YYLTYPE &sl)

   651 {

   652     Q_ASSERT(parseInfo);

   653     const ReflectYYLTYPE ryy(sl, parseInfo);

   654 

   655     QUrl uri(AnyURI::toQUrl<ReportContext::XQST0046>(collation, parseInfo->staticContext, &ryy));

   656 

   657     if(uri.isRelative())

   658         uri = parseInfo->staticContext->baseURI().resolved(uri);

   659 

   660     XPathHelper::checkCollationSupport<errorCode>(uri.toString(), parseInfo->staticContext, &ryy);

   661 

   662     return uri;

   663 }

   664 

   665 /* The Bison generated parser declares macros that aren't used

   666  * so suppress the warnings by fake usage of them.

   667  *

   668  * We do the same for some more defines in the first action. */

   669 #if    defined(YYLSP_NEEDED)    \

   670     || defined(YYBISON)         \

   671     || defined(YYBISON_VERSION) \

   672     || defined(YYPURE)          \

   673     || defined(yydebug)         \

   674     || defined(YYSKELETON_NAME)

   675 #endif

   676 

   677 /**

   678  * Wraps @p operand with a CopyOf in case it makes any difference.

   679  *

   680  * There is no need to wrap the return value in a call to create(), it's

   681  * already done.

   682  */

   683 static Expression::Ptr createCopyOf(const Expression::Ptr &operand,

   684                                     const ParserContext *const parseInfo,

   685                                     const YYLTYPE &sl)

   686 {

   687     return create(new CopyOf(operand, parseInfo->inheritNamespacesMode,

   688                              parseInfo->preserveNamespacesMode), sl, parseInfo);

   689 }

   690 

   691 static Expression::Ptr createCompatStore(const Expression::Ptr &expr,

   692                                          const YYLTYPE &sourceLocator,

   693                                          const ParserContext *const parseInfo)

   694 {

   695     return create(new StaticCompatibilityStore(expr), sourceLocator, parseInfo);

   696 }

   697 

   698 /**

   699  * @short Creates an Expression that corresponds to <tt>/</tt>. This is literally

   700  * <tt>fn:root(self::node()) treat as document-node()</tt>.

   701  */

   702 static Expression::Ptr createRootExpression(const ParserContext *const parseInfo,

   703                                             const YYLTYPE &sl)

   704 {

   705     Q_ASSERT(parseInfo);

   706     const QXmlName name(StandardNamespaces::fn, StandardLocalNames::root);

   707 

   708     Expression::List args;

   709     args.append(create(new ContextItem(), sl, parseInfo));

   710 

   711     const ReflectYYLTYPE ryy(sl, parseInfo);

   712 

   713     const Expression::Ptr fnRoot(parseInfo->staticContext->functionSignatures()

   714                                  ->createFunctionCall(name, args, parseInfo->staticContext, &ryy));

   715     Q_ASSERT(fnRoot);

   716 

   717     return create(new TreatAs(create(fnRoot, sl, parseInfo), CommonSequenceTypes::ExactlyOneDocumentNode), sl, parseInfo);

   718 }

   719 

   720 static int XPathlex(YYSTYPE *lexVal, YYLTYPE *sourceLocator, const ParserContext *const parseInfo)

   721 {

   722 #ifdef Patternist_DEBUG_PARSER

   723     /**

   724      * "External integer variable set to zero by default. If yydebug

   725      *  is given a nonzero value, the parser will output information on

   726      *  input symbols and parser action. See section Debugging Your Parser."

   727      */

   728 #   define YYDEBUG 1

   729 

   730     extern int XPathdebug;

   731     XPathdebug = 1;

   732 #endif

   733 

   734     Q_ASSERT(parseInfo);

   735 

   736     const Tokenizer::Token tok(parseInfo->tokenizer->nextToken(sourceLocator));

   737 

   738     (*lexVal).sval = tok.value;

   739 

   740     return static_cast<int>(tok.type);

   741 }

   742 

   743 /**

   744  * @short Creates a path expression which contains the step <tt>//</tt> between

   745  * @p begin and and @p end.

   746  *

   747  * <tt>begin//end</tt> is a short form for: <tt>begin/descendant-or-self::node()/end</tt>

   748  *

   749  * This will be compiled as two-path expression: <tt>(/)/(//.)/step/</tt>

   750  */

   751 static Expression::Ptr createSlashSlashPath(const Expression::Ptr &begin,

   752                                             const Expression::Ptr &end,

   753                                             const YYLTYPE &sourceLocator,

   754                                             const ParserContext *const parseInfo)

   755 {

   756     const Expression::Ptr twoSlash(create(new AxisStep(QXmlNodeModelIndex::AxisDescendantOrSelf, BuiltinTypes::node), sourceLocator, parseInfo));

   757     const Expression::Ptr p1(create(new Path(begin, twoSlash), sourceLocator, parseInfo));

   758 

   759     return create(new Path(p1, end), sourceLocator, parseInfo);

   760 }

   761 

   762 /**

   763  * @short Creates a call to <tt>fn:concat()</tt> with @p args as the arguments.

   764  */

   765 static inline Expression::Ptr createConcatFN(const ParserContext *const parseInfo,

   766                                              const Expression::List &args,

   767                                              const YYLTYPE &sourceLocator)

   768 {

   769     Q_ASSERT(parseInfo);

   770     const QXmlName name(StandardNamespaces::fn, StandardLocalNames::concat);

   771     const ReflectYYLTYPE ryy(sourceLocator, parseInfo);

   772 

   773     return create(parseInfo->staticContext->functionSignatures()->createFunctionCall(name, args, parseInfo->staticContext, &ryy),

   774                   sourceLocator, parseInfo);

   775 }

   776 

   777 static inline Expression::Ptr createDirAttributeValue(const Expression::List &content,

   778                                                       const ParserContext *const parseInfo,

   779                                                       const YYLTYPE &sourceLocator)

   780 {

   781     if(content.isEmpty())

   782         return create(new EmptySequence(), sourceLocator, parseInfo);

   783     else if(content.size() == 1)

   784         return content.first();

   785     else

   786         return createConcatFN(parseInfo, content, sourceLocator);

   787 }

   788 

   789 /**

   790  * @short Checks for variable initialization circularity.

   791  *

   792  * "A recursive function that checks for recursion is full of ironies."

   793  *

   794  *      -- The Salsa Master

   795  *

   796  * Issues an error via @p parseInfo's StaticContext if the initialization

   797  * expression @p checkee for the global variable @p var, contains a variable

   798  * reference to @p var. That is, if there's a circularity.

   799  *

   800  * @see <a href="http://www.w3.org/TR/xquery/#ERRXQST0054">XQuery 1.0: An XML

   801  * Query Language, err:XQST0054</a>

   802  */

   803 static void checkVariableCircularity(const VariableDeclaration::Ptr &var,

   804                                      const Expression::Ptr &checkee,

   805                                      const VariableDeclaration::Type type,

   806                                      FunctionSignature::List &signList,

   807                                      const ParserContext *const parseInfo)

   808 {

   809     Q_ASSERT(var);

   810     Q_ASSERT(checkee);

   811     Q_ASSERT(parseInfo);

   812 

   813     const Expression::ID id = checkee->id();

   814 

   815     if(id == Expression::IDExpressionVariableReference)

   816     {

   817         const ExpressionVariableReference *const ref =

   818                     static_cast<const ExpressionVariableReference *>(checkee.data());

   819 

   820         if(var->slot == ref->slot() && type == ref->variableDeclaration()->type)

   821         {

   822             parseInfo->staticContext->error(QtXmlPatterns::tr("The initialization of variable %1 "

   823                                                               "depends on itself").arg(formatKeyword(var, parseInfo->staticContext->namePool())),

   824                                             parseInfo->isXSLT() ? ReportContext::XTDE0640 : ReportContext::XQST0054, ref);

   825             return;

   826         }

   827         else

   828         {

   829             /* If the variable we're checking is below another variable, it can be a recursive

   830              * dependency through functions, so we need to check variable references too. */

   831             checkVariableCircularity(var, ref->sourceExpression(), type, signList, parseInfo);

   832             return;

   833         }

   834     }

   835     else if(id == Expression::IDUserFunctionCallsite)

   836     {

   837         const UserFunctionCallsite::Ptr callsite(checkee);

   838         const FunctionSignature::Ptr sign(callsite->callTargetDescription());

   839         const FunctionSignature::List::const_iterator end(signList.constEnd());

   840         FunctionSignature::List::const_iterator it(signList.constBegin());

   841         bool noMatch = true;

   842 

   843         for(; it != end; ++it)

   844         {

   845             if(*it == sign)

   846             {

   847                 /* The variable we're checking is depending on a function that's recursive. The

   848                  * user has written a weird query, in other words. Since it's the second time

   849                  * we've encountered a callsite, we now skip it. */

   850                 noMatch = false;

   851                 break;

   852             }

   853         }

   854 

   855         if(noMatch)

   856         {

   857             signList.append(sign);

   858             /* Check the body of the function being called. */

   859             checkVariableCircularity(var, callsite->body(), type, signList, parseInfo);

   860         }

   861         /* Continue with the operands, such that we also check the arguments of the callsite. */

   862     }

   863     else if(id == Expression::IDUnresolvedVariableReference)

   864     {

   865         /* We're called before it has rewritten itself. */

   866         checkVariableCircularity(var, checkee->as<UnresolvedVariableReference>()->replacement(), type, signList, parseInfo);

   867     }

   868 

   869     /* Check the operands. */

   870     const Expression::List ops(checkee->operands());

   871     if(ops.isEmpty())

   872         return;

   873 

   874     const Expression::List::const_iterator end(ops.constEnd());

   875     Expression::List::const_iterator it(ops.constBegin());

   876 

   877     for(; it != end; ++it)

   878         checkVariableCircularity(var, *it, type, signList, parseInfo);

   879 }

   880 

   881 static void variableUnavailable(const QXmlName &variableName,

   882                                 const ParserContext *const parseInfo,

   883                                 const YYLTYPE &location)

   884 {

   885     parseInfo->staticContext->error(QtXmlPatterns::tr("No variable by name %1 exists")

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

   887                                     ReportContext::XPST0008, fromYYLTYPE(location, parseInfo));

   888 }

   889 

   890 /**

   891  * The Cardinality in a TypeDeclaration for a variable in a quantification has no effect,

   892  * and this function ensures this by changing @p type to Cardinality Cardinality::zeroOrMore().

   893  *

   894  * @see <a href="http://www.w3.org/Bugs/Public/show_bug.cgi?id=3305">Bugzilla Bug 3305

   895  * Cardinality + on range variables</a>

   896  * @see ParserContext::finalizePushedVariable()

   897  */

   898 static inline SequenceType::Ptr quantificationType(const SequenceType::Ptr &type)

   899 {

   900     Q_ASSERT(type);

   901     return makeGenericSequenceType(type->itemType(), Cardinality::zeroOrMore());

   902 }

   903 

   904 /**

   905  * @p seqType and @p expr may be @c null.

   906  */

   907 static Expression::Ptr pushVariable(const QXmlName name,

   908                                     const SequenceType::Ptr &seqType,

   909                                     const Expression::Ptr &expr,

   910                                     const VariableDeclaration::Type type,

   911                                     const YYLTYPE &sourceLocator,

   912                                     ParserContext *const parseInfo,

   913                                     const bool checkSource = true)

   914 {

   915     Q_ASSERT(!name.isNull());

   916     Q_ASSERT(parseInfo);

   917 

   918     /* -2 will cause Q_ASSERTs to trigger if it isn't changed. */

   919     VariableSlotID slot = -2;

   920 

   921     switch(type)

   922     {

   923         case VariableDeclaration::FunctionArgument:

   924         /* Fallthrough. */

   925         case VariableDeclaration::ExpressionVariable:

   926         {

   927             slot = parseInfo->allocateExpressionSlot();

   928             break;

   929         }

   930         case VariableDeclaration::GlobalVariable:

   931         {

   932             slot = parseInfo->allocateGlobalVariableSlot();

   933             break;

   934         }

   935         case VariableDeclaration::RangeVariable:

   936         {

   937             slot = parseInfo->staticContext->allocateRangeSlot();

   938             break;

   939         }

   940         case VariableDeclaration::PositionalVariable:

   941         {

   942             slot = parseInfo->allocatePositionalSlot();

   943             break;

   944         }

   945         case VariableDeclaration::TemplateParameter:

   946             /* Fallthrough. We do nothing, template parameters

   947              * doesn't use context slots at all, they're hashed

   948              * on the name. */

   949         case VariableDeclaration::ExternalVariable:

   950             /* We do nothing, external variables doesn't use

   951              *context slots/stack frames at all. */

   952             ;

   953     }

   954 

   955     const VariableDeclaration::Ptr var(new VariableDeclaration(name, slot, type, seqType));

   956 

   957     Expression::Ptr checked;

   958 

   959     if(checkSource && seqType)

   960     {

   961         if(expr)

   962         {

   963             /* We only want to add conversion for function arguments, and variables

   964              * if we're XSL-T.

   965              *

   966              * We unconditionally skip TypeChecker::CheckFocus because the StaticContext we

   967              * pass hasn't set up the focus yet, since that's the parent's responsibility. */

   968             const TypeChecker::Options options((   type == VariableDeclaration::FunctionArgument

   969                                                 || type == VariableDeclaration::TemplateParameter

   970                                                 || parseInfo->isXSLT())

   971                                                ? TypeChecker::AutomaticallyConvert : TypeChecker::Options());

   972 

   973             checked = TypeChecker::applyFunctionConversion(expr, seqType, parseInfo->staticContext,

   974                                                            parseInfo->isXSLT() ? ReportContext::XTTE0570 : ReportContext::XPTY0004,

   975                                                            options);

   976         }

   977     }

   978     else

   979         checked = expr;

   980 

   981     /* Add an evaluation cache for all expression variables. No EvaluationCache is needed for

   982      * positional variables because in the end they are calls to Iterator::position(). Similarly,

   983      * no need to cache range variables either because they are calls to DynamicContext::rangeVariable().

   984      *

   985      * We don't do it for function arguments because the Expression being cached depends -- it depends

   986      * on the callsite. UserFunctionCallsite is responsible for the evaluation caches in that case.

   987      *

   988      * In some cases the EvaluationCache instance isn't necessary, but in those cases EvaluationCache

   989      * optimizes itself away. */

   990     if(type == VariableDeclaration::ExpressionVariable)

   991         checked = create(new EvaluationCache<false>(checked, var, parseInfo->allocateCacheSlot()), sourceLocator, parseInfo);

   992     else if(type == VariableDeclaration::GlobalVariable)

   993         checked = create(new EvaluationCache<true>(checked, var, parseInfo->allocateCacheSlot()), sourceLocator, parseInfo);

   994 

   995     var->setExpression(checked);

   996 

   997     parseInfo->variables.push(var);

   998     return checked;

   999 }

  1000 

  1001 static inline VariableDeclaration::Ptr variableByName(const QXmlName name,

  1002                                                       const ParserContext *const parseInfo)

  1003 {

  1004     Q_ASSERT(!name.isNull());

  1005     Q_ASSERT(parseInfo);

  1006 

  1007     /* We walk the list backwards. */

  1008     const VariableDeclaration::Stack::const_iterator start(parseInfo->variables.constBegin());

  1009     VariableDeclaration::Stack::const_iterator it(parseInfo->variables.constEnd());

  1010 

  1011     while(it != start)

  1012     {

  1013         --it;

  1014         Q_ASSERT(*it);

  1015         if((*it)->name == name)

  1016             return *it;

  1017     }

  1018 

  1019     return VariableDeclaration::Ptr();

  1020 }

  1021 

  1022 static Expression::Ptr resolveVariable(const QXmlName &name,

  1023                                        const YYLTYPE &sourceLocator,

  1024                                        ParserContext *const parseInfo,

  1025                                        const bool raiseErrorOnUnavailability)

  1026 {

  1027     const VariableDeclaration::Ptr var(variableByName(name, parseInfo));

  1028     Expression::Ptr retval;

  1029 

  1030     if(var && var->type != VariableDeclaration::ExternalVariable)

  1031     {

  1032         switch(var->type)

  1033         {

  1034             case VariableDeclaration::RangeVariable:

  1035             {

  1036                 retval = create(new RangeVariableReference(var->expression(), var->slot), sourceLocator, parseInfo);

  1037                 break;

  1038             }

  1039             case VariableDeclaration::GlobalVariable:

  1040             /* Fallthrough. From the perspective of an ExpressionVariableReference, it can't tell

  1041              * a difference between a global and a local expression variable. However, the cache

  1042              * mechanism must. */

  1043             case VariableDeclaration::ExpressionVariable:

  1044             {

  1045                 retval = create(new ExpressionVariableReference(var->slot, var), sourceLocator, parseInfo);

  1046                 break;

  1047             }

  1048             case VariableDeclaration::FunctionArgument:

  1049             {

  1050                 retval = create(new ArgumentReference(var->sequenceType, var->slot), sourceLocator, parseInfo);

  1051                 break;

  1052             }

  1053             case VariableDeclaration::PositionalVariable:

  1054             {

  1055                 retval = create(new PositionalVariableReference(var->slot), sourceLocator, parseInfo);

  1056                 break;

  1057             }

  1058             case VariableDeclaration::TemplateParameter:

  1059             {

  1060                 retval = create(new TemplateParameterReference(var), sourceLocator, parseInfo);

  1061                 break;

  1062             }

  1063             case VariableDeclaration::ExternalVariable:

  1064                 /* This code path will never be hit, but the case

  1065                  * label silences a warning. See above. */

  1066                 ;

  1067         }

  1068         Q_ASSERT(retval);

  1069         var->references.append(retval);

  1070     }

  1071     else

  1072     {

  1073         /* Let's see if your external variable loader can provide us with one. */

  1074         const SequenceType::Ptr varType(parseInfo->staticContext->

  1075                                         externalVariableLoader()->announceExternalVariable(name, CommonSequenceTypes::ZeroOrMoreItems));

  1076 

  1077         if(varType)

  1078         {

  1079             const Expression::Ptr extRef(create(new ExternalVariableReference(name, varType), sourceLocator, parseInfo));

  1080             const Expression::Ptr checked(TypeChecker::applyFunctionConversion(extRef, varType, parseInfo->staticContext));

  1081             retval = checked;

  1082         }

  1083         else if(!raiseErrorOnUnavailability && parseInfo->isXSLT())

  1084         {

  1085             /* In XSL-T, global variables are in scope for the whole

  1086              * stylesheet, so we must resolve this first at the end. */

  1087             retval = create(new UnresolvedVariableReference(name), sourceLocator, parseInfo);

  1088             parseInfo->unresolvedVariableReferences.insert(name, retval);

  1089         }

  1090         else

  1091             variableUnavailable(name, parseInfo, sourceLocator);

  1092     }

  1093 

  1094     return retval;

  1095 }

  1096 

  1097 static Expression::Ptr createReturnOrderBy(const OrderSpecTransfer::List &orderSpecTransfer,

  1098                                            const Expression::Ptr &returnExpr,

  1099                                            const OrderBy::Stability stability,

  1100                                            const YYLTYPE &sourceLocator,

  1101                                            const ParserContext *const parseInfo)

  1102 {

  1103     // TODO do resize(orderSpec.size() + 1)

  1104     Expression::List exprs;

  1105     OrderBy::OrderSpec::Vector orderSpecs;

  1106 

  1107     exprs.append(returnExpr);

  1108 

  1109     const int len = orderSpecTransfer.size();

  1110 

  1111     for(int i = 0; i < len; ++i)

  1112     {

  1113         exprs.append(orderSpecTransfer.at(i).expression);

  1114         orderSpecs.append(orderSpecTransfer.at(i).orderSpec);

  1115     }

  1116 

  1117     return create(new ReturnOrderBy(stability, orderSpecs, exprs), sourceLocator, parseInfo);

  1118 }

  1119 

  1120 

  1121 

  1122 /* Enabling traces.  */

  1123 #ifndef YYDEBUG

  1124 # define YYDEBUG 0

  1125 #endif

  1126 

  1127 /* Enabling verbose error messages.  */

  1128 #ifdef YYERROR_VERBOSE

  1129 # undef YYERROR_VERBOSE

  1130 # define YYERROR_VERBOSE 1

  1131 #else

  1132 # define YYERROR_VERBOSE 1

  1133 #endif

  1134