diff options
Diffstat (limited to 'src/xmlpatterns/parser/querytransformparser.ypp')
| -rw-r--r-- | src/xmlpatterns/parser/querytransformparser.ypp | 4680 |
1 files changed, 4680 insertions, 0 deletions
diff --git a/src/xmlpatterns/parser/querytransformparser.ypp b/src/xmlpatterns/parser/querytransformparser.ypp new file mode 100644 index 0000000..186538c --- /dev/null +++ b/src/xmlpatterns/parser/querytransformparser.ypp @@ -0,0 +1,4680 @@ +/**************************************************************************** +** +** Copyright (C) 2011 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) 2011 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, + * into an equivalent XPath expression. + * + * Essentially, the following rewrite is done: + * + * <tt> + * axis1::test1(a)/axis2::test2(b) + * => + * child-or-top::test2(b)[parent::test1(a)] + * </tt> + * + * Section 5.5.3 The Meaning of a Pattern talks about rewrites that are applied to + * only the first step in a pattern, but since we're doing rewrites more radically, + * its line of reasoning cannot be followed. + * + * Keep in mind the rewrites that non-terminal PatternStep do. + * + * @see createIdPatternPath() + */ +static inline Expression::Ptr createPatternPath(const Expression::Ptr &operand1, + const Expression::Ptr &operand2, + const QXmlNodeModelIndex::Axis axis, + const YYLTYPE &sl, + const ParserContext *const parseInfo) +{ + const Expression::Ptr operandL(findAxisStep(operand1, false)); + + if(operandL->is(Expression::IDAxisStep)) + operandL->as<AxisStep>()->setAxis(axis); + else + findAxisStep(operand1)->as<AxisStep>()->setAxis(axis); + + return create(GenericPredicate::create(operand2, operandL, + parseInfo->staticContext, fromYYLTYPE(sl, parseInfo)), sl, parseInfo); +} + +/** + * @short Performs the same role as createPatternPath(), but is tailored + * for @c fn:key() and @c fn:id(). + * + * @c fn:key() and @c fn:id() can be part of path patterns(only as the first step, + * to be precise) and that poses a challenge to rewriting because what + * createPatternPath() is not possible to express, since the functions cannot be + * node tests. E.g, this rewrite is not possible: + * + * <tt> + * id-or-key/abc + * => + * child-or-top::abc[parent::id-or-key] + * </tt> + * + * Our approach is to rewrite like this: + * + * <tt> + * id-or-key/abc + * => + * child-or-top::abc[parent::node is id-or-key] + * </tt> + * + * @p operand1 is the call to @c fn:key() or @c fn:id(), @p operand2 + * the right operand, and @p axis the target axis to rewrite to. + * + * @see createPatternPath() + */ +static inline Expression::Ptr createIdPatternPath(const Expression::Ptr &operand1, + const Expression::Ptr &operand2, + const QXmlNodeModelIndex::Axis axis, + const YYLTYPE &sl, + const ParserContext *const parseInfo) +{ + const Expression::Ptr operandR(findAxisStep(operand2)); + Q_ASSERT(operandR); + changeToTopAxis(operandR); + + const Expression::Ptr parentStep(create(new AxisStep(axis, BuiltinTypes::node), + sl, + parseInfo)); + const Expression::Ptr isComp(create(new NodeComparison(parentStep, + QXmlNodeModelIndex::Is, + operand1), + sl, + parseInfo)); + + return create(GenericPredicate::create(operandR, isComp, + parseInfo->staticContext, fromYYLTYPE(sl, parseInfo)), sl, parseInfo); +} + +/** + * @short Centralizes a translation message, for the + * purpose of consistency and modularization. + */ +static inline QString prologMessage(const char *const msg) +{ + Q_ASSERT(msg); + return QtXmlPatterns::tr("Only one %1 declaration can occur in the query prolog.").arg(formatKeyword(msg)); +} + +/** + * @short Resolves against the static base URI and checks that @p collation + * is a supported Unicode Collation. + * + * "If a default collation declaration specifies a collation by a + * relative URI, that relative URI is resolved to an absolute + * URI using the base URI in the static context." + * + * @returns the Unicode Collation properly resolved, if @p collation is a valid collation + */ +template<const ReportContext::ErrorCode errorCode> +static QUrl resolveAndCheckCollation(const QString &collation, + const ParserContext *const parseInfo, + const YYLTYPE &sl) +{ + Q_ASSERT(parseInfo); + const ReflectYYLTYPE ryy(sl, parseInfo); + + QUrl uri(AnyURI::toQUrl<ReportContext::XQST0046>(collation, parseInfo->staticContext, &ryy)); + + if(uri.isRelative()) + uri = parseInfo->staticContext->baseURI().resolved(uri); + + XPathHelper::checkCollationSupport<errorCode>(uri.toString(), parseInfo->staticContext, &ryy); + + return uri; +} + +/* The Bison generated parser declares macros that aren't used + * so suppress the warnings by fake usage of them. + * + * We do the same for some more defines in the first action. */ +#if defined(YYLSP_NEEDED) \ + || defined(YYBISON) \ + || defined(YYBISON_VERSION) \ + || defined(YYPURE) \ + || defined(yydebug) \ + || defined(YYSKELETON_NAME) +#endif + +/** + * Wraps @p operand with a CopyOf in case it makes any difference. + * + * There is no need to wrap the return value in a call to create(), it's + * already done. + */ +static Expression::Ptr createCopyOf(const Expression::Ptr &operand, + const ParserContext *const parseInfo, + const YYLTYPE &sl) +{ + return create(new CopyOf(operand, parseInfo->inheritNamespacesMode, + parseInfo->preserveNamespacesMode), sl, parseInfo); +} + +static Expression::Ptr createCompatStore(const Expression::Ptr &expr, + const YYLTYPE &sourceLocator, + const ParserContext *const parseInfo) +{ + return create(new StaticCompatibilityStore(expr), sourceLocator, parseInfo); +} + +/** + * @short Creates an Expression that corresponds to <tt>/</tt>. This is literally + * <tt>fn:root(self::node()) treat as document-node()</tt>. + */ +static Expression::Ptr createRootExpression(const ParserContext *const parseInfo, + const YYLTYPE &sl) +{ + Q_ASSERT(parseInfo); + const QXmlName name(StandardNamespaces::fn, StandardLocalNames::root); + + Expression::List args; + args.append(create(new ContextItem(), sl, parseInfo)); + + const ReflectYYLTYPE ryy(sl, parseInfo); + + const Expression::Ptr fnRoot(parseInfo->staticContext->functionSignatures() + ->createFunctionCall(name, args, parseInfo->staticContext, &ryy)); + Q_ASSERT(fnRoot); + + return create(new TreatAs(create(fnRoot, sl, parseInfo), CommonSequenceTypes::ExactlyOneDocumentNode), sl, parseInfo); +} + +static int XPathlex(YYSTYPE *lexVal, YYLTYPE *sourceLocator, const ParserContext *const parseInfo) +{ +#ifdef Patternist_DEBUG_PARSER + /** + * "External integer variable set to zero by default. If yydebug + * is given a nonzero value, the parser will output information on + * input symbols and parser action. See section Debugging Your Parser." + */ +# define YYDEBUG 1 + + extern int XPathdebug; + XPathdebug = 1; +#endif + + Q_ASSERT(parseInfo); + + const Tokenizer::Token tok(parseInfo->tokenizer->nextToken(sourceLocator)); + + (*lexVal).sval = tok.value; + + return static_cast<int>(tok.type); +} + +/** + * @short Creates a path expression which contains the step <tt>//</tt> between + * @p begin and and @p end. + * + * <tt>begin//end</tt> is a short form for: <tt>begin/descendant-or-self::node()/end</tt> + * + * This will be compiled as two-path expression: <tt>(/)/(//.)/step/</tt> + */ +static Expression::Ptr createSlashSlashPath(const Expression::Ptr &begin, + const Expression::Ptr &end, + const YYLTYPE &sourceLocator, + const ParserContext *const parseInfo) +{ + const Expression::Ptr twoSlash(create(new AxisStep(QXmlNodeModelIndex::AxisDescendantOrSelf, BuiltinTypes::node), sourceLocator, parseInfo)); + const Expression::Ptr p1(create(new Path(begin, twoSlash), sourceLocator, parseInfo)); + + return create(new Path(p1, end), sourceLocator, parseInfo); +} + +/** + * @short Creates a call to <tt>fn:concat()</tt> with @p args as the arguments. + */ +static inline Expression::Ptr createConcatFN(const ParserContext *const parseInfo, + const Expression::List &args, + const YYLTYPE &sourceLocator) +{ + Q_ASSERT(parseInfo); + const QXmlName name(StandardNamespaces::fn, StandardLocalNames::concat); + const ReflectYYLTYPE ryy(sourceLocator, parseInfo); + + return create(parseInfo->staticContext->functionSignatures()->createFunctionCall(name, args, parseInfo->staticContext, &ryy), + sourceLocator, parseInfo); +} + +static inline Expression::Ptr createDirAttributeValue(const Expression::List &content, + const ParserContext *const parseInfo, + const YYLTYPE &sourceLocator) +{ + if(content.isEmpty()) + return create(new EmptySequence(), sourceLocator, parseInfo); + else if(content.size() == 1) + return content.first(); + else + return createConcatFN(parseInfo, content, sourceLocator); +} + +/** + * @short Checks for variable initialization circularity. + * + * "A recursive function that checks for recursion is full of ironies." + * + * -- The Salsa Master + * + * Issues an error via @p parseInfo's StaticContext if the initialization + * expression @p checkee for the global variable @p var, contains a variable + * reference to @p var. That is, if there's a circularity. + * + * @see <a href="http://www.w3.org/TR/xquery/#ERRXQST0054">XQuery 1.0: An XML + * Query Language, err:XQST0054</a> + */ +static void checkVariableCircularity(const VariableDeclaration::Ptr &var, + const Expression::Ptr &checkee, + const VariableDeclaration::Type type, + FunctionSignature::List &signList, + const ParserContext *const parseInfo) +{ + Q_ASSERT(var); + Q_ASSERT(checkee); + Q_ASSERT(parseInfo); + + const Expression::ID id = checkee->id(); + + if(id == Expression::IDExpressionVariableReference) + { + const ExpressionVariableReference *const ref = + static_cast<const ExpressionVariableReference *>(checkee.data()); + + if(var->slot == ref->slot() && type == ref->variableDeclaration()->type) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("The initialization of variable %1 " + "depends on itself").arg(formatKeyword(var, parseInfo->staticContext->namePool())), + parseInfo->isXSLT() ? ReportContext::XTDE0640 : ReportContext::XQST0054, ref); + return; + } + else + { + /* If the variable we're checking is below another variable, it can be a recursive + * dependency through functions, so we need to check variable references too. */ + checkVariableCircularity(var, ref->sourceExpression(), type, signList, parseInfo); + return; + } + } + else if(id == Expression::IDUserFunctionCallsite) + { + const UserFunctionCallsite::Ptr callsite(checkee); + const FunctionSignature::Ptr sign(callsite->callTargetDescription()); + const FunctionSignature::List::const_iterator end(signList.constEnd()); + FunctionSignature::List::const_iterator it(signList.constBegin()); + bool noMatch = true; + + for(; it != end; ++it) + { + if(*it == sign) + { + /* The variable we're checking is depending on a function that's recursive. The + * user has written a weird query, in other words. Since it's the second time + * we've encountered a callsite, we now skip it. */ + noMatch = false; + break; + } + } + + if(noMatch) + { + signList.append(sign); + /* Check the body of the function being called. */ + checkVariableCircularity(var, callsite->body(), type, signList, parseInfo); + } + /* Continue with the operands, such that we also check the arguments of the callsite. */ + } + else if(id == Expression::IDUnresolvedVariableReference) + { + /* We're called before it has rewritten itself. */ + checkVariableCircularity(var, checkee->as<UnresolvedVariableReference>()->replacement(), type, signList, parseInfo); + } + + /* Check the operands. */ + const Expression::List ops(checkee->operands()); + if(ops.isEmpty()) + return; + + const Expression::List::const_iterator end(ops.constEnd()); + Expression::List::const_iterator it(ops.constBegin()); + + for(; it != end; ++it) + checkVariableCircularity(var, *it, type, signList, parseInfo); +} + +static void variableUnavailable(const QXmlName &variableName, + const ParserContext *const parseInfo, + const YYLTYPE &location) +{ + parseInfo->staticContext->error(QtXmlPatterns::tr("No variable with name %1 exists") + .arg(formatKeyword(parseInfo->staticContext->namePool(), variableName)), + ReportContext::XPST0008, fromYYLTYPE(location, parseInfo)); +} + +/** + * The Cardinality in a TypeDeclaration for a variable in a quantification has no effect, + * and this function ensures this by changing @p type to Cardinality Cardinality::zeroOrMore(). + * + * @see <a href="http://www.w3.org/Bugs/Public/show_bug.cgi?id=3305">Bugzilla Bug 3305 + * Cardinality + on range variables</a> + * @see ParserContext::finalizePushedVariable() + */ +static inline SequenceType::Ptr quantificationType(const SequenceType::Ptr &type) +{ + Q_ASSERT(type); + return makeGenericSequenceType(type->itemType(), Cardinality::zeroOrMore()); +} + +/** + * @p seqType and @p expr may be @c null. + */ +static Expression::Ptr pushVariable(const QXmlName name, + const SequenceType::Ptr &seqType, + const Expression::Ptr &expr, + const VariableDeclaration::Type type, + const YYLTYPE &sourceLocator, + ParserContext *const parseInfo, + const bool checkSource = true) +{ + Q_ASSERT(!name.isNull()); + Q_ASSERT(parseInfo); + + /* -2 will cause Q_ASSERTs to trigger if it isn't changed. */ + VariableSlotID slot = -2; + + switch(type) + { + case VariableDeclaration::FunctionArgument: + /* Fallthrough. */ + case VariableDeclaration::ExpressionVariable: + { + slot = parseInfo->allocateExpressionSlot(); + break; + } + case VariableDeclaration::GlobalVariable: + { + slot = parseInfo->allocateGlobalVariableSlot(); + break; + } + case VariableDeclaration::RangeVariable: + { + slot = parseInfo->staticContext->allocateRangeSlot(); + break; + } + case VariableDeclaration::PositionalVariable: + { + slot = parseInfo->allocatePositionalSlot(); + break; + } + case VariableDeclaration::TemplateParameter: + /* Fallthrough. We do nothing, template parameters + * doesn't use context slots at all, they're hashed + * on the name. */ + case VariableDeclaration::ExternalVariable: + /* We do nothing, external variables doesn't use + *context slots/stack frames at all. */ + ; + } + + const VariableDeclaration::Ptr var(new VariableDeclaration(name, slot, type, seqType)); + + Expression::Ptr checked; + + if(checkSource && seqType) + { + if(expr) + { + /* We only want to add conversion for function arguments, and variables + * if we're XSL-T. + * + * We unconditionally skip TypeChecker::CheckFocus because the StaticContext we + * pass hasn't set up the focus yet, since that's the parent's responsibility. */ + const TypeChecker::Options options(( type == VariableDeclaration::FunctionArgument + || type == VariableDeclaration::TemplateParameter + || parseInfo->isXSLT()) + ? TypeChecker::AutomaticallyConvert : TypeChecker::Options()); + + checked = TypeChecker::applyFunctionConversion(expr, seqType, parseInfo->staticContext, + parseInfo->isXSLT() ? ReportContext::XTTE0570 : ReportContext::XPTY0004, + options); + } + } + else + checked = expr; + + /* Add an evaluation cache for all expression variables. No EvaluationCache is needed for + * positional variables because in the end they are calls to Iterator::position(). Similarly, + * no need to cache range variables either because they are calls to DynamicContext::rangeVariable(). + * + * We don't do it for function arguments because the Expression being cached depends -- it depends + * on the callsite. UserFunctionCallsite is responsible for the evaluation caches in that case. + * + * In some cases the EvaluationCache instance isn't necessary, but in those cases EvaluationCache + * optimizes itself away. */ + if(type == VariableDeclaration::ExpressionVariable) + checked = create(new EvaluationCache<false>(checked, var, parseInfo->allocateCacheSlot()), sourceLocator, parseInfo); + else if(type == VariableDeclaration::GlobalVariable) + checked = create(new EvaluationCache<true>(checked, var, parseInfo->allocateCacheSlot()), sourceLocator, parseInfo); + + var->setExpression(checked); + + parseInfo->variables.push(var); + return checked; +} + +static inline VariableDeclaration::Ptr variableByName(const QXmlName name, + const ParserContext *const parseInfo) +{ + Q_ASSERT(!name.isNull()); + Q_ASSERT(parseInfo); + + /* We walk the list backwards. */ + const VariableDeclaration::Stack::const_iterator start(parseInfo->variables.constBegin()); + VariableDeclaration::Stack::const_iterator it(parseInfo->variables.constEnd()); + + while(it != start) + { + --it; + Q_ASSERT(*it); + if((*it)->name == name) + return *it; + } + + return VariableDeclaration::Ptr(); +} + +static Expression::Ptr resolveVariable(const QXmlName &name, + const YYLTYPE &sourceLocator, + ParserContext *const parseInfo, + const bool raiseErrorOnUnavailability) +{ + const VariableDeclaration::Ptr var(variableByName(name, parseInfo)); + Expression::Ptr retval; + + if(var && var->type != VariableDeclaration::ExternalVariable) + { + switch(var->type) + { + case VariableDeclaration::RangeVariable: + { + retval = create(new RangeVariableReference(var->expression(), var->slot), sourceLocator, parseInfo); + break; + } + case VariableDeclaration::GlobalVariable: + /* Fallthrough. From the perspective of an ExpressionVariableReference, it can't tell + * a difference between a global and a local expression variable. However, the cache + * mechanism must. */ + case VariableDeclaration::ExpressionVariable: + { + retval = create(new ExpressionVariableReference(var->slot, var), sourceLocator, parseInfo); + break; + } + case VariableDeclaration::FunctionArgument: + { + retval = create(new ArgumentReference(var->sequenceType, var->slot), sourceLocator, parseInfo); + break; + } + case VariableDeclaration::PositionalVariable: + { + retval = create(new PositionalVariableReference(var->slot), sourceLocator, parseInfo); + break; + } + case VariableDeclaration::TemplateParameter: + { + retval = create(new TemplateParameterReference(var), sourceLocator, parseInfo); + break; + } + case VariableDeclaration::ExternalVariable: + /* This code path will never be hit, but the case + * label silences a warning. See above. */ + ; + } + Q_ASSERT(retval); + var->references.append(retval); + } + else + { + /* Let's see if your external variable loader can provide us with one. */ + const SequenceType::Ptr varType(parseInfo->staticContext-> + externalVariableLoader()->announceExternalVariable(name, CommonSequenceTypes::ZeroOrMoreItems)); + + if(varType) + { + const Expression::Ptr extRef(create(new ExternalVariableReference(name, varType), sourceLocator, parseInfo)); + const Expression::Ptr checked(TypeChecker::applyFunctionConversion(extRef, varType, parseInfo->staticContext)); + retval = checked; + } + else if(!raiseErrorOnUnavailability && parseInfo->isXSLT()) + { + /* In XSL-T, global variables are in scope for the whole + * stylesheet, so we must resolve this first at the end. */ + retval = create(new UnresolvedVariableReference(name), sourceLocator, parseInfo); + parseInfo->unresolvedVariableReferences.insert(name, retval); + } + else + variableUnavailable(name, parseInfo, sourceLocator); + } + + return retval; +} + +static Expression::Ptr createReturnOrderBy(const OrderSpecTransfer::List &orderSpecTransfer, + const Expression::Ptr &returnExpr, + const OrderBy::Stability stability, + const YYLTYPE &sourceLocator, + const ParserContext *const parseInfo) +{ + // TODO do resize(orderSpec.size() + 1) + Expression::List exprs; + OrderBy::OrderSpec::Vector orderSpecs; + + exprs.append(returnExpr); + + const int len = orderSpecTransfer.size(); + + for(int i = 0; i < len; ++i) + { + exprs.append(orderSpecTransfer.at(i).expression); + orderSpecs.append(orderSpecTransfer.at(i).orderSpec); + } + + return create(new ReturnOrderBy(stability, orderSpecs, exprs), sourceLocator, parseInfo); +} + +%} + +/* This grammar shouldn't be compiled with anything older than the Bison version + * specified below. This '%require' directive was introduced in Bison 2.2. */ +%require "2.3a" + +%name-prefix="XPath" + +/* Specifies the name of the generated parser. */ +%output="qquerytransformparser.cpp" + +/* Output the .output file. */ +%verbose + +/* Yes, we want descriptive error messages. */ +%error-verbose + +/* We'd like to be reentrant/thread-safe */ +%pure-parser + +/* We want code for line/columns to be generated. */ +%locations + +/* Create a header file and put declarations there. */ +%defines + +%parse-param {ParserContext *const parseInfo} +%lex-param {ParserContext *const parseInfo} + +%expect 4 +/* Silences the following: + +state 327 + + 293 SequenceType: ItemType . OccurrenceIndicator + + "+" shift, and go to state 379 + "*" shift, and go to state 380 + "?" shift, and go to state 381 + + "+" [reduce using rule 295 (OccurrenceIndicator)] + "*" [reduce using rule 295 (OccurrenceIndicator)] + $default reduce using rule 295 (OccurrenceIndicator) + + OccurrenceIndicator go to state 382 + +state 45 + + 200 PathExpr: "/" . RelativePathExpr + 203 | "/" . + + [...] + + "<" [reduce using rule 203 (PathExpr)] + "*" [reduce using rule 203 (PathExpr)] + $default reduce using rule 203 (PathExpr) +*/ + +%token <sval> STRING_LITERAL "<string literal>" + +/** + * This token is only used in element content and signals content that + * is not Boundary whitespace. Nevertheless, the token value can be all whitespace, + * but it was specified using character references or CDATA sections by the user. */ +%token <sval> NON_BOUNDARY_WS "<non-boundary text node>" + +/* XPath 2.0 allows quotes and apostrophes to be escaped with "" and ''; this token is + is used for XPath 2.0 literals such that we can flag syntax errors if running in + 1.0 mode. */ +%token <sval> XPATH2_STRING_LITERAL "<string literal(XPath 2.0)>" +%token <sval> QNAME "QName" +%token <sval> NCNAME "NCName" + +/* A QName as a clark name. See QXmlName::toClarkName(). */ +%token <sval> CLARK_NAME "ClarkName" + +/** + * Is "ncname:*". The token value does not include the colon and the star. + */ +%token <sval> ANY_LOCAL_NAME + +/** + * Is "*:ncname". The token value does not include the colon and the star. + */ +%token <sval> ANY_PREFIX + +/** + * An XPath 1.0 number literal. It is a string value because + * Numeric::fromLexical() does the tokenization. + */ +%token <sval> NUMBER "<number literal>" + +/** + * XPath 2.0 number literal. It includes the use of 'e'/'E' + */ +%token <sval> XPATH2_NUMBER "<number literal(XPath 2.0)>" + +%token ANCESTOR "ancestor" +%token ANCESTOR_OR_SELF "ancestor-or-self" +%token AND "and" +%token APOS "'" +%token APPLY_TEMPLATE "apply-template" +%token AS "as" +%token ASCENDING "ascending" +%token ASSIGN ":=" +%token AT "at" +%token AT_SIGN "@" +%token ATTRIBUTE "attribute" +%token AVT /* Synthetic token. Signals an attribute value template. */ +%token BAR "|" +%token BASEURI "base-uri" +%token BEGIN_END_TAG "</" +%token BOUNDARY_SPACE "boundary-space" +%token BY "by" +%token CALL_TEMPLATE "call-template" +%token CASE "case" +%token CASTABLE "castable" +%token CAST "cast" +%token CHILD "child" +%token COLLATION "collation" +%token COLONCOLON "::" +%token COMMA "," +%token COMMENT "comment" +%token COMMENT_START "<!--" +%token CONSTRUCTION "construction" +%token COPY_NAMESPACES "copy-namespaces" +%token CURLY_LBRACE "{" +%token CURLY_RBRACE "}" +%token DECLARE "declare" +%token DEFAULT "default" +%token DESCENDANT "descendant" +%token DESCENDANT_OR_SELF "descendant-or-self" +%token DESCENDING "descending" +%token DIV "div" +%token DOCUMENT "document" +%token DOCUMENT_NODE "document-node" +%token DOLLAR "$" +%token DOT "." +%token DOTDOT ".." +%token ELEMENT "element" +%token ELSE "else" +%token EMPTY "empty" +%token EMPTY_SEQUENCE "empty-sequence" +%token ENCODING "encoding" +%token END_OF_FILE 0 "end of file" +%token END_SORT "end_sort" +%token EQ "eq" +%token ERROR "unknown keyword" /* Used by the Tokenizer. We use the phrase "keyword" instead of "token" to be less pointy. */ +%token EVERY "every" +%token EXCEPT "except" +%token EXTERNAL "external" +%token FOLLOWING "following" +%token FOLLOWING_SIBLING "following-sibling" +%token FOLLOWS ">>" +%token FOR_APPLY_TEMPLATE "for-apply-template" /* Synthetic token, used in XSL-T. */ +%token FOR "for" +%token FUNCTION "function" +%token GE "ge" +%token G_EQ "=" +%token G_GE ">=" +%token G_GT ">" +%token G_LE "<=" +%token G_LT "<" +%token G_NE "!=" +%token GREATEST "greatest" +%token GT "gt" +%token IDIV "idiv" +%token IF "if" +%token IMPORT "import" +%token INHERIT "inherit" +%token IN "in" +%token INSTANCE "instance" +%token INTERSECT "intersect" +%token IS "is" +%token ITEM "item" +%token LAX "lax" +%token LBRACKET "[" +%token LEAST "least" +%token LE "le" +%token LET "let" +%token LPAREN "(" +%token LT "lt" +%token MAP "map" /* Synthetic token, used in XSL-T. */ +%token MATCHES "matches" +%token MINUS "-" +%token MODE "mode" /* Synthetic token, used in XSL-T. */ +%token MOD "mod" +%token MODULE "module" +%token NAME "name" +%token NAMESPACE "namespace" +%token NE "ne" +%token NODE "node" +%token NO_INHERIT "no-inherit" +%token NO_PRESERVE "no-preserve" +%token OF "of" +%token OPTION "option" +%token ORDERED "ordered" +%token ORDERING "ordering" +%token ORDER "order" +%token OR "or" +%token PARENT "parent" +%token PI_START "<?" +%token PLUS "+" +%token POSITION_SET /* Synthetic token. */ +%token PRAGMA_END "#)" +%token PRAGMA_START "(#" +%token PRECEDES "<<" +%token PRECEDING "preceding" +%token PRECEDING_SIBLING "preceding-sibling" +%token PRESERVE "preserve" +%token PRIORITY "priority" +%token PROCESSING_INSTRUCTION "processing-instruction" +%token QUESTION "?" +%token QUICK_TAG_END "/>" +%token QUOTE "\"" +%token RBRACKET "]" +%token RETURN "return" +%token RPAREN ")" +%token SATISFIES "satisfies" +%token SCHEMA_ATTRIBUTE "schema-attribute" +%token SCHEMA_ELEMENT "schema-element" +%token SCHEMA "schema" +%token SELF "self" +%token SEMI_COLON ";" +%token SLASH "/" +%token SLASHSLASH "//" +%token SOME "some" +%token SORT "sort" /* Synthetic token, used in XSL-T. */ +%token STABLE "stable" +%token STAR "*" +%token STRICT "strict" +%token STRIP "strip" +%token SUCCESS /* Synthetic token, used by the Tokenizer. */ +%token <sval> COMMENT_CONTENT +%token <sval> PI_CONTENT +%token <sval> PI_TARGET +%token <sval> XSLT_VERSION /* Synthetic token, used in XSL-T. */ +%token TEMPLATE "template" +%token TEXT "text" +%token THEN "then" +%token TO "to" +%token TREAT "treat" +%token TUNNEL "tunnel" /* Synthetic token, used in XSL-T. */ +%token TYPESWITCH "typeswitch" +%token UNION "union" +%token UNORDERED "unordered" +%token VALIDATE "validate" +%token VARIABLE "variable" +%token VERSION "version" +%token WHERE "where" +%token XQUERY "xquery" +%token INTERNAL "internal" /* Synthetic token, used in XSL-T. */ +%token INTERNAL_NAME "internal-name" /* Synthetic token, used in XSL-T. */ +%token CURRENT "current" /* Synthetic token, used in XSL-T. */ + +/* Alphabetically. */ +%type <attributeHolder> Attribute +%type <attributeHolders> DirAttributeList +%type <cardinality> OccurrenceIndicator +%type <enums.axis> Axis AxisToken +%type <enums.boundarySpacePolicy> BoundarySpacePolicy +%type <enums.combinedNodeOp> IntersectOperator +%type <enums.constructionMode> ConstructionMode +%type <enums.mathOperator> MultiplyOperator AdditiveOperator UnaryOperator +%type <enums.nodeOperator> NodeOperator +%type <enums.orderingEmptySequence> OrderingEmptySequence EmptynessModifier +%type <enums.sortDirection> DirectionModifier + +%type <enums.orderingMode> OrderingMode +%type <enums.slot> PositionalVar +%type <enums.validationMode> ValidationMode +%type <enums.valueOperator> ValueComparisonOperator GeneralComparisonOperator +%type <expr> OrExpr AndExpr ComparisonExpr UnionExpr Literal + AdditiveExpr MultiplicativeExpr PrimaryExpr FilterExpr + StepExpr PathExpr RelativePathExpr Expr ExprSingle + VarRef ContextItemExpr IfExpr CastExpr CastableExpr + TreatExpr InstanceOfExpr ValueExpr UnaryExpr NodeComp + IntersectExceptExpr RangeExpr ParenthesizedExpr + ValueComp FunctionCallExpr GeneralComp ForClause + WhereClause FLWORExpr ForTail QuantifiedExpr QueryBody + SomeQuantificationExpr SomeQuantificationTail + EveryQuantificationExpr EveryQuantificationTail + ExtensionExpr EnclosedOptionalExpr VariableValue + EnclosedExpr FunctionBody ValidateExpr NumericLiteral + OrderingExpr TypeswitchExpr LetClause LetTail + Constructor DirectConstructor DirElemConstructor + ComputedConstructor CompDocConstructor CompElemConstructor + CompTextConstructor CompCommentConstructor CompPIConstructor + DirPIConstructor CompAttrConstructor DirElemConstructorTail + AxisStep ForwardStep ReverseStep AbbrevForwardStep + CaseDefault CaseClause CaseTail CompAttributeName + FilteredAxisStep DirCommentConstructor CompPIName + DirAttributeValue AbbrevReverseStep CompNamespaceConstructor + CompElementName CompNameExpr SatisfiesClause Pattern PathPattern + PatternStep RelativePathPattern IdKeyPattern OptionalAssign + OptionalDefaultValue + +%type <orderSpec> OrderSpec +%type <expressionList> ExpressionSequence FunctionArguments + DirElemContent AttrValueContent +%type <orderSpecs> OrderSpecList OrderByClause MandatoryOrderByClause +%type <functionArgument> Param +%type <functionArguments> ParamList +%type <itemType> KindTest ItemType AtomicType NodeTest NameTest WildCard NodeTestInAxisStep + ElementTest AttributeTest SchemaElementTest SchemaAttributeTest + TextTest CommentTest PITest DocumentTest AnyKindTest AnyAttributeTest +%type <qName> ElementName QName VarName FunctionName PragmaName TypeName NCName + CaseVariable AttributeName OptionalTemplateName + TemplateName Mode OptionalMode +%type <qNameVector> Modes OptionalModes +%type <sequenceType> SequenceType SingleType TypeDeclaration +%type <sval> URILiteral StringLiteral LexicalName +%type <enums.Bool> IsInternal IsTunnel +%type <enums.Double> OptionalPriority +%type <enums.pathKind> MapOrSlash + +/* Operator Precendence + * See: http://www.w3.org/TR/xpath20/#parse-note-occurrence-indicators */ +%left STAR DIV +%left PLUS MINUS + +%% + +/* Here, the grammar starts. In the brackets on the right you + * find the number of corresponding EBNF rule in the XQuery 1.0 specification. If it + * contains an X, it means the non-terminal has no counter part in the grammar, but + * exists for implementation purposes. */ +Module: VersionDecl LibraryModule /* [1] */ +| VersionDecl MainModule + +VersionDecl: /* empty */ /* [2] */ +| XQUERY VERSION StringLiteral Encoding Separator + { + +/* Suppress more compiler warnings about unused defines. */ +#if defined(YYNNTS) \ + || defined(yyerrok) \ + || defined(YYNSTATES) \ + || defined(YYRHSLOC) \ + || defined(YYRECOVERING) \ + || defined(YYFAIL) \ + || defined(YYERROR) \ + || defined(YYNRULES) \ + || defined(YYBACKUP) \ + || defined(YYMAXDEPTH) \ + || defined(yyclearin) \ + || defined(YYERRCODE) \ + || defined(YY_LOCATION_PRINT) \ + || defined(YYLLOC_DEFAULT) +#endif + + if($3 != QLatin1String("1.0")) + { + const ReflectYYLTYPE ryy(@$, parseInfo); + + parseInfo->staticContext->error(QtXmlPatterns::tr("Version %1 is not supported. The supported " + "XQuery version is 1.0.") + .arg(formatData($3)), + ReportContext::XQST0031, &ryy); + } + } + +Encoding: /* empty */ /* [X] */ +| ENCODING StringLiteral + { + const QRegExp encNameRegExp(QLatin1String("[A-Za-z][A-Za-z0-9._\\-]*")); + + if(!encNameRegExp.exactMatch($2)) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("The encoding %1 is invalid. " + "It must contain Latin characters only, " + "must not contain whitespace, and must match " + "the regular expression %2.") + .arg(formatKeyword((yyvsp[(2) - (2)].sval)), + formatExpression(encNameRegExp.pattern())), + ReportContext::XQST0087, fromYYLTYPE(@$, parseInfo)); + } + } + +MainModule: Prolog QueryBody /* [3] */ + { + /* In XSL-T, we can have dangling variable references, so resolve them + * before we proceed with other steps, such as checking circularity. */ + if(parseInfo->isXSLT()) + { + typedef QHash<QXmlName, Expression::Ptr> Hash; + const Hash::const_iterator end(parseInfo->unresolvedVariableReferences.constEnd()); + + for(Hash::const_iterator it(parseInfo->unresolvedVariableReferences.constBegin()); it != end; ++it) + { + const Expression::Ptr body(resolveVariable(it.key(), @$, parseInfo, true)); // TODO source locations vaise + Q_ASSERT(body); + it.value()->as<UnresolvedVariableReference>()->bindTo(body); + } + } + + /* The UserFunction callsites aren't bound yet, so bind them(if possible!). */ + { + const UserFunctionCallsite::List::const_iterator cend(parseInfo->userFunctionCallsites.constEnd()); + UserFunctionCallsite::List::const_iterator cit(parseInfo->userFunctionCallsites.constBegin()); + for(; cit != cend; ++cit) /* For each callsite. */ + { + const UserFunctionCallsite::Ptr callsite(*cit); + Q_ASSERT(callsite); + const UserFunction::List::const_iterator end(parseInfo->userFunctions.constEnd()); + UserFunction::List::const_iterator it(parseInfo->userFunctions.constBegin()); + + for(; it != end; ++it) /* For each UserFunction. */ + { + const FunctionSignature::Ptr sign((*it)->signature()); + Q_ASSERT(sign); + + if(callsite->isSignatureValid(sign)) + { + callsite->setSource((*it), + parseInfo->allocateCacheSlots((*it)->argumentDeclarations().count())); + break; + } + } + if(it == end) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("No function with signature %1 is available") + .arg(formatFunction(callsite)), + ReportContext::XPST0017, fromYYLTYPE(@$, parseInfo)); + } + } + } + + /* Mark callsites in UserFunction bodies as recursive, if they are. */ + { + const UserFunction::List::const_iterator fend(parseInfo->userFunctions.constEnd()); + UserFunction::List::const_iterator fit(parseInfo->userFunctions.constBegin()); + for(; fit != fend; ++fit) + { + CallTargetDescription::List signList; + signList.append((*fit)->signature()); + CallTargetDescription::checkCallsiteCircularity(signList, (*fit)->body()); + } + } + + /* Now, check all global variables for circularity. This is done + * backwards because global variables are only in scope below them, + * in XQuery. */ + { + const VariableDeclaration::List::const_iterator start(parseInfo->declaredVariables.constBegin()); + VariableDeclaration::List::const_iterator it(parseInfo->declaredVariables.constEnd()); + + while(it != start) + { + --it; + if((*it)->type != VariableDeclaration::ExpressionVariable && (*it)->type != VariableDeclaration::GlobalVariable) + continue; /* We want to ignore 'external' variables. */ + + FunctionSignature::List signList; + checkVariableCircularity(*it, (*it)->expression(), (*it)->type, signList, parseInfo); + ExpressionFactory::registerLastPath((*it)->expression()); + parseInfo->finalizePushedVariable(1, false); /* Warn if it's unused. */ + } + } + + /* Generate code for doing initial template name calling. One problem + * is that we compilation in the initial template name, since we throw away the + * code if we don't have the requested template. */ + if(parseInfo->languageAccent == QXmlQuery::XSLT20 + && !parseInfo->initialTemplateName.isNull() + && parseInfo->namedTemplates.contains(parseInfo->initialTemplateName)) + { + parseInfo->queryBody = create(new CallTemplate(parseInfo->initialTemplateName, + WithParam::Hash()), + @$, parseInfo); + parseInfo->templateCalls.append(parseInfo->queryBody); + /* We just discard the template body that XSLTTokenizer generated. */ + } + else + parseInfo->queryBody = $2; + } + +LibraryModule: ModuleDecl Prolog /* [4] */ + +ModuleDecl: MODULE NAMESPACE NCNAME G_EQ URILiteral Separator /* [5] */ + { + // TODO add to namespace context + parseInfo->moduleNamespace = parseInfo->staticContext->namePool()->allocateNamespace($3); + } + +Prolog: /* Empty. */ /* [6] */ +/* First part. */ +| Prolog DefaultNamespaceDecl + { + allowedIn(QXmlQuery::XQuery10, parseInfo, @$); + if(parseInfo->hasSecondPrologPart) + parseInfo->staticContext->error(QtXmlPatterns::tr("A default namespace declaration must occur before function, " + "variable, and option declarations."), ReportContext::XPST0003, fromYYLTYPE(@$, parseInfo)); + } +| Prolog Setter + { + if(parseInfo->hasSecondPrologPart) + parseInfo->staticContext->error(QtXmlPatterns::tr("A default namespace declaration must occur before function, " + "variable, and option declarations."), ReportContext::XPST0003, fromYYLTYPE(@$, parseInfo)); + } +| Prolog NamespaceDecl + { + if(parseInfo->hasSecondPrologPart) + parseInfo->staticContext->error(QtXmlPatterns::tr("Namespace declarations must occur before function, " + "variable, and option declarations."), ReportContext::XPST0003, fromYYLTYPE(@$, parseInfo)); + } +| Prolog Import + { + allowedIn(QXmlQuery::XQuery10, parseInfo, @$); + if(parseInfo->hasSecondPrologPart) + parseInfo->staticContext->error(QtXmlPatterns::tr("Module imports must occur before function, " + "variable, and option declarations."), ReportContext::XPST0003, fromYYLTYPE(@$, parseInfo)); + } +| Prolog TemplateDecl + +/* Second part. */ +| Prolog VarDecl + { + parseInfo->hasSecondPrologPart = true; + } +| Prolog FunctionDecl + { + parseInfo->hasSecondPrologPart = true; + } +| Prolog OptionDecl + { + allowedIn(QXmlQuery::XQuery10, parseInfo, @$); + parseInfo->hasSecondPrologPart = true; + } + +/* + * declare template name theName + * { + * "expression" + * }; + * + * or + * + * declare template name theName matches (pattern) mode modeName priority 123 + * { + * "expression" + * }; + * + */ +TemplateDecl: DECLARE TEMPLATE TemplateName + OptionalTemplateParameters + TypeDeclaration + EnclosedOptionalExpr Separator /* [X] */ + { + Template::Ptr temp(create(new Template(parseInfo->currentImportPrecedence, $5), @$, parseInfo)); + + registerNamedTemplate($3, typeCheckTemplateBody($6, $5, parseInfo), + parseInfo, @1, temp); + temp->templateParameters = parseInfo->templateParameters; + parseInfo->templateParametersHandled(); + } +| DECLARE TEMPLATE OptionalTemplateName + MATCHES LPAREN + { + parseInfo->isParsingPattern = true; + } + Pattern + { + parseInfo->isParsingPattern = false; + } + RPAREN + OptionalModes + OptionalPriority + OptionalTemplateParameters + TypeDeclaration + EnclosedOptionalExpr Separator /* [X] */ + { + /* In this grammar branch, we're guaranteed to be a template rule, but + * may also be a named template. */ + + const ImportPrecedence ip = parseInfo->isFirstTemplate() ? 0 : parseInfo->currentImportPrecedence; + Expression::Ptr pattern($7); + const TemplatePattern::ID templateID = parseInfo->allocateTemplateID(); + + Template::Ptr templ(create(new Template(ip, $13), @$, parseInfo)); + templ->body = typeCheckTemplateBody($14, $13, parseInfo); + templ->templateParameters = parseInfo->templateParameters; + parseInfo->templateParametersHandled(); + + TemplatePattern::Vector ourPatterns; + /* We do it as per 6.4 Conflict Resolution for Template Rules: + * + * "If the pattern contains multiple alternatives separated by |, then + * the template rule is treated equivalently to a set of template + * rules, one for each alternative. However, it is not an error if a + * node matches more than one of the alternatives." */ + while(pattern->is(Expression::IDCombineNodes)) + { + const Expression::List operands(pattern->operands()); + pattern = operands.first(); + + loadPattern(operands.at(1), ourPatterns, templateID, $11, templ); + } + + loadPattern(pattern, ourPatterns, templateID, $11, templ); + + if(!$3.isNull()) + registerNamedTemplate($3, $14, parseInfo, @1, templ); + + /* Now, let's add it to all the relevant templates. */ + for(int i = 0; i < $10.count(); ++i) /* For each mode. */ + { + const QXmlName &modeName = $10.at(i); + + if(modeName == QXmlName(StandardNamespaces::InternalXSLT, StandardLocalNames::all) && $10.count() > 1) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("The keyword %1 cannot occur with any other mode name.") + .arg(formatKeyword(QLatin1String("#all"))), + ReportContext::XTSE0530, + fromYYLTYPE(@$, parseInfo)); + } + + /* For each pattern the template use. */ + const TemplateMode::Ptr mode(parseInfo->modeFor(modeName)); + for(int t = 0; t < ourPatterns.count(); ++t) + mode->templatePatterns.append(ourPatterns.at(t)); + } + } + +OptionalPriority: /* Empty. */ /* [X] */ + { + $$ = std::numeric_limits<xsDouble>::quiet_NaN(); + } + +| PRIORITY StringLiteral + { + const AtomicValue::Ptr val(Decimal::fromLexical($2)); + if(val->hasError()) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("The value of attribute %1 must be of type %2, which %3 isn't.") + .arg(formatKeyword(QLatin1String("priority")), + formatType(parseInfo->staticContext->namePool(), BuiltinTypes::xsDecimal), + formatData($2)), + ReportContext::XTSE0530, + fromYYLTYPE(@$, parseInfo)); + } + else + $$ = val->as<Numeric>()->toDouble(); + } + +OptionalTemplateName: /* Empty. */ /* [X] */ + { + $$ = QXmlName(); + } +| TemplateName + +TemplateName: NAME ElementName + { + $$ = $2; + } + +Setter: BoundarySpaceDecl /* [7] */ +| DefaultCollationDecl + { + allowedIn(QXmlQuery::XQuery10, parseInfo, @$); + } +| BaseURIDecl +| ConstructionDecl + { + allowedIn(QXmlQuery::XQuery10, parseInfo, @$); + } +| OrderingModeDecl + { + allowedIn(QXmlQuery::XQuery10, parseInfo, @$); + } +| EmptyOrderDecl + { + allowedIn(QXmlQuery::XQuery10, parseInfo, @$); + } +| CopyNamespacesDecl + +Import: SchemaImport /* [8] */ +| ModuleImport + +Separator: SEMI_COLON /* [9] */ + +NamespaceDecl: DECLARE NAMESPACE NCNAME G_EQ URILiteral IsInternal Separator /* [10] */ + { + if(!$6) + allowedIn(QXmlQuery::XQuery10, parseInfo, @$); + + if($3 == QLatin1String("xmlns")) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("It is not possible to redeclare prefix %1.") + .arg(formatKeyword(QLatin1String("xmlns"))), + ReportContext::XQST0070, fromYYLTYPE(@$, parseInfo)); + } + else if ($5 == CommonNamespaces::XML || $3 == QLatin1String("xml")) + { + parseInfo->staticContext->error(QtXmlPatterns::tr( + "The prefix %1 can not be bound. By default, it is already bound " + "to the namespace %2.") + .arg(formatKeyword("xml")) + .arg(formatURI(CommonNamespaces::XML)), + ReportContext::XQST0070, + fromYYLTYPE(@$, parseInfo)); + } + else if(parseInfo->declaredPrefixes.contains($3)) + { + /* This includes the case where the user has bound a default prefix(such + * as 'local') and now tries to do it again. */ + parseInfo->staticContext->error(QtXmlPatterns::tr("Prefix %1 is already declared in the prolog.") + .arg(formatKeyword($3)), + ReportContext::XQST0033, fromYYLTYPE(@$, parseInfo)); + } + else + { + parseInfo->declaredPrefixes.append($3); + + if($5.isEmpty()) + { + parseInfo->staticContext->namespaceBindings()->addBinding(QXmlName(StandardNamespaces::UndeclarePrefix, + StandardLocalNames::empty, + parseInfo->staticContext->namePool()->allocatePrefix($3))); + } + else + { + parseInfo->staticContext->namespaceBindings()->addBinding(parseInfo->staticContext->namePool()->allocateBinding($3, $5)); + } + } + } + +BoundarySpaceDecl: DECLARE BOUNDARY_SPACE BoundarySpacePolicy Separator /* [11] */ + { + if(parseInfo->hasDeclaration(ParserContext::BoundarySpaceDecl)) + { + parseInfo->staticContext->error(prologMessage("declare boundary-space"), + ReportContext::XQST0068, fromYYLTYPE(@$, parseInfo)); + } + else + { + parseInfo->staticContext->setBoundarySpacePolicy($3); + parseInfo->registerDeclaration(ParserContext::BoundarySpaceDecl); + } + } + +BoundarySpacePolicy: STRIP /* [X] */ + { + $$ = StaticContext::BSPStrip; + } + +| PRESERVE + { + $$ = StaticContext::BSPPreserve; + } + +DefaultNamespaceDecl: DeclareDefaultElementNamespace /* [12] */ +| DeclareDefaultFunctionNamespace + +DeclareDefaultElementNamespace: DECLARE DEFAULT ELEMENT NAMESPACE + URILiteral Separator /* [X] */ + { + if(parseInfo->hasDeclaration(ParserContext::DeclareDefaultElementNamespace)) + { + parseInfo->staticContext->error(prologMessage("declare default element namespace"), + ReportContext::XQST0066, fromYYLTYPE(@$, parseInfo)); + } + else + { + parseInfo->staticContext->namespaceBindings()->addBinding(QXmlName(parseInfo->staticContext->namePool()->allocateNamespace($5), StandardLocalNames::empty)); + parseInfo->registerDeclaration(ParserContext::DeclareDefaultElementNamespace); + } + } + +DeclareDefaultFunctionNamespace: DECLARE DEFAULT FUNCTION NAMESPACE + URILiteral Separator /* [X] */ + { + if(parseInfo->hasDeclaration(ParserContext::DeclareDefaultFunctionNamespace)) + { + parseInfo->staticContext->error(prologMessage("declare default function namespace"), + ReportContext::XQST0066, fromYYLTYPE(@$, parseInfo)); + } + else + { + parseInfo->staticContext->setDefaultFunctionNamespace($5); + parseInfo->registerDeclaration(ParserContext::DeclareDefaultFunctionNamespace); + } + } + +OptionDecl: DECLARE OPTION ElementName StringLiteral Separator /* [13] */ + { + if($3.prefix() == StandardPrefixes::empty) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("The name of an option must have a prefix. " + "There is no default namespace for options."), + ReportContext::XPST0081, fromYYLTYPE(@$, parseInfo)); + } + } + +OrderingModeDecl: DECLARE ORDERING OrderingMode Separator /* [14] */ + { + allowedIn(QXmlQuery::XQuery10, parseInfo, @$); + if(parseInfo->hasDeclaration(ParserContext::OrderingModeDecl)) + { + parseInfo->staticContext->error(prologMessage("declare ordering"), + ReportContext::XQST0065, fromYYLTYPE(@$, parseInfo)); + } + else + { + parseInfo->registerDeclaration(ParserContext::OrderingModeDecl); + parseInfo->staticContext->setOrderingMode($3); + } + } + +OrderingMode: ORDERED + { + $$ = StaticContext::Ordered; + } +| UNORDERED + { + $$ = StaticContext::Unordered; + } + +EmptyOrderDecl: DECLARE DEFAULT ORDER OrderingEmptySequence Separator /* [15] */ + { + if(parseInfo->hasDeclaration(ParserContext::EmptyOrderDecl)) + { + parseInfo->staticContext->error(prologMessage("declare default order"), + ReportContext::XQST0069, fromYYLTYPE(@$, parseInfo)); + } + else + { + parseInfo->registerDeclaration(ParserContext::EmptyOrderDecl); + parseInfo->staticContext->setOrderingEmptySequence($4); + } + } + +OrderingEmptySequence: EMPTY LEAST /* [X] */ + { + $$ = StaticContext::Least; + } +| EMPTY GREATEST + { + $$ = StaticContext::Greatest; + } + +CopyNamespacesDecl: DECLARE COPY_NAMESPACES PreserveMode COMMA + InheritMode Separator /* [16] */ + { + if(parseInfo->hasDeclaration(ParserContext::CopyNamespacesDecl)) + { + parseInfo->staticContext->error(prologMessage("declare copy-namespaces"), + ReportContext::XQST0055, fromYYLTYPE(@$, parseInfo)); + } + else + { + parseInfo->registerDeclaration(ParserContext::CopyNamespacesDecl); + } + } + +PreserveMode: PRESERVE /* [17] */ + { + parseInfo->preserveNamespacesMode = true; + } + +| NO_PRESERVE + { + parseInfo->preserveNamespacesMode = false; + } + +InheritMode: INHERIT /* [18] */ + { + parseInfo->inheritNamespacesMode = true; + } + +| NO_INHERIT + { + parseInfo->inheritNamespacesMode = false; + } + +DefaultCollationDecl: DECLARE DEFAULT COLLATION StringLiteral Separator /* [19] */ + { + if(parseInfo->hasDeclaration(ParserContext::DefaultCollationDecl)) + { + parseInfo->staticContext->error(prologMessage("declare default collation"), + ReportContext::XQST0038, fromYYLTYPE(@$, parseInfo)); + } + else + { + const QUrl coll(resolveAndCheckCollation<ReportContext::XQST0038>($4, parseInfo, @$)); + + parseInfo->registerDeclaration(ParserContext::DefaultCollationDecl); + parseInfo->staticContext->setDefaultCollation(coll); + } + } + +BaseURIDecl: DECLARE BASEURI IsInternal URILiteral Separator /* [20] */ + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XSLT20), parseInfo, @$, $3); + if(parseInfo->hasDeclaration(ParserContext::BaseURIDecl)) + { + parseInfo->staticContext->error(prologMessage("declare base-uri"), + ReportContext::XQST0032, fromYYLTYPE(@$, parseInfo)); + } + else + { + parseInfo->registerDeclaration(ParserContext::BaseURIDecl); + const ReflectYYLTYPE ryy(@$, parseInfo); + + QUrl toBeBase(AnyURI::toQUrl<ReportContext::XQST0046>($4, parseInfo->staticContext, &ryy)); + /* Now we're guaranteed that base is a valid lexical representation, but it can still be relative. */ + + if(toBeBase.isRelative()) + toBeBase = parseInfo->staticContext->baseURI().resolved(toBeBase); + + parseInfo->staticContext->setBaseURI(toBeBase); + } + } + +SchemaImport: IMPORT SCHEMA SchemaPrefix URILiteral FileLocations Separator /* [21] */ + { + parseInfo->staticContext->error(QtXmlPatterns::tr("The Schema Import feature is not supported, " + "and therefore %1 declarations cannot occur.") + .arg(formatKeyword("import schema")), + ReportContext::XQST0009, fromYYLTYPE(@$, parseInfo)); + } + +SchemaPrefix: /* empty */ /* [22] */ +| DEFAULT ELEMENT NAMESPACE +| NAMESPACE NCNAME G_EQ + +ModuleImport: IMPORT MODULE ModuleNamespaceDecl URILiteral FileLocations Separator /* [23] */ + { + if($4.isEmpty()) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("The target namespace of a %1 cannot be empty.") + .arg(formatKeyword("module import")), + ReportContext::XQST0088, fromYYLTYPE(@$, parseInfo)); + + } + else + { + /* This is temporary until we have implemented it. */ + parseInfo->staticContext->error(QtXmlPatterns::tr("The module import feature is not supported"), + ReportContext::XQST0016, fromYYLTYPE(@$, parseInfo)); + } + } + +ModuleNamespaceDecl: /* empty */ /* [X] */ +| NAMESPACE NCNAME G_EQ + +FileLocations: /* empty */ /* [X] */ +| AT FileLocation + +FileLocation: URILiteral /* [X] */ +| FileLocation COMMA URILiteral + +VarDecl: DECLARE VARIABLE IsInternal DOLLAR VarName TypeDeclaration + VariableValue OptionalDefaultValue Separator /* [24] */ + { + allowedIn(QXmlQuery::XQuery10, parseInfo, @$, $3); + if(variableByName($5, parseInfo)) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("A variable by name %1 has already " + "been declared.") + .arg(formatKeyword(parseInfo->staticContext->namePool()->toLexical($5))), + parseInfo->isXSLT() ? ReportContext::XTSE0630 : ReportContext::XQST0049, + fromYYLTYPE(@$, parseInfo)); + } + else + { + if($7) /* We got a value assigned. */ + { + const Expression::Ptr checked + (TypeChecker::applyFunctionConversion($7, $6, parseInfo->staticContext, + $3 ? ReportContext::XTTE0570 : ReportContext::XPTY0004, + $3 ? TypeChecker::Options(TypeChecker::CheckFocus | TypeChecker::AutomaticallyConvert) : TypeChecker::CheckFocus)); + + pushVariable($5, $6, checked, VariableDeclaration::GlobalVariable, @$, parseInfo); + parseInfo->declaredVariables.append(parseInfo->variables.last()); + } + else /* We got an 'external' declaration. */ + { + const SequenceType::Ptr varType(parseInfo->staticContext-> + externalVariableLoader()->announceExternalVariable($5, $6)); + + if(varType) + { + /* We push the declaration such that we can see name clashes and so on, but we don't use it for tying + * any references to it. */ + pushVariable($5, varType, Expression::Ptr(), VariableDeclaration::ExternalVariable, @$, parseInfo); + } + else if($8) + { + /* Ok, the xsl:param got a default value, we make it + * available as a regular variable declaration. */ + // TODO turn into checked + pushVariable($5, $6, $8, VariableDeclaration::GlobalVariable, @$, parseInfo); + // TODO ensure that duplicates are trapped. + } + else + { + parseInfo->staticContext->error(QtXmlPatterns::tr("No value is available for the external " + "variable by name %1.") + .arg(formatKeyword(parseInfo->staticContext->namePool(), $5)), + parseInfo->isXSLT() ? ReportContext::XTDE0050 : ReportContext::XPDY0002, + fromYYLTYPE(@$, parseInfo)); + } + } + } + } + +VariableValue: EXTERNAL /* [X] */ + { + $$.reset(); + } +| ASSIGN ExprSingle + { + $$ = $2; + } + +OptionalDefaultValue: /* Empty. */ /* [X] */ + { + $$.reset(); + } +| ASSIGN ExprSingle + { + $$ = $2; + } + +ConstructionDecl: DECLARE CONSTRUCTION ConstructionMode Separator /* [25] */ + { + if(parseInfo->hasDeclaration(ParserContext::ConstructionDecl)) + { + parseInfo->staticContext->error(prologMessage("declare ordering"), + ReportContext::XQST0067, fromYYLTYPE(@$, parseInfo)); + } + else + { + parseInfo->registerDeclaration(ParserContext::ConstructionDecl); + parseInfo->staticContext->setConstructionMode($3); + } + } + +ConstructionMode: STRIP /* [X] */ + { + $$ = StaticContext::CMStrip; + } +| PRESERVE + { + $$ = StaticContext::CMPreserve; + } + +FunctionDecl: DECLARE FUNCTION IsInternal FunctionName LPAREN ParamList RPAREN + { + $<enums.slot>$ = parseInfo->currentExpressionSlot() - $6.count(); + } + TypeDeclaration FunctionBody Separator /* [26] */ + { + if(!$3) + allowedIn(QXmlQuery::XQuery10, parseInfo, @$, $3); + + /* If FunctionBody is null, it is 'external', otherwise the value is the body. */ + const QXmlName::NamespaceCode ns($4.namespaceURI()); + + if(parseInfo->isXSLT() && !$4.hasPrefix()) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("A stylesheet function must have a prefixed name."), + ReportContext::XTSE0740, + fromYYLTYPE(@$, parseInfo)); + } + + if($10) /* We got a function body. */ + { + if(ns == StandardNamespaces::empty) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("The namespace for a user defined function " + "cannot be empty (try the predefined " + "prefix %1 which exists for cases " + "like this)") + .arg(formatKeyword("local")), + ReportContext::XQST0060, fromYYLTYPE(@$, parseInfo)); + } + else if(XPathHelper::isReservedNamespace(ns)) + { + parseInfo->staticContext->error(QtXmlPatterns::tr( + "The namespace %1 is reserved; therefore " + "user defined functions may not use it. " + "Try the predefined prefix %2, which " + "exists for these cases.") + .arg(formatURI(parseInfo->staticContext->namePool(), ns), formatKeyword("local")), + parseInfo->isXSLT() ? ReportContext::XTSE0080 : ReportContext::XQST0045, + fromYYLTYPE(@$, parseInfo)); + } + else if(parseInfo->moduleNamespace != StandardNamespaces::empty && + ns != parseInfo->moduleNamespace) + { + parseInfo->staticContext->error(QtXmlPatterns::tr( + "The namespace of a user defined " + "function in a library module must be " + "equivalent to the module namespace. " + "In other words, it should be %1 instead " + "of %2") + .arg(formatURI(parseInfo->staticContext->namePool(), parseInfo->moduleNamespace), + formatURI(parseInfo->staticContext->namePool(), ns)), + ReportContext::XQST0048, fromYYLTYPE(@$, parseInfo)); + } + else + { + /* Apply function conversion such that the body matches the declared + * return type. */ + const Expression::Ptr checked(TypeChecker::applyFunctionConversion($10, $9, + parseInfo->staticContext, + ReportContext::XPTY0004, + TypeChecker::Options(TypeChecker::AutomaticallyConvert | + TypeChecker::CheckFocus | + TypeChecker::GeneratePromotion))); + + const int argCount = $6.count(); + const FunctionSignature::Ptr sign(new FunctionSignature($4 /* name */, + argCount /* minArgs */, + argCount /* maxArgs */, + $9 /* returnType */)); + sign->setArguments($6); + const UserFunction::List::const_iterator end(parseInfo->userFunctions.constEnd()); + UserFunction::List::const_iterator it(parseInfo->userFunctions.constBegin()); + + for(; it != end; ++it) + { + if(*(*it)->signature() == *sign) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("A function already exists with " + "the signature %1.") + .arg(formatFunction(parseInfo->staticContext->namePool(), sign)), + parseInfo->isXSLT() ? ReportContext::XTSE0770 : ReportContext::XQST0034, fromYYLTYPE(@$, parseInfo)); + } + } + + VariableDeclaration::List argDecls; + + for(int i = 0; i < argCount; ++i) + argDecls.append(parseInfo->variables.at(i)); + + if($<enums.slot>8 > -1) + { + /* We have allocated slots, so now push them out of scope. */ + parseInfo->finalizePushedVariable(argCount); + } + + parseInfo->userFunctions.append(UserFunction::Ptr(new UserFunction(sign, checked, $<enums.slot>8, argDecls))); + } + } + else /* We got an 'external' declaration. */ + { + parseInfo->staticContext->error(QtXmlPatterns::tr("No external functions are supported. " + "All supported functions can be used directly, " + "without first declaring them as external"), + ReportContext::XPST0017, fromYYLTYPE(@$, parseInfo)); + } + } + +ParamList: /* empty */ /* [27] */ + { + $$ = FunctionArgument::List(); + } +| Param + { + FunctionArgument::List l; + l.append($1); + $$ = l; + } +| ParamList COMMA Param + { + FunctionArgument::List::const_iterator it($1.constBegin()); + const FunctionArgument::List::const_iterator end($1.constEnd()); + + for(; it != end; ++it) + { + if((*it)->name() == $3->name()) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("An argument by name %1 has already " + "been declared. Every argument name " + "must be unique.") + .arg(formatKeyword(parseInfo->staticContext->namePool(), $3->name())), + ReportContext::XQST0039, fromYYLTYPE(@$, parseInfo)); + } + } + + $1.append($3); + $$ = $1; + } + +Param: DOLLAR VarName TypeDeclaration /* [28] */ + { + pushVariable($2, $3, Expression::Ptr(), VariableDeclaration::FunctionArgument, @$, parseInfo); + $$ = FunctionArgument::Ptr(new FunctionArgument($2, $3)); + } + +FunctionBody: EXTERNAL /* [X] */ + { + $$.reset(); + } +| EnclosedExpr + +EnclosedExpr: CURLY_LBRACE Expr CURLY_RBRACE /* [29] */ + { + $$ = $2; + } + +QueryBody: Expr /* [30] */ + +/** + * A pattern as found in for instance xsl:template/@match. + * + * @note When using this pattern, remember to set ParserContext::isParsingPattern. + * + * @see <a href="http://www.w3.org/TR/xslt20/#dt-pattern">XSL Transformations + * (XSLT) Version 2.0, 5.5.2 Syntax of Patterns</a> + */ +Pattern: PathPattern /* [XSLT20-1] */ +| Pattern BAR PathPattern + { + $$ = create(new CombineNodes($1, CombineNodes::Union, $3), @$, parseInfo); + } + +PathPattern: RelativePathPattern /* [XSLT20-2] */ +| SLASH + { + /* We write this into a node test. The spec says, 5.5.3 The Meaning of a Pattern: + * "Similarly, / matches a document node, and only a document node, + * because the result of the expression root(.)//(/) returns the root + * node of the tree containing the context node if and only if it is a + * document node." */ + $$ = create(new AxisStep(QXmlNodeModelIndex::AxisSelf, BuiltinTypes::document), @$, parseInfo); + } +| SLASH RelativePathPattern + { + /* /axis::node-test + * => + * axis::node-test[parent::document-node()] + * + * In practice it looks like this. $2 is: + * + * TruthPredicate + * AxisStep self::element(c) + * TruthPredicate + * AxisStep parent::element(b) + * AxisStep parent::element(a) + * + * and we want this: + * + * TruthPredicate + * AxisStep self::element(c) + * TruthPredicate + * AxisStep self::element(b) + * TruthPredicate + * AxisStep parent::element(a) + * AxisStep parent::document() + * + * So we want to rewrite the predicate deepest down into a + * another TruthPredicate containing the AxisStep. + * + * The simplest case where $2 is only an axis step is special. When $2 is: + * + * AxisStep self::element(a) + * + * we want: + * + * TruthPredicate + * AxisStep self::element(a) + * AxisStep parent::document() + */ + + /* First, find the target. */ + Expression::Ptr target($2); + + while(isPredicate(target->id())) + { + const Expression::Ptr candidate(target->operands().at(1)); + + if(isPredicate(candidate->id())) + target = candidate; + else + break; /* target is now the last predicate. */ + } + + if(target->is(Expression::IDAxisStep)) + { + $$ = create(GenericPredicate::create($2, create(new AxisStep(QXmlNodeModelIndex::AxisParent, BuiltinTypes::document), @$, parseInfo), + parseInfo->staticContext, fromYYLTYPE(@1, parseInfo)), @1, parseInfo); + } + else + { + const Expression::List targetOperands(target->operands()); + Expression::List newOps; + newOps.append(targetOperands.at(0)); + + newOps.append(create(GenericPredicate::create(targetOperands.at(1), + create(new AxisStep(QXmlNodeModelIndex::AxisParent, BuiltinTypes::document), @$, parseInfo), + parseInfo->staticContext, fromYYLTYPE(@1, parseInfo)), @1, parseInfo)); + + target->setOperands(newOps); + $$ = $2; + } + } +| SLASHSLASH RelativePathPattern + { + /* //axis::node-test + * => + * axis::node-test[parent::node()] + * + * Spec says: "//para matches any para element that has a parent node." + */ + $$ = create(GenericPredicate::create($2, create(new AxisStep(QXmlNodeModelIndex::AxisParent, BuiltinTypes::node), @$, parseInfo), + parseInfo->staticContext, fromYYLTYPE(@1, parseInfo)), @1, parseInfo); + } +| IdKeyPattern +| IdKeyPattern SLASH RelativePathPattern + { + createIdPatternPath($1, $3, QXmlNodeModelIndex::AxisParent, @2, parseInfo); + } +| IdKeyPattern SLASHSLASH RelativePathPattern + { + createIdPatternPath($1, $3, QXmlNodeModelIndex::AxisAncestor, @2, parseInfo); + } + +IdKeyPattern: FunctionCallExpr + { + const Expression::List ands($1->operands()); + const FunctionSignature::Ptr signature($1->as<FunctionCall>()->signature()); + const QXmlName name(signature->name()); + const QXmlName key(StandardNamespaces::fn, StandardLocalNames::key); + const QXmlName id(StandardNamespaces::fn, StandardLocalNames::id); + + if(name == id) + { + const Expression::ID id = ands.first()->id(); + if(!isVariableReference(id) && id != Expression::IDStringValue) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("When function %1 is used for matching inside a pattern, " + "the argument must be a variable reference or a string literal.") + .arg(formatFunction(parseInfo->staticContext->namePool(), signature)), + ReportContext::XPST0003, + fromYYLTYPE(@$, parseInfo)); + } + } + else if(name == key) + { + if(ands.first()->id() != Expression::IDStringValue) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("In an XSL-T pattern, the first argument to function %1 " + "must be a string literal, when used for matching.") + .arg(formatFunction(parseInfo->staticContext->namePool(), signature)), + ReportContext::XPST0003, + fromYYLTYPE(@$, parseInfo)); + } + + const Expression::ID id2 = ands.at(1)->id(); + if(!isVariableReference(id2) && + id2 != Expression::IDStringValue && + id2 != Expression::IDIntegerValue && + id2 != Expression::IDBooleanValue && + id2 != Expression::IDFloat) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("In an XSL-T pattern, the first argument to function %1 " + "must be a literal or a variable reference, when used for matching.") + .arg(formatFunction(parseInfo->staticContext->namePool(), signature)), + ReportContext::XPST0003, + fromYYLTYPE(@$, parseInfo)); + } + + if(ands.count() == 3) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("In an XSL-T pattern, function %1 cannot have a third argument.") + .arg(formatFunction(parseInfo->staticContext->namePool(), signature)), + ReportContext::XPST0003, + fromYYLTYPE(@$, parseInfo)); + } + + } + else + { + const FunctionSignature::Hash signs(parseInfo->staticContext->functionSignatures()->functionSignatures()); + parseInfo->staticContext->error(QtXmlPatterns::tr("In an XSL-T pattern, only function %1 " + "and %2, not %3, can be used for matching.") + .arg(formatFunction(parseInfo->staticContext->namePool(), signs.value(id)), + formatFunction(parseInfo->staticContext->namePool(), signs.value(key)), + formatFunction(parseInfo->staticContext->namePool(), signature)), + ReportContext::XPST0003, + fromYYLTYPE(@$, parseInfo)); + } + + $$ = $1; + } + +RelativePathPattern: PatternStep /* [XSLT20-3] */ +| RelativePathPattern SLASH PatternStep + { + $$ = createPatternPath($1, $3, QXmlNodeModelIndex::AxisParent, @2, parseInfo); + } +| RelativePathPattern SLASHSLASH PatternStep + { + $$ = createPatternPath($1, $3, QXmlNodeModelIndex::AxisAncestor, @2, parseInfo); + } + +PatternStep: FilteredAxisStep + { + const Expression::Ptr expr(findAxisStep($1)); + + const QXmlNodeModelIndex::Axis axis = expr->as<AxisStep>()->axis(); + AxisStep *const axisStep = expr->as<AxisStep>(); + + /* Here we constrain the possible axes, and we rewrite the axes as according + * to 5.5.3 The Meaning of a Pattern. + * + * However, we also rewrite axis child and attribute to axis self. The + * reason for this is that if we don't, we will match the children of + * the context node, instead of the context node itself. The formal + * definition of a pattern, root(.)//EE is insensitive to context, + * while the way we implement pattern, "the other way of seeing it", + * e.g from right to left, are very much. */ + + if(axisStep->nodeTest() == BuiltinTypes::document + || axis == QXmlNodeModelIndex::AxisChild) + axisStep->setAxis(QXmlNodeModelIndex::AxisSelf); + else if(axis == QXmlNodeModelIndex::AxisAttribute) + { + axisStep->setAxis(QXmlNodeModelIndex::AxisSelf); + /* Consider that the user write attribute::node(). This is + * semantically equivalent to attribute::attribute(), but since we have changed + * the axis to axis self, we also need to change the node test, such that we + * have self::attribute(). */ + if(*axisStep->nodeTest() == *BuiltinTypes::node) + axisStep->setNodeTest(BuiltinTypes::attribute); + } + else + { + parseInfo->staticContext->error(QtXmlPatterns::tr("In an XSL-T pattern, axis %1 cannot be used, " + "only axis %2 or %3 can.") + .arg(formatKeyword(AxisStep::axisName(axis)), + formatKeyword(AxisStep::axisName(QXmlNodeModelIndex::AxisChild)), + formatKeyword(AxisStep::axisName(QXmlNodeModelIndex::AxisAttribute))), + ReportContext::XPST0003, + fromYYLTYPE(@$, parseInfo)); + } + + $$ = $1; + } + +Expr: ExprSingle /* [31] */ +| ExpressionSequence + { + $$ = create(new ExpressionSequence($1), @$, parseInfo); + } + +ExpressionSequence: ExprSingle COMMA ExprSingle /* [X] */ + { + Expression::List l; + l.append($1); + l.append($3); + $$ = l; + } +| ExpressionSequence COMMA ExprSingle + { + $1.append($3); + $$ = $1; + } + +ExprSingle: OrExpr /* [32] */ +| FLWORExpr +| QuantifiedExpr +| TypeswitchExpr +| IfExpr +| AVT LPAREN AttrValueContent RPAREN + { + $$ = createDirAttributeValue($3, parseInfo, @$); + } + +OptionalModes: /* Empty. */ /* [X] */ + { + QVector<QXmlName> result; + result.append(QXmlName(StandardNamespaces::InternalXSLT, StandardLocalNames::Default)); + $$ = result; + } +| MODE Modes + { + $$ = $2; + } + +OptionalMode: /* Empty. */ /* [X] */ + { + $$ = QXmlName(StandardNamespaces::InternalXSLT, StandardLocalNames::Default); + } +| MODE Mode + { + $$ = $2; + } + +Modes: Mode + { + QVector<QXmlName> result; + result.append($1); + $$ = result; + } +| Modes COMMA Mode + { + $1.append($3); + $$ = $1; + } + +Mode: QName /* [X] */ + { + $$ = $1; + } +| NCNAME + { + if($1 == QLatin1String("#current")) + $$ = QXmlName(StandardNamespaces::InternalXSLT, StandardLocalNames::current); + else if($1 == QLatin1String("#default")) + $$ = QXmlName(StandardNamespaces::InternalXSLT, StandardLocalNames::Default); + else if($1 == QLatin1String("#all")) + $$ = QXmlName(StandardNamespaces::InternalXSLT, StandardLocalNames::all); + else + { + const ReflectYYLTYPE ryy(@$, parseInfo); + + if(!QXmlUtils::isNCName($1)) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("%1 is an invalid template mode name.") + .arg(formatKeyword($1)), + ReportContext::XTSE0550, + fromYYLTYPE(@$, parseInfo)); + } + + $$ = parseInfo->staticContext->namePool()->allocateQName(StandardNamespaces::empty, $1); + } + } + + +FLWORExpr: ForClause /* [33] */ +| LetClause + +ForClause: FOR DOLLAR VarName TypeDeclaration + PositionalVar IN ExprSingle + { + /* We're pushing the range variable here, not the positional. */ + $<expr>$ = pushVariable($3, quantificationType($4), $7, VariableDeclaration::RangeVariable, @$, parseInfo); + } + { + /* It is ok this appears after PositionalVar, because currentRangeSlot() + * uses a different "channel" than currentPositionSlot(), so they can't trash + * each other. */ + $<enums.slot>$ = parseInfo->staticContext->currentRangeSlot(); + } + ForTail /* [34] */ + { + Q_ASSERT($7); + Q_ASSERT($10); + + /* We want the next last pushed variable, since we push the range variable after the + * positional variable. */ + if($5 != -1 && parseInfo->variables.at(parseInfo->variables.count() -2)->name == $3) + { + /* Ok, a positional variable is used since its slot is not -1, and its name is equal + * to our range variable. This is an error. */ + parseInfo->staticContext->error(QtXmlPatterns::tr("The name of a variable bound in a for-expression must be different " + "from the positional variable. Hence, the two variables named %1 collide.") + .arg(formatKeyword(parseInfo->staticContext->namePool(), $3)), + ReportContext::XQST0089, + fromYYLTYPE(@$, parseInfo)); + + } + + const Expression::Ptr retBody(create(new ForClause($<enums.slot>9, $<expr>8, $10, $5), @$, parseInfo)); + ReturnOrderBy *const rob = locateReturnClause($10); + + if(rob) + $$ = create(new OrderBy(rob->stability(), rob->orderSpecs(), retBody, rob), @$, parseInfo); + else + $$ = retBody; + + parseInfo->finalizePushedVariable(); + + if($5 != -1) /* We also have a positional variable to remove from the scope. */ + parseInfo->finalizePushedVariable(); + } + +ForTail: COMMA DOLLAR VarName TypeDeclaration + PositionalVar IN ExprSingle + { + pushVariable($3, quantificationType($4), $7, VariableDeclaration::RangeVariable, @$, parseInfo); + } + { + /* It is ok this appears after PositionalVar, because currentRangeSlot() + * uses a different "channel" than currentPositionSlot(), so they can't trash + * each other. */ + $<enums.slot>$ = parseInfo->staticContext->currentRangeSlot(); + } + ForTail /* [X] */ + { + $$ = create(new ForClause($<enums.slot>9, $<expr>7, $10, $5), @$, parseInfo); + + parseInfo->finalizePushedVariable(); + + if($5 != -1) /* We also have a positional variable to remove from the scope. */ + parseInfo->finalizePushedVariable(); + } + +| WhereClause +| ForClause +| LetClause + +PositionalVar: /* empty */ /* [35] */ + { + $$ = -1; + } + +| AT DOLLAR VarName + { + pushVariable($3, CommonSequenceTypes::ExactlyOneInteger, Expression::Ptr(), + VariableDeclaration::PositionalVariable, @$, parseInfo); + $$ = parseInfo->currentPositionSlot(); + } + +LetClause: LET IsInternal DOLLAR VarName TypeDeclaration ASSIGN ExprSingle + { + $<expr>$ = pushVariable($4, quantificationType($5), $7, VariableDeclaration::ExpressionVariable, @$, parseInfo); + } + LetTail /* [36] */ + { + allowedIn(QXmlQuery::XQuery10, parseInfo, @$, $2); + + Q_ASSERT(parseInfo->variables.top()->name == $4); + $$ = create(new LetClause($<expr>8, $9, parseInfo->variables.top()), @$, parseInfo); + parseInfo->finalizePushedVariable(); + } + +LetTail: COMMA DOLLAR VarName TypeDeclaration ASSIGN ExprSingle + { $<expr>$ = pushVariable($3, quantificationType($4), $6, VariableDeclaration::ExpressionVariable, @$, parseInfo);} + LetTail /* [X] */ + { + Q_ASSERT(parseInfo->variables.top()->name == $3); + $$ = create(new LetClause($<expr>7, $8, parseInfo->variables.top()), @$, parseInfo); + parseInfo->finalizePushedVariable(); + } + +| WhereClause +| ForClause +| LetClause + +WhereClause: OrderByClause RETURN ExprSingle /* [37] */ + { + if($1.isEmpty()) + $$ = $3; + else + $$ = createReturnOrderBy($1, $3, parseInfo->orderStability.pop(), @$, parseInfo); + } + +| WHERE ExprSingle OrderByClause RETURN ExprSingle + { + if($3.isEmpty()) + $$ = create(new IfThenClause($2, $5, create(new EmptySequence, @$, parseInfo)), @$, parseInfo); + else + $$ = create(new IfThenClause($2, createReturnOrderBy($3, $5, parseInfo->orderStability.pop(), @$, parseInfo), + create(new EmptySequence, @$, parseInfo)), + @$, parseInfo); + } + +OrderByClause: /* Empty. */ /* [38] */ + { + $$ = OrderSpecTransfer::List(); + } +| MandatoryOrderByClause + +MandatoryOrderByClause: OrderByInputOrder OrderSpecList + { + $$ = $2; + } + +OrderSpecList: OrderSpecList COMMA OrderSpec /* [39] */ + { + OrderSpecTransfer::List list; + list += $1; + list.append($3); + $$ = list; + } +| OrderSpec + { + OrderSpecTransfer::List list; + list.append($1); + $$ = list; + } + +OrderSpec: ExprSingle DirectionModifier EmptynessModifier CollationModifier /* [40] */ + { + $$ = OrderSpecTransfer($1, OrderBy::OrderSpec($2, $3)); + } + +DirectionModifier: /* Empty. */ /* [X] */ + { + /* Where does the specification state the default value is ascending? + * + * It is implicit, in the first enumerated list in 3.8.3 Order By and Return Clauses: + * + * "If T1 and T2 are two tuples in the tuple stream, and V1 and V2 are the first pair + * of values encountered when evaluating their orderspecs from left to right for + * which one value is greater-than the other (as defined above), then: + * + * 1. If V1 is greater-than V2: If the orderspec specifies descending, + * then T1 precedes T2 in the tuple stream; otherwise, T2 precedes T1 in the tuple stream. + * 2. If V2 is greater-than V1: If the orderspec specifies descending, + * then T2 precedes T1 in the tuple stream; otherwise, T1 precedes T2 in the tuple stream." + * + * which means that if you don't specify anything, or you + * specify ascending, you get the same result. + */ + $$ = OrderBy::OrderSpec::Ascending; + } + +| ASCENDING + { + $$ = OrderBy::OrderSpec::Ascending; + } + +| DESCENDING + { + $$ = OrderBy::OrderSpec::Descending; + } + +EmptynessModifier: /* Empty. */ /* [X] */ + { + $$ = parseInfo->staticContext->orderingEmptySequence(); + } +| OrderingEmptySequence + +CollationModifier: /* Empty. */ /* [X] */ +| COLLATION URILiteral + { + if(parseInfo->isXSLT()) + resolveAndCheckCollation<ReportContext::XTDE1035>($2, parseInfo, @$); + else + resolveAndCheckCollation<ReportContext::XQST0076>($2, parseInfo, @$); + } +| INTERNAL COLLATION ExprSingle + { + /* We do nothing. We don't use collations, and we have this non-terminal + * in order to accept expressions. */ + } + +OrderByInputOrder: STABLE ORDER BY /* [X] */ + { + parseInfo->orderStability.push(OrderBy::StableOrder); + } +| ORDER BY + { + parseInfo->orderStability.push(OrderBy::UnstableOrder); + } + +QuantifiedExpr: SomeQuantificationExpr /* [42] */ +| EveryQuantificationExpr + +SomeQuantificationExpr: SOME DOLLAR VarName TypeDeclaration IN ExprSingle + { + pushVariable($3, quantificationType($4), $6, + VariableDeclaration::RangeVariable, @$, parseInfo); + } + {$<enums.slot>$ = parseInfo->staticContext->currentRangeSlot();} + SomeQuantificationTail /* [X] */ + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XPath20), parseInfo, @$); + $$ = create(new QuantifiedExpression($<enums.slot>8, + QuantifiedExpression::Some, $<expr>6, $9), @$, parseInfo); + parseInfo->finalizePushedVariable(); + } + +SomeQuantificationTail: COMMA DOLLAR VarName TypeDeclaration IN ExprSingle + { + $<expr>$ = pushVariable($3, quantificationType($4), $6, + VariableDeclaration::RangeVariable, @$, parseInfo); + } + {$<enums.slot>$ = parseInfo->staticContext->currentRangeSlot();} + SomeQuantificationTail /* [X] */ + { + $$ = create(new QuantifiedExpression($<enums.slot>8, + QuantifiedExpression::Some, $<expr>7, $9), @$, parseInfo); + parseInfo->finalizePushedVariable(); + } + +| SatisfiesClause + +EveryQuantificationExpr: EVERY DOLLAR VarName TypeDeclaration IN ExprSingle + { + pushVariable($3, quantificationType($4), $6, + VariableDeclaration::RangeVariable, @$, parseInfo); + } + {$<enums.slot>$ = parseInfo->staticContext->currentRangeSlot();} + EveryQuantificationTail /* [X] */ + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XPath20), parseInfo, @$); + $$ = create(new QuantifiedExpression($<enums.slot>8, + QuantifiedExpression::Every, $<expr>6, $9), @$, parseInfo); + parseInfo->finalizePushedVariable(); + } + +EveryQuantificationTail: COMMA DOLLAR VarName TypeDeclaration IN ExprSingle + { + $<expr>$ = pushVariable($3, quantificationType($4), $6, + VariableDeclaration::RangeVariable, @$, parseInfo); + } + {$<enums.slot>$ = parseInfo->staticContext->currentRangeSlot();} + EveryQuantificationTail /* [X] */ + { + $$ = create(new QuantifiedExpression($<enums.slot>8, + QuantifiedExpression::Every, $<expr>7, $9), @$, parseInfo); + parseInfo->finalizePushedVariable(); + } + +| SatisfiesClause + +SatisfiesClause: SATISFIES ExprSingle /* [X] */ + { + $$ = $2; + } + +/* + * Typeswitches are re-written to a combination between @c if clauses, <tt>instance of</tt>, and + * @c let bindings. For example, the query: + * + * @code + * typeswitch(input) + * case element() return <!-- a comment --> + * case $i as attribute(name) return name($i) + * default return "Didn't match" + * @endcode + * + * becomes: + * + * @code + * if(input instance of element()) + * then <!-- a comment --> + * else if(input instance of attribute(name)) + * then let $i as attribute(name) := input return name($i) + * else "Didn't match" + * @endcode + */ + +TypeswitchExpr: TYPESWITCH LPAREN Expr RPAREN + { + parseInfo->typeswitchSource.push($3); + } + CaseClause /* [43] */ + { + allowedIn(QXmlQuery::XQuery10, parseInfo, @$); + parseInfo->typeswitchSource.pop(); + $$ = $6; + } + +CaseClause: CASE CaseVariable SequenceType /* [44] */ + { + if(!$2.isNull()) + { + pushVariable($2, $3, parseInfo->typeswitchSource.top(), + VariableDeclaration::ExpressionVariable, @$, parseInfo, false); + } + } + RETURN ExprSingle + { + /* The variable shouldn't be in-scope for other case branches. */ + if(!$2.isNull()) + parseInfo->finalizePushedVariable(); + } + CaseTail + { + const Expression::Ptr instanceOf(create(new InstanceOf(parseInfo->typeswitchSource.top(), $3), @$, parseInfo)); + $$ = create(new IfThenClause(instanceOf, $6, $8), @$, parseInfo); + } + +CaseTail: CaseClause /* [X] */ +| CaseDefault + +CaseVariable: /* Empty. */ /* [X] */ + { + $$ = QXmlName(); + } + +| DOLLAR ElementName AS + { + $$ = $2; + } + +CaseDefault: DEFAULT RETURN ExprSingle /* [X] */ + { + $$ = $3; + } +| DEFAULT DOLLAR ElementName + { + if(!$3.isNull()) + { + pushVariable($3, parseInfo->typeswitchSource.top()->staticType(), + parseInfo->typeswitchSource.top(), + VariableDeclaration::ExpressionVariable, @$, parseInfo, false); + } + } + RETURN ExprSingle + { + if(!$3.isNull()) + parseInfo->finalizePushedVariable(); + $$ = $6; + } + +IfExpr: IF LPAREN Expr RPAREN THEN ExprSingle ELSE ExprSingle /* [45] */ + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XPath20), parseInfo, @$); + $$ = create(new IfThenClause($3, $6, $8), @$, parseInfo); + } + +OrExpr: AndExpr /* [46] */ +| OrExpr OR AndExpr + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XPath20), parseInfo, @$); + $$ = create(new OrExpression($1, $3), @$, parseInfo); + } + +AndExpr: ComparisonExpr /* [47] */ +| AndExpr AND ComparisonExpr + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XPath20), parseInfo, @$); + $$ = create(new AndExpression($1, $3), @$, parseInfo); + } + +ComparisonExpr: RangeExpr /* [48] */ +| ValueComp +| GeneralComp +| NodeComp + +RangeExpr: AdditiveExpr /* [49] */ +| AdditiveExpr TO AdditiveExpr + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XPath20), parseInfo, @$); + $$ = create(new RangeExpression($1, $3), @$, parseInfo); + } + +AdditiveExpr: MultiplicativeExpr /* [50] */ +| AdditiveExpr AdditiveOperator MultiplicativeExpr + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XPath20), parseInfo, @$); + $$ = create(new ArithmeticExpression($1, $2, $3), @$, parseInfo); + } + +AdditiveOperator: PLUS {$$ = AtomicMathematician::Add;} /* [X] */ +| MINUS {$$ = AtomicMathematician::Substract;} + +MultiplicativeExpr: UnionExpr /* [51] */ +| MultiplicativeExpr MultiplyOperator UnionExpr + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XPath20), parseInfo, @$); + $$ = create(new ArithmeticExpression($1, $2, $3), @$, parseInfo); + } + +MultiplyOperator: STAR {$$ = AtomicMathematician::Multiply;} /* [X] */ +| DIV {$$ = AtomicMathematician::Div;} +| IDIV {$$ = AtomicMathematician::IDiv;} +| MOD {$$ = AtomicMathematician::Mod;} + +UnionExpr: IntersectExceptExpr /* [52] */ +| UnionExpr UnionOperator IntersectExceptExpr + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 + | QXmlQuery::XPath20 + | QXmlQuery::XmlSchema11IdentityConstraintField + | QXmlQuery::XmlSchema11IdentityConstraintSelector), + parseInfo, @$); + $$ = create(new CombineNodes($1, CombineNodes::Union, $3), @$, parseInfo); + } + +IntersectExceptExpr: InstanceOfExpr /* [53] */ +| IntersectExceptExpr IntersectOperator InstanceOfExpr + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XPath20), parseInfo, @$); + $$ = create(new CombineNodes($1, $2, $3), @$, parseInfo); + } + +UnionOperator: UNION /* [X] */ +| BAR + +IntersectOperator: INTERSECT /* [X] */ + { + $$ = CombineNodes::Intersect; + } +| EXCEPT + { + $$ = CombineNodes::Except; + } + +InstanceOfExpr: TreatExpr /* [54] */ +| TreatExpr INSTANCE OF SequenceType + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XPath20), parseInfo, @$); + $$ = create(new InstanceOf($1, + SequenceType::Ptr($4)), @$, parseInfo); + } + +TreatExpr: CastableExpr /* [55] */ +| CastableExpr TREAT AS SequenceType + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XPath20), parseInfo, @$); + $$ = create(new TreatAs($1, $4), @$, parseInfo); + } + +CastableExpr: CastExpr /* [56] */ +| CastExpr CASTABLE AS SingleType + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XPath20), parseInfo, @$); + $$ = create(new CastableAs($1, $4), @$, parseInfo); + } + +CastExpr: UnaryExpr /* [57] */ +| UnaryExpr CAST AS SingleType + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XPath20), parseInfo, @$); + $$ = create(new CastAs($1, $4), @$, parseInfo); + } + +UnaryExpr: ValueExpr /* [58] */ +| UnaryOperator UnaryExpr + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XPath20), parseInfo, @$); + $$ = create(new UnaryExpression($1, $2, parseInfo->staticContext), @$, parseInfo); + } + +UnaryOperator: PLUS /* [X] */ + { + $$ = AtomicMathematician::Add; + } +| MINUS + { + $$ = AtomicMathematician::Substract; + } + +ValueExpr: ValidateExpr /* [59] */ +| PathExpr +| ExtensionExpr + +GeneralComp: RangeExpr GeneralComparisonOperator RangeExpr /* [60] */ + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XPath20), parseInfo, @$); + $$ = create(new GeneralComparison($1, $2, $3, parseInfo->isBackwardsCompat.top()), @$, parseInfo); + } + +GeneralComparisonOperator: G_EQ {$$ = AtomicComparator::OperatorEqual;} /* [X] */ +| G_NE {$$ = AtomicComparator::OperatorNotEqual;} +| G_GE {$$ = AtomicComparator::OperatorGreaterOrEqual;} +| G_GT {$$ = AtomicComparator::OperatorGreaterThan;} +| G_LE {$$ = AtomicComparator::OperatorLessOrEqual;} +| G_LT {$$ = AtomicComparator::OperatorLessThan;} + +ValueComp: RangeExpr ValueComparisonOperator RangeExpr /* [61] */ + { + $$ = create(new ValueComparison($1, $2, $3), @$, parseInfo); + } + +ValueComparisonOperator: EQ {$$ = AtomicComparator::OperatorEqual;} +| NE {$$ = AtomicComparator::OperatorNotEqual;} +| GE {$$ = AtomicComparator::OperatorGreaterOrEqual;} +| GT {$$ = AtomicComparator::OperatorGreaterThan;} +| LE {$$ = AtomicComparator::OperatorLessOrEqual;} +| LT {$$ = AtomicComparator::OperatorLessThan;} + +NodeComp: RangeExpr NodeOperator RangeExpr /* [62] */ + { + $$ = create(new NodeComparison($1, $2, $3), @$, parseInfo); + } + +NodeOperator: IS {$$ = QXmlNodeModelIndex::Is;} /* [X] */ +| PRECEDES {$$ = QXmlNodeModelIndex::Precedes;} +| FOLLOWS {$$ = QXmlNodeModelIndex::Follows;} + +ValidateExpr: ValidationMode EnclosedExpr /* [63] */ + { + allowedIn(QXmlQuery::XQuery10, parseInfo, @$); + parseInfo->staticContext->error(QtXmlPatterns::tr("The Schema Validation Feature is not supported. " + "Hence, %1-expressions may not be used.") + .arg(formatKeyword("validate")), + ReportContext::XQST0075, fromYYLTYPE(@$, parseInfo)); + /* + $$ = Validate::create($2, $1, parseInfo->staticContext); + */ + } + +/* "A validate expression may optionally specify a validation mode. The + default validation mode is strict." */ +ValidationMode: VALIDATE {$$ = Validate::Strict;} /* [64] */ +| VALIDATE STRICT {$$ = Validate::Strict;} +| VALIDATE LAX {$$ = Validate::Lax;} + +ExtensionExpr: Pragmas EnclosedOptionalExpr /* [65] */ + { + allowedIn(QXmlQuery::XQuery10, parseInfo, @$); + /* We don't support any pragmas, so we only do the + * necessary validation and use the fallback expression. */ + + if($2) + $$ = $2; + else + { + parseInfo->staticContext->error(QtXmlPatterns::tr("None of the pragma expressions are supported. " + "Therefore, a fallback expression " + "must be present"), + ReportContext::XQST0079, fromYYLTYPE(@$, parseInfo)); + } + } + +EnclosedOptionalExpr: CURLY_LBRACE /* empty */ CURLY_RBRACE /* [X] */ + { + $$.reset(); + } +| CURLY_LBRACE Expr CURLY_RBRACE + { + $$ = $2; + } + +Pragmas: Pragmas Pragma /* [X] */ +| Pragma + +Pragma: PRAGMA_START PragmaName PragmaContents PRAGMA_END /* [66] */ + { + allowedIn(QXmlQuery::XQuery10, parseInfo, @$); + } + +PragmaContents: /* empty */ /* [67] */ +| StringLiteral + +PathExpr: SLASH RelativePathExpr /* [68] */ + { + /* This is "/step". That is, fn:root(self::node()) treat as document-node()/RelativePathExpr. */ + $$ = create(new Path(createRootExpression(parseInfo, @$), $2), @$, parseInfo); + } + +| SLASHSLASH RelativePathExpr + { + $$ = createSlashSlashPath(createRootExpression(parseInfo, @$), $2, @$, parseInfo); + } +| SLASH + { + /* This is "/". That is, fn:root(self::node()) treat as document-node(). */ + $$ = createRootExpression(parseInfo, @$); + } + +| RelativePathExpr + /* This is "step", simply. We let bison generate "$$ = $1". */ + +RelativePathExpr: StepExpr /* [69] */ +| RelativePathExpr MapOrSlash StepExpr + { + $$ = create(new Path($1, $3, $2), @$, parseInfo); + } +| RelativePathExpr MapOrSlash SORT MandatoryOrderByClause RETURN StepExpr END_SORT + { + const Expression::Ptr orderBy(createReturnOrderBy($4, $6, parseInfo->orderStability.pop(), @$, parseInfo)); + + ReturnOrderBy *const rob = orderBy->as<ReturnOrderBy>(); + const Expression::Ptr path(create(new Path($1, orderBy, $2), @$, parseInfo)); + + $$ = create(new OrderBy(rob->stability(), rob->orderSpecs(), path, rob), @$, parseInfo); + } +| RelativePathExpr SLASHSLASH StepExpr + { + $$ = createSlashSlashPath($1, $3, @$, parseInfo); + } + +StepExpr: FilteredAxisStep /* [70] */ + { + $$ = NodeSortExpression::wrapAround($1, parseInfo->staticContext); + } +| FilterExpr +| CURRENT EnclosedExpr + { + $$ = create(new CurrentItemStore($2), @$, parseInfo); + } +| XSLT_VERSION + { + const xsDouble version = $1.toDouble(); + + parseInfo->isBackwardsCompat.push(version != 2); + + $<enums.Double>$ = version; + } + EnclosedExpr + { + if($<enums.Double>2 < 2) + $$ = createCompatStore($3, @$, parseInfo); + else + $$ = $3; + } +| BASEURI StringLiteral CURLY_LBRACE Expr CURLY_RBRACE /* [X] */ +{ + allowedIn(QXmlQuery::XSLT20, parseInfo, @$); + Q_ASSERT(!$2.isEmpty()); + $$ = create(new StaticBaseURIStore($2, $4), @$, parseInfo); +} + +| DECLARE NAMESPACE NCNAME G_EQ STRING_LITERAL CURLY_LBRACE /* [X] */ + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XSLT20), parseInfo, @$); + parseInfo->resolvers.push(parseInfo->staticContext->namespaceBindings()); + const NamespaceResolver::Ptr resolver(new DelegatingNamespaceResolver(parseInfo->staticContext->namespaceBindings())); + resolver->addBinding(QXmlName(parseInfo->staticContext->namePool()->allocateNamespace($5), + StandardLocalNames::empty, + parseInfo->staticContext->namePool()->allocatePrefix($3))); + parseInfo->staticContext->setNamespaceBindings(resolver); + } + Expr + CURLY_RBRACE + { + parseInfo->staticContext->setNamespaceBindings(parseInfo->resolvers.pop()); + $$ = $8; + } +| CALL_TEMPLATE ElementName LPAREN TemplateWithParameters RPAREN + { + $$ = create(new CallTemplate($2, parseInfo->templateWithParams), @$, parseInfo); + parseInfo->templateWithParametersHandled(); + parseInfo->templateCalls.append($$); + } + +TemplateWithParameters: + { + parseInfo->startParsingWithParam(); + } + TemplateParameters + { + parseInfo->endParsingWithParam(); + } + +TemplateParameters: /* Empty. */ /* [X] */ + { + } +| TemplateParameter + { + } +| TemplateParameters COMMA TemplateParameter + { + } + +OptionalTemplateParameters: /* Empty. */ /* [X] */ + { + } +| LPAREN TemplateParameters RPAREN + { + } + +TemplateParameter: IsTunnel DOLLAR VarName TypeDeclaration OptionalAssign + { + /* Note, this grammar rule is invoked for @c xsl:param @em and @c + * xsl:with-param. */ + const bool isParsingWithParam = parseInfo->isParsingWithParam(); + + /** + * @c xsl:param doesn't make life easy: + * + * If it only has @c name, it's default value is an empty + * string(hence has type @c xs:string), but the value that + * (maybe) is supplied can be anything, typically a node. + * + * Therefore, for that very common case we can't rely on + * the Expression's type, but have to force it to item()*. + * + * So if we're supplied the type item()*, we pass a null + * SequenceType. TemplateParameterReference recognizes this + * and has item()* as its static type, regardless of if the + * expression has a more specific type. + */ + SequenceType::Ptr type; + + if(!$4->is(CommonSequenceTypes::ZeroOrMoreItems)) + type = $4; + + Expression::Ptr expr; + + /* The default value is an empty sequence. */ + if(!$5 && ((type && $4->cardinality().allowsEmpty()) + || isParsingWithParam)) + expr = create(new EmptySequence, @$, parseInfo); + else + expr = $5; + + /* We ensure we have some type, so CallTemplate, Template and friends + * are happy. */ + if(!isParsingWithParam && !type) + type = CommonSequenceTypes::ZeroOrMoreItems; + + if($1) + /* TODO, handle tunnel parameters. */; + else + { + if((!isParsingWithParam && VariableDeclaration::contains(parseInfo->templateParameters, $3)) || + (isParsingWithParam && parseInfo->templateWithParams.contains($3))) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("Each name of a template parameter must be unique; %1 is duplicated.") + .arg(formatKeyword(parseInfo->staticContext->namePool(), $3)), + isParsingWithParam ? ReportContext::XTSE0670 : ReportContext::XTSE0580, fromYYLTYPE(@$, parseInfo)); + } + else + { + if(isParsingWithParam) + parseInfo->templateWithParams[$3] = WithParam::Ptr(new WithParam($3, $4, expr)); + else + { + Q_ASSERT(type); + pushVariable($3, type, expr, VariableDeclaration::TemplateParameter, @$, parseInfo); + parseInfo->templateParameters.append(parseInfo->variables.top()); + } + } + } + } + +IsTunnel: /* Empty. */ + { + $$ = false; + } +| TUNNEL + { + $$ = true; + } + +OptionalAssign: /* Empty. */ /* [X] */ + { + $$ = Expression::Ptr(); + } +| ASSIGN ExprSingle + { + $$ = $2; + } + +/** + * Controls whethers a path expression should sort its result. Used for + * implementing XSL-T's for-each. + */ +MapOrSlash: SLASH /* [X] */ + { + $$ = Path::RegularPath; + } +| MAP + { + $$ = Path::XSLTForEach; + } +| FOR_APPLY_TEMPLATE + { + $$ = Path::ForApplyTemplate; + } + +FilteredAxisStep: AxisStep /* [X] */ +| FilteredAxisStep LBRACKET Expr RBRACKET + { + $$ = create(GenericPredicate::create($1, $3, parseInfo->staticContext, fromYYLTYPE(@$, parseInfo)), @$, parseInfo); + } + +AxisStep: ForwardStep /* [71] */ +| ReverseStep + +ForwardStep: Axis + { + if($1 == QXmlNodeModelIndex::AxisAttribute) + parseInfo->nodeTestSource = BuiltinTypes::attribute; + } + NodeTestInAxisStep /* [72] */ + { + if($3) + { + /* A node test was explicitly specified. The un-abbreviated syntax was used. */ + $$ = create(new AxisStep($1, $3), @$, parseInfo); + } + else + { + /* Quote from 3.2.1.1 Axes + * + * [Definition: Every axis has a principal node kind. If an axis + * can contain elements, then the principal node kind is element; + * otherwise, it is the kind of nodes that the axis can contain.] Thus: + * - For the attribute axis, the principal node kind is attribute. + * - For all other axes, the principal node kind is element. */ + + if($1 == QXmlNodeModelIndex::AxisAttribute) + $$ = create(new AxisStep(QXmlNodeModelIndex::AxisAttribute, BuiltinTypes::attribute), @$, parseInfo); + else + $$ = create(new AxisStep($1, BuiltinTypes::element), @$, parseInfo); + } + + parseInfo->restoreNodeTestSource(); + } +| AbbrevForwardStep + +NodeTestInAxisStep: NodeTest +| AnyAttributeTest + +Axis: AxisToken COLONCOLON /* [73] */ + { + if($1 == QXmlNodeModelIndex::AxisNamespace) + { + /* We don't raise XPST0010 here because the namespace axis isn't an optional + * axis. It simply is not part of the XQuery grammar. */ + parseInfo->staticContext->error(QtXmlPatterns::tr("The %1-axis is unsupported in XQuery") + .arg(formatKeyword("namespace")), + ReportContext::XPST0003, fromYYLTYPE(@$, parseInfo)); + } + else + $$ = $1; + + switch($1) + { + case QXmlNodeModelIndex::AxisAttribute: + { + allowedIn(QueryLanguages( QXmlQuery::XPath20 + | QXmlQuery::XQuery10 + | QXmlQuery::XmlSchema11IdentityConstraintField + | QXmlQuery::XSLT20), + parseInfo, @$); + break; + } + case QXmlNodeModelIndex::AxisChild: + { + allowedIn(QueryLanguages( QXmlQuery::XPath20 + | QXmlQuery::XQuery10 + | QXmlQuery::XmlSchema11IdentityConstraintField + | QXmlQuery::XmlSchema11IdentityConstraintSelector + | QXmlQuery::XSLT20), + parseInfo, @$); + break; + } + default: + { + allowedIn(QueryLanguages( QXmlQuery::XPath20 + | QXmlQuery::XQuery10 + | QXmlQuery::XSLT20), + parseInfo, @$); + } + } + } + +AxisToken: ANCESTOR_OR_SELF {$$ = QXmlNodeModelIndex::AxisAncestorOrSelf ;} +| ANCESTOR {$$ = QXmlNodeModelIndex::AxisAncestor ;} +| ATTRIBUTE {$$ = QXmlNodeModelIndex::AxisAttribute ;} +| CHILD {$$ = QXmlNodeModelIndex::AxisChild ;} +| DESCENDANT_OR_SELF {$$ = QXmlNodeModelIndex::AxisDescendantOrSelf;} +| DESCENDANT {$$ = QXmlNodeModelIndex::AxisDescendant ;} +| FOLLOWING {$$ = QXmlNodeModelIndex::AxisFollowing ;} +| PRECEDING {$$ = QXmlNodeModelIndex::AxisPreceding ;} +| FOLLOWING_SIBLING {$$ = QXmlNodeModelIndex::AxisFollowingSibling;} +| PRECEDING_SIBLING {$$ = QXmlNodeModelIndex::AxisPrecedingSibling;} +| PARENT {$$ = QXmlNodeModelIndex::AxisParent ;} +| SELF {$$ = QXmlNodeModelIndex::AxisSelf ;} + +AbbrevForwardStep: AT_SIGN + { + parseInfo->nodeTestSource = BuiltinTypes::attribute; + } + NodeTest /* [72] */ + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XSLT20 | QXmlQuery::XmlSchema11IdentityConstraintField), parseInfo, @$); + $$ = create(new AxisStep(QXmlNodeModelIndex::AxisAttribute, $3), @$, parseInfo); + + parseInfo->restoreNodeTestSource(); + } +| NodeTest + { + ItemType::Ptr nodeTest; + + if(parseInfo->isParsingPattern && *$1 == *BuiltinTypes::node) + nodeTest = BuiltinTypes::xsltNodeTest; + else + nodeTest = $1; + + $$ = create(new AxisStep(QXmlNodeModelIndex::AxisChild, nodeTest), @$, parseInfo); + } +| AnyAttributeTest + { + $$ = create(new AxisStep(QXmlNodeModelIndex::AxisAttribute, $1), @$, parseInfo); + } + +ReverseStep: AbbrevReverseStep /* [75] */ + +AbbrevReverseStep: DOTDOT /* [77] */ + { + $$ = create(new AxisStep(QXmlNodeModelIndex::AxisParent, BuiltinTypes::node), @$, parseInfo); + } + +NodeTest: NameTest /* [78] */ +| KindTest + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XPath20), parseInfo, @$); + } + +NameTest: ElementName /* [79] */ + { + $$ = QNameTest::create(parseInfo->nodeTestSource, $1); + } +| WildCard + +WildCard: STAR /* [80] */ + { + $$ = parseInfo->nodeTestSource; + } +| ANY_LOCAL_NAME + { + const NamePool::Ptr np(parseInfo->staticContext->namePool()); + const ReflectYYLTYPE ryy(@$, parseInfo); + + const QXmlName::NamespaceCode ns(QNameConstructor::namespaceForPrefix(np->allocatePrefix($1), parseInfo->staticContext, &ryy)); + + $$ = NamespaceNameTest::create(parseInfo->nodeTestSource, ns); + } +| ANY_PREFIX + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XPath20), parseInfo, @$); + const QXmlName::LocalNameCode c = parseInfo->staticContext->namePool()->allocateLocalName($1); + $$ = LocalNameTest::create(parseInfo->nodeTestSource, c); + } + +FilterExpr: PrimaryExpr /* [81] */ +| FilterExpr LBRACKET Expr RBRACKET + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XPath20), parseInfo, @$); + $$ = create(GenericPredicate::create($1, $3, parseInfo->staticContext, fromYYLTYPE(@4, parseInfo)), @$, parseInfo); + } + +PrimaryExpr: Literal /* [84] */ +| VarRef +| ParenthesizedExpr +| ContextItemExpr +| FunctionCallExpr +| OrderingExpr +| Constructor +| APPLY_TEMPLATE OptionalMode LPAREN TemplateWithParameters RPAREN + { + $$ = create(new ApplyTemplate(parseInfo->modeFor($2), + parseInfo->templateWithParams, + parseInfo->modeFor(QXmlName(StandardNamespaces::InternalXSLT, + StandardLocalNames::Default))), + @1, parseInfo); + parseInfo->templateWithParametersHandled(); + } + +Literal: NumericLiteral /* [85] */ +| StringLiteral + { + $$ = create(new Literal(AtomicString::fromValue($1)), @$, parseInfo); + } + +NumericLiteral: XPATH2_NUMBER /* [86] */ + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XPath20), parseInfo, @$); + $$ = createNumericLiteral<Double>($1, @$, parseInfo); + } +| NUMBER + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XPath20), parseInfo, @$); + $$ = createNumericLiteral<Numeric>($1, @$, parseInfo); + } + +VarRef: DOLLAR VarName /* [87] */ + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XPath20), parseInfo, @$); + $$ = resolveVariable($2, @$, parseInfo, false); + } + +VarName: NCNAME /* [88] */ + { + /* See: http://www.w3.org/TR/xpath20/#id-variables */ + $$ = parseInfo->staticContext->namePool()->allocateQName(QString(), $1); + } +| QName + { + $$ = $1; + } + +ParenthesizedExpr: LPAREN Expr RPAREN /* [89] */ + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XPath20), parseInfo, @$); + $$ = $2; + } +| LPAREN RPAREN + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XPath20), parseInfo, @$); + $$ = create(new EmptySequence, @$, parseInfo); + } + +ContextItemExpr: DOT /* [90] */ + { + $$ = create(new ContextItem(), @$, parseInfo); + } + +OrderingExpr: OrderingMode EnclosedExpr /* [X] */ + { + $$ = $2; + } + +FunctionCallExpr: FunctionName LPAREN FunctionArguments RPAREN /* [93] */ + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XPath20), parseInfo, @$); + if(XPathHelper::isReservedNamespace($1.namespaceURI()) || $1.namespaceURI() == StandardNamespaces::InternalXSLT) + { /* We got a call to a builtin function. */ + const ReflectYYLTYPE ryy(@$, parseInfo); + + const Expression::Ptr + func(parseInfo->staticContext-> + functionSignatures()->createFunctionCall($1, $3, parseInfo->staticContext, &ryy)); + + if(func) + $$ = create(func, @$, parseInfo); + else + { + parseInfo->staticContext->error(QtXmlPatterns::tr("No function by name %1 is available.") + .arg(formatKeyword(parseInfo->staticContext->namePool(), $1)), + ReportContext::XPST0017, fromYYLTYPE(@$, parseInfo)); + } + } + else /* It's a call to a function created with 'declare function'.*/ + { + $$ = create(new UserFunctionCallsite($1, $3.count()), @$, parseInfo); + + $$->setOperands($3); + parseInfo->userFunctionCallsites.append($$); + } + } + +FunctionArguments: /* empty */ /* [X] */ + { + $$ = Expression::List(); + } + +| ExprSingle + { + Expression::List list; + list.append($1); + $$ = list; + } + +| ExpressionSequence + +Constructor: DirectConstructor /* [94] */ + { + allowedIn(QXmlQuery::XQuery10, parseInfo, @$); + } +| ComputedConstructor +/* The reason we cannot call alloweIn() as the action for ComputedConstructor, + * is that we use the computed constructors for XSL-T, and therefore generate + * INTERNAL tokens. */ + +DirectConstructor: DirElemConstructor /* [95] */ +| DirCommentConstructor +| DirPIConstructor + +/* + * Direct attribute constructors can contain embedded expressions, and for those namespace bindings + * on the same element needs to be in scope. For example: + * + * @code + * <element attribute="{prefix:nameTest}" xmlns:prefix="http://example.com/"/> + * @endcode + * + * Patternist is designed to do all name resolution at parse time so the subsequent code only has to + * deal with expanded QNames(which the QName class represents), and this presents a problem since + * the parser haven't even encountered the @c xmlns:prefix when resolving @c prefix in the name test. + * + * This is solved as follows: + * + * <ol> + * <li>Just before starting parsing the attributes, we call Tokenizer::commenceScanOnly(). + * This switches the tokenizer to not tokenize embedded expressions in attributes, + * but to return them as strings, token type STRING_LITERAL.</li> + * <li>We parse all the attributes, and iterates over them, only caring about + * namespace bindings, and validates and adds them to the context.</li> + * <li>We call Tokenizer::resumeTokenizationFrom() from the previous position + * returned from Tokenizer::commenceScanOnly() and parses the attributes once more, + * but this time with tokenization of embedded expressions. Since we this time + * have the namespace bindings in place, everything resolves.</li> + * </ol> + * + * Saxon does this in a similar way. Study net.sf.saxon.expr.QueryParser::parseDirectElementConstructor(). + * + * @see XQueryTokenizer::attributeAsRaw() + */ +DirElemConstructor: G_LT + LexicalName + { + $<enums.tokenizerPosition>$ = parseInfo->tokenizer->commenceScanOnly(); + parseInfo->scanOnlyStack.push(true); + } + + /* This list contains name/string pairs. No embedded + * expressions has been parsed. */ + DirAttributeList + + { + ++parseInfo->elementConstructorDepth; + Expression::List constructors; + + parseInfo->resolvers.push(parseInfo->staticContext->namespaceBindings()); + + /* Fix up attributes and namespace declarations. */ + const NamespaceResolver::Ptr resolver(new DelegatingNamespaceResolver(parseInfo->staticContext->namespaceBindings())); + const NamePool::Ptr namePool(parseInfo->staticContext->namePool()); + const int len = $4.size(); + QSet<QXmlName::PrefixCode> usedDeclarations; + + /* Whether xmlns="" has been encountered. */ + bool hasDefaultDeclaration = false; + + /* For each attribute & namespace declaration, do: */ + for(int i = 0; i < len; ++i) + { + QString strLocalName; + QString strPrefix; + + XPathHelper::splitQName($4.at(i).first, strPrefix, strLocalName); + const QXmlName::PrefixCode prefix = namePool->allocatePrefix(strPrefix); + + /* This can seem a bit weird. However, this name is ending up in a QXmlName + * which consider its prefix a... prefix. So, a namespace binding name can in some cases + * be a local name, but that's just as the initial syntactical construct. */ + const QXmlName::LocalNameCode localName = namePool->allocatePrefix(strLocalName); + + /* Not that localName is "foo" in "xmlns:foo" and that prefix is "xmlns". */ + + if(prefix == StandardPrefixes::xmlns || + (prefix == StandardPrefixes::empty && localName == StandardPrefixes::xmlns)) + { + if(localName == StandardPrefixes::xmlns) + hasDefaultDeclaration = true; + + /* We have a namespace declaration. */ + + const Expression::Ptr nsExpr($4.at(i).second); + + const QString strNamespace(nsExpr->is(Expression::IDEmptySequence) ? QString() : nsExpr->as<Literal>()->item().stringValue()); + + const QXmlName::NamespaceCode ns = namePool->allocateNamespace(strNamespace); + + if(ns == StandardNamespaces::empty) + { + if(localName != StandardPrefixes::xmlns) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("The namespace URI cannot be the empty string when binding to a prefix, %1.") + .arg(formatURI(strPrefix)), + ReportContext::XQST0085, fromYYLTYPE(@$, parseInfo)); + } + } + else if(!AnyURI::isValid(strNamespace)) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("%1 is an invalid namespace URI.").arg(formatURI(strNamespace)), + ReportContext::XQST0022, fromYYLTYPE(@$, parseInfo)); + } + + if(prefix == StandardPrefixes::xmlns && localName == StandardPrefixes::xmlns) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("It is not possible to bind to the prefix %1") + .arg(formatKeyword("xmlns")), + ReportContext::XQST0070, fromYYLTYPE(@$, parseInfo)); + } + + if(ns == StandardNamespaces::xml && localName != StandardPrefixes::xml) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("Namespace %1 can only be bound to %2 (and it is, in either case, pre-declared).") + .arg(formatURI(namePool->stringForNamespace(StandardNamespaces::xml))) + .arg(formatKeyword("xml")), + ReportContext::XQST0070, fromYYLTYPE(@$, parseInfo)); + } + + if(localName == StandardPrefixes::xml && ns != StandardNamespaces::xml) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("Prefix %1 can only be bound to %2 (and it is, in either case, pre-declared).") + .arg(formatKeyword("xml")) + .arg(formatURI(namePool->stringForNamespace(StandardNamespaces::xml))), + ReportContext::XQST0070, fromYYLTYPE(@$, parseInfo)); + } + + QXmlName nb; + + if(localName == StandardPrefixes::xmlns) + nb = QXmlName(ns, StandardLocalNames::empty); + else + nb = QXmlName(ns, StandardLocalNames::empty, localName); + + if(usedDeclarations.contains(nb.prefix())) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("Two namespace declaration attributes have the same name: %1.") + .arg(formatKeyword(namePool->stringForPrefix(nb.prefix()))), + ReportContext::XQST0071, fromYYLTYPE(@$, parseInfo)); + + } + else + usedDeclarations.insert(nb.prefix()); + + /* If the user has bound the XML namespace correctly, we in either + * case don't want to output it. + * + * We only have to check the namespace parts since the above checks has ensured + * consistency in the prefix parts. */ + if(ns != StandardNamespaces::xml) + { + /* We don't want default namespace declarations when the + * default namespace already is empty. */ + if(!(ns == StandardNamespaces::empty && + localName == StandardNamespaces::xmlns && + resolver->lookupNamespaceURI(StandardPrefixes::empty) == StandardNamespaces::empty)) + { + constructors.append(create(new NamespaceConstructor(nb), @$, parseInfo)); + resolver->addBinding(nb); + } + } + } + } + + if(parseInfo->elementConstructorDepth == 1 && !hasDefaultDeclaration) + { + /* TODO But mostly this isn't needed, since the default element + * namespace is empty? How does this at all work? */ + const QXmlName def(resolver->lookupNamespaceURI(StandardPrefixes::empty), StandardLocalNames::empty); + constructors.append(create(new NamespaceConstructor(def), @$, parseInfo)); + } + + parseInfo->staticContext->setNamespaceBindings(resolver); + $<expressionList>$ = constructors; + + /* Resolve the name of the element, now that the namespace attributes are read. */ + { + const ReflectYYLTYPE ryy(@$, parseInfo); + + const QXmlName ele = QNameConstructor::expandQName<StaticContext::Ptr, + ReportContext::XPST0081, + ReportContext::XPST0081>($2, parseInfo->staticContext, resolver, &ryy); + parseInfo->tagStack.push(ele); + } + + parseInfo->tokenizer->resumeTokenizationFrom($<enums.tokenizerPosition>3); + } + POSITION_SET + DirAttributeList + DirElemConstructorTail /* [96] */ + { + /* We add the content constructor after the attribute constructors. This might result + * in nested ExpressionSequences, but it will be optimized away later on. */ + + Expression::List attributes($<expressionList>5); + const NamePool::Ptr namePool(parseInfo->staticContext->namePool()); + const int len = $7.size(); + QSet<QXmlName> declaredAttributes; + declaredAttributes.reserve(len); + + /* For each namespace, resolve its name(now that we have resolved the namespace declarations) and + * turn it into an attribute constructor. */ + for(int i = 0; i < len; ++i) + { + QString strLocalName; + QString strPrefix; + + XPathHelper::splitQName($7.at(i).first, strPrefix, strLocalName); + const QXmlName::PrefixCode prefix = namePool->allocatePrefix(strPrefix); + const QXmlName::LocalNameCode localName = namePool->allocateLocalName(strLocalName); + + if(prefix == StandardPrefixes::xmlns || + (prefix == StandardPrefixes::empty && localName == StandardLocalNames::xmlns)) + { + const Expression::ID id = $7.at(i).second->id(); + + if(id == Expression::IDStringValue || id == Expression::IDEmptySequence) + { + /* It's a namespace declaration, and we've already handled those above. */ + continue; + } + else + { + parseInfo->staticContext->error(QtXmlPatterns::tr("The namespace URI must be a constant and cannot " + "use enclosed expressions."), + ReportContext::XQST0022, fromYYLTYPE(@$, parseInfo)); + } + + } + else + { + const ReflectYYLTYPE ryy(@$, parseInfo); + const QXmlName att = QNameConstructor::expandQName<StaticContext::Ptr, + ReportContext::XPST0081, + ReportContext::XPST0081>($7.at(i).first, parseInfo->staticContext, + parseInfo->staticContext->namespaceBindings(), + &ryy, true); + if(declaredAttributes.contains(att)) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("An attribute by name %1 has already appeared on this element.") + .arg(formatKeyword(parseInfo->staticContext->namePool(), att)), + ReportContext::XQST0040, fromYYLTYPE(@$, parseInfo)); + + } + else + declaredAttributes.insert(att); + + /* wrapLiteral() needs the SourceLocationReflection of the AttributeConstructor, but + * it's unknown inside the arguments to its constructor. Hence we have to do this workaround of setting + * it twice. + * + * The AttributeConstructor's arguments are just dummies. */ + const Expression::Ptr ctor(create(new AttributeConstructor($7.at(i).second, $7.at(i).second), @$, parseInfo)); + + Expression::List ops; + ops.append(wrapLiteral(toItem(QNameValue::fromValue(namePool, att)), parseInfo->staticContext, ctor.data())); + ops.append($7.at(i).second); + ctor->setOperands(ops); + + attributes.append(ctor); + } + } + + Expression::Ptr contentOp; + + if(attributes.isEmpty()) + contentOp = $8; + else + { + attributes.append($8); + contentOp = create(new ExpressionSequence(attributes), @$, parseInfo); + } + + const Expression::Ptr name(create(new Literal(toItem(QNameValue::fromValue(parseInfo->staticContext->namePool(), parseInfo->tagStack.top()))), @$, parseInfo)); + $$ = create(new ElementConstructor(name, contentOp, parseInfo->isXSLT()), @$, parseInfo); + + /* Restore the old context. We don't want the namespaces + * to be in-scope for expressions appearing after the + * element they appeared on. */ + parseInfo->staticContext->setNamespaceBindings(parseInfo->resolvers.pop()); + parseInfo->tagStack.pop(); + + --parseInfo->elementConstructorDepth; + } + +DirElemConstructorTail: QUICK_TAG_END + { + $$ = create(new EmptySequence(), @$, parseInfo); + } +| G_GT DirElemContent BEGIN_END_TAG ElementName G_GT + { + if(!$4.isLexicallyEqual(parseInfo->tagStack.top())) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("A direct element constructor is not " + "well-formed. %1 is ended with %2.") + .arg(formatKeyword(parseInfo->staticContext->namePool()->toLexical(parseInfo->tagStack.top())), + formatKeyword(parseInfo->staticContext->namePool()->toLexical($4))), + ReportContext::XPST0003, fromYYLTYPE(@$, parseInfo)); + } + + if($2.isEmpty()) + $$ = create(new EmptySequence(), @$, parseInfo); + else if($2.size() == 1) + $$ = $2.first(); + else + $$ = create(new ExpressionSequence($2), @$, parseInfo); + } + +DirAttributeList: /* empty */ /* [97] */ + { + $$ = AttributeHolderVector(); + } +| DirAttributeList Attribute + { + $1.append($2); + $$ = $1; + } + +Attribute: LexicalName G_EQ DirAttributeValue /* [X] */ + { + $$ = qMakePair($1, $3); + } + +DirAttributeValue: QUOTE AttrValueContent QUOTE /* [98] */ + { + $$ = createDirAttributeValue($2, parseInfo, @$); + } + +| APOS AttrValueContent APOS + { + $$ = createDirAttributeValue($2, parseInfo, @$); + } + +AttrValueContent: /* Empty. */ /* [X] */ + { + $$ = Expression::List(); + } +| EnclosedExpr AttrValueContent + { + Expression::Ptr content($1); + + if(parseInfo->isBackwardsCompat.top()) + content = create(GenericPredicate::createFirstItem(content), @$, parseInfo); + + $2.prepend(createSimpleContent(content, @$, parseInfo)); + $$ = $2; + } +| StringLiteral AttrValueContent + { + $2.prepend(create(new Literal(AtomicString::fromValue($1)), @$, parseInfo)); + $$ = $2; + } + +DirElemContent: /* empty */ /* [101] */ + { + $$ = Expression::List(); + parseInfo->isPreviousEnclosedExpr = false; + } +| DirElemContent DirectConstructor + { + $1.append($2); + $$ = $1; + parseInfo->isPreviousEnclosedExpr = false; + } +| DirElemContent StringLiteral + { + if(parseInfo->staticContext->boundarySpacePolicy() == StaticContext::BSPStrip && + XPathHelper::isWhitespaceOnly($2)) + { + $$ = $1; + } + else + { + $1.append(create(new TextNodeConstructor(create(new Literal(AtomicString::fromValue($2)), @$, parseInfo)), @$, parseInfo)); + $$ = $1; + parseInfo->isPreviousEnclosedExpr = false; + } + } +| DirElemContent NON_BOUNDARY_WS + { + $1.append(create(new TextNodeConstructor(create(new Literal(AtomicString::fromValue($2)), @$, parseInfo)), @$, parseInfo)); + $$ = $1; + parseInfo->isPreviousEnclosedExpr = false; + } +| DirElemContent EnclosedExpr + { + /* We insert a text node constructor that send an empty text node between + * the two enclosed expressions, in order to ensure that no space is inserted. + * + * However, we only do it when we have no node constructors. */ + if(parseInfo->isPreviousEnclosedExpr && + BuiltinTypes::xsAnyAtomicType->xdtTypeMatches($2->staticType()->itemType()) && + BuiltinTypes::xsAnyAtomicType->xdtTypeMatches($1.last()->staticType()->itemType())) + $1.append(create(new TextNodeConstructor(create(new Literal(AtomicString::fromValue(QString())), @$, parseInfo)), @$, parseInfo)); + else + parseInfo->isPreviousEnclosedExpr = true; + + $1.append(createCopyOf($2, parseInfo, @$)); + $$ = $1; + } + +DirCommentConstructor: COMMENT_START COMMENT_CONTENT /* [103] */ + { + $$ = create(new CommentConstructor(create(new Literal(AtomicString::fromValue($2)), @$, parseInfo)), @$, parseInfo); + } + +DirPIConstructor: PI_START PI_TARGET PI_CONTENT /* [105] */ + { + const ReflectYYLTYPE ryy(@$, parseInfo); + NCNameConstructor::validateTargetName<StaticContext::Ptr, + ReportContext::XPST0003, + ReportContext::XPST0003>($2, + parseInfo->staticContext, &ryy); + + $$ = create(new ProcessingInstructionConstructor( + create(new Literal(AtomicString::fromValue($2)), @$, parseInfo), + create(new Literal(AtomicString::fromValue($3)), @$, parseInfo)), @$, parseInfo); + } + +ComputedConstructor: CompDocConstructor /* [109] */ +| CompElemConstructor +| CompAttrConstructor +| CompTextConstructor +| CompCommentConstructor +| CompPIConstructor +| CompNamespaceConstructor + +CompDocConstructor: DOCUMENT IsInternal EnclosedExpr /* [110] */ + { + allowedIn(QXmlQuery::XQuery10, parseInfo, @$, $2); + + $$ = create(new DocumentConstructor($3), @$, parseInfo); + } + +CompElemConstructor: ELEMENT IsInternal CompElementName + { + /* This value is incremented before the action below is executed. */ + ++parseInfo->elementConstructorDepth; + } + EnclosedOptionalExpr /* [111] */ + { + Q_ASSERT(5); + allowedIn(QXmlQuery::XQuery10, parseInfo, @$, $2); + + Expression::Ptr effExpr; + + if($5) + effExpr = createCopyOf($5, parseInfo, @$); + else + effExpr = create(new EmptySequence(), @$, parseInfo); + + const QXmlName::NamespaceCode ns = parseInfo->resolvers.top()->lookupNamespaceURI(StandardPrefixes::empty); + + /* Ensure the default namespace gets counted as an in-scope binding, if such a one exists. If we're + * a child of another constructor, it has already been done. */ + if(parseInfo->elementConstructorDepth == 1 && ns != StandardNamespaces::empty) + { + Expression::List exprList; + + /* We append the namespace constructor before the body, in order to + * comply with QAbstractXmlPushHandler's contract. */ + const QXmlName def(parseInfo->resolvers.top()->lookupNamespaceURI(StandardPrefixes::empty), StandardLocalNames::empty); + exprList.append(create(new NamespaceConstructor(def), @$, parseInfo)); + + exprList.append(effExpr); + + effExpr = create(new ExpressionSequence(exprList), @$, parseInfo); + } + + --parseInfo->elementConstructorDepth; + $$ = create(new ElementConstructor($3, effExpr, parseInfo->isXSLT()), @$, parseInfo); + } + +IsInternal: /* Empty. */ /* [X] */ + { + $$ = false; + } +| INTERNAL + { + $$ = true; + } + +CompAttrConstructor: ATTRIBUTE + IsInternal + CompAttributeName + EnclosedOptionalExpr /* [113] */ + { + allowedIn(QXmlQuery::XQuery10, parseInfo, @$, $2); + + const Expression::Ptr name(create(new AttributeNameValidator($3), @$, parseInfo)); + + if($4) + $$ = create(new AttributeConstructor(name, createSimpleContent($4, @$, parseInfo)), @$, parseInfo); + else + $$ = create(new AttributeConstructor(name, create(new EmptySequence(), @$, parseInfo)), @$, parseInfo); + } + +CompTextConstructor: TEXT IsInternal EnclosedExpr /* [114] */ + { + $$ = create(new TextNodeConstructor(createSimpleContent($3, @$, parseInfo)), @$, parseInfo); + } + +CompCommentConstructor: COMMENT IsInternal EnclosedExpr /* [115] */ + { + allowedIn(QXmlQuery::XQuery10, parseInfo, @$, $2); + + $$ = create(new CommentConstructor(createSimpleContent($3, @$, parseInfo)), @$, parseInfo); + } + +CompPIConstructor: PROCESSING_INSTRUCTION CompPIName EnclosedOptionalExpr /* [116] */ + { + allowedIn(QXmlQuery::XQuery10, parseInfo, @$, $2); + + if($3) + { + $$ = create(new ProcessingInstructionConstructor($2, createSimpleContent($3, @$, parseInfo)), @$, parseInfo); + } + else + $$ = create(new ProcessingInstructionConstructor($2, create(new EmptySequence(), @$, parseInfo)), @$, parseInfo); + } + +CompAttributeName: { + parseInfo->nodeTestSource = BuiltinTypes::attribute; + } + ElementName + { + parseInfo->restoreNodeTestSource(); + } /* [X] */ + { + $$ = create(new Literal(toItem(QNameValue::fromValue(parseInfo->staticContext->namePool(), $2))), @$, parseInfo); + } +| CompNameExpr + +CompElementName: ElementName /* [X] */ + { + $$ = create(new Literal(toItem(QNameValue::fromValue(parseInfo->staticContext->namePool(), $1))), @$, parseInfo); + } +| CompNameExpr + +CompNameExpr: EnclosedExpr + { + if(BuiltinTypes::xsQName->xdtTypeMatches($1->staticType()->itemType())) + $$ = $1; + else + { + $$ = create(new QNameConstructor($1, + parseInfo->staticContext->namespaceBindings()), + @$, parseInfo); + } + } + +/* + * We always create an NCNameConstructor here. If will be rewritten away if not needed. + */ +CompPIName: NCNAME + { + $$ = create(new NCNameConstructor(create(new Literal(AtomicString::fromValue($1)), @$, parseInfo)), @$, parseInfo); + } +| EnclosedExpr + { + $$ = create(new NCNameConstructor($1), @$, parseInfo); + } + +/* + * This expression is used for implementing XSL-T 2.0's xsl:namespace + * instruction. + */ +CompNamespaceConstructor: NAMESPACE EnclosedExpr EnclosedExpr /* [X] */ +{ + $$ = create(new ComputedNamespaceConstructor($2, $3), @$, parseInfo); +} + +SingleType: AtomicType /* [117] */ + { + $$ = makeGenericSequenceType($1, Cardinality::exactlyOne()); + } +| AtomicType QUESTION + { + $$ = makeGenericSequenceType($1, Cardinality::zeroOrOne()); + } + +TypeDeclaration: /* empty */ /* [118] */ + { + $$ = CommonSequenceTypes::ZeroOrMoreItems; + } +| AS SequenceType + { + $$ = $2; + } + +SequenceType: ItemType OccurrenceIndicator /* [119] */ + { + $$ = makeGenericSequenceType($1, $2); + } + +| EMPTY_SEQUENCE EmptyParanteses + { + $$ = CommonSequenceTypes::Empty; + } + +OccurrenceIndicator: /* empty */ {$$ = Cardinality::exactlyOne();} /* [120] */ +| PLUS {$$ = Cardinality::oneOrMore();} +| STAR {$$ = Cardinality::zeroOrMore();} +| QUESTION {$$ = Cardinality::zeroOrOne();} + +ItemType: AtomicType /* [121] */ +| KindTest +| AnyAttributeTest +| ITEM EmptyParanteses + { + $$ = BuiltinTypes::item; + } + +AtomicType: ElementName /* [122] */ + { + const SchemaType::Ptr t(parseInfo->staticContext->schemaDefinitions()->createSchemaType($1)); + + if(!t) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("The name %1 does not refer to any schema type.") + .arg(formatKeyword(parseInfo->staticContext->namePool(), $1)), ReportContext::XPST0051, fromYYLTYPE(@$, parseInfo)); + } + else if(BuiltinTypes::xsAnyAtomicType->wxsTypeMatches(t)) + $$ = AtomicType::Ptr(t); + else + { + /* Try to give an intelligent message. */ + if(t->isComplexType()) + { + parseInfo->staticContext->error(QtXmlPatterns::tr("%1 is an complex type. Casting to complex " + "types is not possible. However, casting " + "to atomic types such as %2 works.") + .arg(formatType(parseInfo->staticContext->namePool(), t)) + .arg(formatType(parseInfo->staticContext->namePool(), BuiltinTypes::xsInteger)), + ReportContext::XPST0051, fromYYLTYPE(@$, parseInfo)); + } + else + { + parseInfo->staticContext->error(QtXmlPatterns::tr("%1 is not an atomic type. Casting " + "is only possible to atomic types.") + .arg(formatType(parseInfo->staticContext->namePool(), t)), + ReportContext::XPST0051, fromYYLTYPE(@$, parseInfo)); + } + } + } + +/* This non-terminal does not contain SchemaAttributeTest and AttributeTest. + Those are in the AnyAttributeTest non-terminal. This is in order to get the axis + right for attribute tests in the abbreviated syntax. */ +KindTest: DocumentTest /* [123] */ +| ElementTest +| SchemaElementTest +| PITest +| CommentTest +| TextTest +| AnyKindTest + +AnyKindTest: NODE EmptyParanteses /* [124] */ + { + $$ = BuiltinTypes::node; + } + +DocumentTest: DOCUMENT_NODE EmptyParanteses /* [125] */ + { + $$ = BuiltinTypes::document; + } + +| DOCUMENT_NODE LPAREN AnyElementTest RPAREN + { + // TODO support for document element testing + $$ = BuiltinTypes::document; + } + +AnyElementTest: ElementTest /* [X] */ +| SchemaElementTest + +TextTest: TEXT EmptyParanteses /* [126] */ + { + $$ = BuiltinTypes::text; + } + +CommentTest: COMMENT EmptyParanteses /* [127] */ + { + $$ = BuiltinTypes::comment; + } + +PITest: PROCESSING_INSTRUCTION EmptyParanteses /* [128] */ + { + $$ = BuiltinTypes::pi; + } + +| PROCESSING_INSTRUCTION LPAREN NCNAME RPAREN + { + $$ = LocalNameTest::create(BuiltinTypes::pi, parseInfo->staticContext->namePool()->allocateLocalName($3)); + } + +| PROCESSING_INSTRUCTION LPAREN StringLiteral RPAREN + { + if(QXmlUtils::isNCName($3)) + { + $$ = LocalNameTest::create(BuiltinTypes::pi, parseInfo->staticContext->namePool()->allocateLocalName($3)); + } + else + { + parseInfo->staticContext->error(QtXmlPatterns::tr("%1 is not a valid name for a " + "processing-instruction.") + .arg(formatKeyword($3)), + ReportContext::XPTY0004, + fromYYLTYPE(@$, parseInfo)); + } + } + +AnyAttributeTest: AttributeTest +| SchemaAttributeTest + +AttributeTest: ATTRIBUTE EmptyParanteses /* [129] */ + { + $$ = BuiltinTypes::attribute; + } + +| ATTRIBUTE LPAREN STAR RPAREN + { + $$ = BuiltinTypes::attribute; + } + +| ATTRIBUTE LPAREN AttributeName RPAREN + { + $$ = QNameTest::create(BuiltinTypes::attribute, $3); + } +| ATTRIBUTE LPAREN AttributeName COMMA TypeName RPAREN + { + const SchemaType::Ptr t(parseInfo->staticContext->schemaDefinitions()->createSchemaType($5)); + + if(t) + $$ = BuiltinTypes::attribute; + else + { + parseInfo->staticContext->error(unknownType().arg(formatKeyword(parseInfo->staticContext->namePool(), $5)), + ReportContext::XPST0008, fromYYLTYPE(@$, parseInfo)); + } + } +| ATTRIBUTE LPAREN STAR COMMA TypeName RPAREN + { + const SchemaType::Ptr t(parseInfo->staticContext->schemaDefinitions()->createSchemaType($5)); + + if(t) + $$ = BuiltinTypes::attribute; + else + { + parseInfo->staticContext->error(unknownType().arg(formatKeyword(parseInfo->staticContext->namePool(), $5)), + ReportContext::XPST0008, fromYYLTYPE(@$, parseInfo)); + } + } + +SchemaAttributeTest: SCHEMA_ATTRIBUTE LPAREN ElementName RPAREN /* [131] */ + { + parseInfo->staticContext->error(QtXmlPatterns::tr("%1 is not in the in-scope attribute " + "declarations. Note that the schema import " + "feature is not supported.") + .arg(formatKeyword(parseInfo->staticContext->namePool(), $3)), + ReportContext::XPST0008, fromYYLTYPE(@$, parseInfo)); + $$.reset(); + } + +ElementTest: ELEMENT EmptyParanteses /* [133] */ + { + $$ = BuiltinTypes::element; + } + +| ELEMENT LPAREN STAR RPAREN + { + $$ = BuiltinTypes::element; + } + +| ELEMENT LPAREN ElementName RPAREN + { + $$ = QNameTest::create(BuiltinTypes::element, $3); + } + +| ELEMENT LPAREN ElementName COMMA TypeName OptionalQuestionMark RPAREN + { + const SchemaType::Ptr t(parseInfo->staticContext->schemaDefinitions()->createSchemaType($5)); + + if(t) + $$ = BuiltinTypes::element; + else + { + parseInfo->staticContext->error(unknownType() + .arg(formatKeyword(parseInfo->staticContext->namePool(), $5)), + ReportContext::XPST0008, fromYYLTYPE(@$, parseInfo)); + } + } + +| ELEMENT LPAREN STAR COMMA TypeName OptionalQuestionMark RPAREN + { + const SchemaType::Ptr t(parseInfo->staticContext->schemaDefinitions()->createSchemaType($5)); + + if(t) + $$ = BuiltinTypes::element; + else + { + parseInfo->staticContext->error(QtXmlPatterns::tr("%1 is an unknown schema type.") + .arg(formatKeyword(parseInfo->staticContext->namePool(), $5)), + ReportContext::XPST0008, fromYYLTYPE(@$, parseInfo)); + } + } + +OptionalQuestionMark: /* Empty. */ +| QUESTION + +SchemaElementTest: SCHEMA_ELEMENT LPAREN ElementName RPAREN /* [135] */ + { + parseInfo->staticContext->error(QtXmlPatterns::tr("%1 is not in the in-scope attribute " + "declarations. Note that the schema import " + "feature is not supported.") + .arg(formatKeyword(parseInfo->staticContext->namePool(), $3)), + ReportContext::XPST0008, fromYYLTYPE(@$, parseInfo)); + $$.reset(); + } + +EmptyParanteses: LPAREN RPAREN /* [X] */ + +AttributeName: NCNAME /* [137] */ + { + $$ = parseInfo->staticContext->namePool()->allocateQName(StandardNamespaces::empty, $1); + } + +| QName + +/* + * When a QName appear with no prefix, it uses a certain default namespace + * depending on where the QName occurs. These two rules, invoked in the appropriate + * contexts, performs this distinction. + */ +ElementName: NCNAME /* [138] */ + { + if(parseInfo->nodeTestSource == BuiltinTypes::element) + $$ = parseInfo->staticContext->namePool()->allocateQName(parseInfo->staticContext->namespaceBindings()->lookupNamespaceURI(StandardPrefixes::empty), $1); + else + $$ = parseInfo->staticContext->namePool()->allocateQName(StandardNamespaces::empty, $1); + } +| QName + +TypeName: ElementName /* [139] */ + +FunctionName: NCName /* [X] */ +| QName + +NCName: NCNAME + { + $$ = parseInfo->staticContext->namePool()->allocateQName(parseInfo->staticContext->defaultFunctionNamespace(), $1); + } +| INTERNAL_NAME NCNAME + { + $$ = parseInfo->staticContext->namePool()->allocateQName(StandardNamespaces::InternalXSLT, $2); + } + +LexicalName: NCNAME +| QNAME + +PragmaName: NCNAME /* [X] */ + { + parseInfo->staticContext->error(QtXmlPatterns::tr("The name of an extension expression must be in " + "a namespace."), + ReportContext::XPST0081, fromYYLTYPE(@$, parseInfo)); + } +| QName + +URILiteral: StringLiteral /* [140] */ + +StringLiteral: STRING_LITERAL /* [144] */ + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XPath20), parseInfo, @$); + } +| XPATH2_STRING_LITERAL + { + allowedIn(QueryLanguages(QXmlQuery::XQuery10 | QXmlQuery::XPath20), parseInfo, @$); + } + +QName: QNAME /* [154] */ + { + + const ReflectYYLTYPE ryy(@$, parseInfo); + + $$ = QNameConstructor:: + expandQName<StaticContext::Ptr, + ReportContext::XPST0081, + ReportContext::XPST0081>($1, parseInfo->staticContext, + parseInfo->staticContext->namespaceBindings(), &ryy); + + } +| CLARK_NAME + { + $$ = parseInfo->staticContext->namePool()->fromClarkName($1); + } + +%% + +QString Tokenizer::tokenToString(const Token &token) +{ + switch(token.type) + { + case NCNAME: + /* Fallthrough. */ + case QNAME: + /* Fallthrough. */ + case NUMBER: + /* Fallthrough. */ + case XPATH2_NUMBER: + return token.value; + case STRING_LITERAL: + return QLatin1Char('"') + token.value + QLatin1Char('"'); + default: + { + const QString raw(QString::fromLatin1(yytname[YYTRANSLATE(token.type)])); + + /* Remove the quotes. */ + if(raw.at(0) == QLatin1Char('"') && raw.length() > 1) + return raw.mid(1, raw.length() - 2); + else + return raw; + } + } +} + +} /* namespace Patternist */ + +QT_END_NAMESPACE + +// vim: et:ts=4:sw=4:sts=4:syntax=yacc |