summaryrefslogtreecommitdiff
path: root/src/xmlpatterns/parser
diff options
context:
space:
mode:
Diffstat (limited to 'src/xmlpatterns/parser')
-rw-r--r--src/xmlpatterns/parser/.gitattributes4
-rw-r--r--src/xmlpatterns/parser/.gitignore1
-rw-r--r--src/xmlpatterns/parser/TokenLookup.gperf223
-rwxr-xr-xsrc/xmlpatterns/parser/createParser.sh15
-rwxr-xr-xsrc/xmlpatterns/parser/createTokenLookup.sh5
-rwxr-xr-xsrc/xmlpatterns/parser/createXSLTTokenLookup.sh3
-rw-r--r--src/xmlpatterns/parser/parser.pri19
-rw-r--r--src/xmlpatterns/parser/qmaintainingreader.cpp273
-rw-r--r--src/xmlpatterns/parser/qmaintainingreader_p.h233
-rw-r--r--src/xmlpatterns/parser/qparsercontext.cpp100
-rw-r--r--src/xmlpatterns/parser/qparsercontext_p.h433
-rw-r--r--src/xmlpatterns/parser/qquerytransformparser.cpp7976
-rw-r--r--src/xmlpatterns/parser/qquerytransformparser_p.h307
-rw-r--r--src/xmlpatterns/parser/qtokenizer_p.h216
-rw-r--r--src/xmlpatterns/parser/qtokenlookup.cpp404
-rw-r--r--src/xmlpatterns/parser/qtokenrevealer.cpp111
-rw-r--r--src/xmlpatterns/parser/qtokenrevealer_p.h97
-rw-r--r--src/xmlpatterns/parser/qtokensource.cpp53
-rw-r--r--src/xmlpatterns/parser/qtokensource_p.h169
-rw-r--r--src/xmlpatterns/parser/querytransformparser.ypp4572
-rw-r--r--src/xmlpatterns/parser/qxquerytokenizer.cpp2249
-rw-r--r--src/xmlpatterns/parser/qxquerytokenizer_p.h332
-rw-r--r--src/xmlpatterns/parser/qxslttokenizer.cpp2717
-rw-r--r--src/xmlpatterns/parser/qxslttokenizer_p.h481
-rw-r--r--src/xmlpatterns/parser/qxslttokenlookup.cpp3006
-rw-r--r--src/xmlpatterns/parser/qxslttokenlookup.xml167
-rw-r--r--src/xmlpatterns/parser/qxslttokenlookup_p.h213
-rw-r--r--src/xmlpatterns/parser/trolltechHeader.txt51
-rw-r--r--src/xmlpatterns/parser/winCEWorkaround.sed20
29 files changed, 24450 insertions, 0 deletions
diff --git a/src/xmlpatterns/parser/.gitattributes b/src/xmlpatterns/parser/.gitattributes
new file mode 100644
index 0000000000..61b39a87ec
--- /dev/null
+++ b/src/xmlpatterns/parser/.gitattributes
@@ -0,0 +1,4 @@
+qquerytransformparser.cpp -diff Unset
+qquerytransformparser_p.h -diff Unset
+qxslttokenlookup.cpp -diff Unset
+qxslttokenlookup_p.h -diff Unset
diff --git a/src/xmlpatterns/parser/.gitignore b/src/xmlpatterns/parser/.gitignore
new file mode 100644
index 0000000000..615637a31d
--- /dev/null
+++ b/src/xmlpatterns/parser/.gitignore
@@ -0,0 +1 @@
+qquerytransformparser.output
diff --git a/src/xmlpatterns/parser/TokenLookup.gperf b/src/xmlpatterns/parser/TokenLookup.gperf
new file mode 100644
index 0000000000..e55007ed88
--- /dev/null
+++ b/src/xmlpatterns/parser/TokenLookup.gperf
@@ -0,0 +1,223 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/**
+ * @file qtokenlookup.cpp
+ * @short This file is generated from TokenLookup.gperf and contains
+ * TokenLookup, a class housing a perfect hash function class for XQuery's keywords.
+ * @author Frans Englich <fenglich@trolltech.com>
+ */
+
+/**
+ * @class QPatternist::TokenLookup
+ * @short Contains a perfect hash function for XQuery's keywords.
+ */
+
+/**
+ * @fn QPatternist::TokenLookup::value(const QString &keyword)
+ * Looks up @p keyword and returns a pointer to the corresponding value.
+ *
+ * If @p keyword is not contained in the hash, a null pointer is returned.
+ */
+
+/**
+ * @file
+ * @short This file is the @c gperf declaration for generating TokenLookup.cpp.
+ *
+ * You generate TokenLookup.cpp by running:
+ *
+ * @code
+ * gperf TokenLookup.gperf --output-file=../src/parser/TokenLookup.cpp
+ * @endcode
+ *
+ * @c gperf generates a perfect hash function, which the tokenizer, src/parser/qxquerytokenizer.cpp,
+ * uses for looking up XQuery keywords.
+ *
+ * @see <a href="http://en.wikipedia.org/wiki/Perfect_hash_function">Perfect hash function, Wikipedia</a>
+ * @see <a href="http://www.gnu.org/software/gperf/manual/gperf.html">Perfect Hash Function Generator</a>
+ */
+
+%language=C++
+
+/* Declare data const such that the compiler can put them
+ * in the read-only section. */
+%readonly-tables
+
+/* Yes, for crisps sake, we want enums instead of macros. */
+%enum
+
+/* Rename in_word_set to value, such that it's more
+ * like QHash::value(). */
+%define lookup-function-name value
+
+/* Rename Perfect_Hash to TokenLookup. More Qt/Patternist'ish. */
+%define class-name TokenLookup
+
+/* Output initializers for the TokenMap struct. Note the lack
+ * of a space between the comma and ERROR. Anything else is
+ * a syntax error to gperf. Rocket science. */
+%define initializer-suffix ,ERROR
+
+%struct-type
+
+struct TokenMap
+{
+ const char *name;
+ const Tokenizer::TokenType token;
+}
+
+%{
+
+QT_BEGIN_NAMESPACE
+
+namespace QPatternist
+{
+
+%}
+
+/* The strings below are in UTF-16 encoding. Subsequently, each ASCII
+ * character is stored as the ASCII character, followed by a null byte.
+ * Sorted alphabetically. */
+%%
+"ancestor", ANCESTOR
+"ancestor-or-self", ANCESTOR_OR_SELF
+"and", AND
+"as", AS
+"ascending", ASCENDING
+"assign", ASSIGN
+"at", AT
+"attribute", ATTRIBUTE
+"base-uri", BASEURI
+"boundary-space", BOUNDARY_SPACE
+"by", BY
+"case", CASE
+"castable", CASTABLE
+"cast", CAST
+"child", CHILD
+"collation", COLLATION
+"comment", COMMENT
+"construction", CONSTRUCTION
+"copy-namespaces", COPY_NAMESPACES
+"declare", DECLARE
+"default", DEFAULT
+"descendant", DESCENDANT
+"descendant-or-self", DESCENDANT_OR_SELF
+"descending", DESCENDING
+"div", DIV
+"document", DOCUMENT
+"document-node", DOCUMENT_NODE
+"element", ELEMENT
+"else", ELSE
+"empty", EMPTY
+"empty-sequence", EMPTY_SEQUENCE
+"encoding", ENCODING
+"eq", EQ
+"every", EVERY
+"except", EXCEPT
+"external", EXTERNAL
+"following", FOLLOWING
+"following-sibling", FOLLOWING_SIBLING
+"follows", FOLLOWS
+"for", FOR
+"function", FUNCTION
+"ge", GE
+"greatest", GREATEST
+"gt", GT
+"idiv", IDIV
+"if", IF
+"import", IMPORT
+"inherit", INHERIT
+"in", IN
+"instance", INSTANCE
+"intersect", INTERSECT
+"is", IS
+"item", ITEM
+"lax", LAX
+"least", LEAST
+"le", LE
+"let", LET
+"lt", LT
+"mod", MOD
+"module", MODULE
+"namespace", NAMESPACE
+"ne", NE
+"node", NODE
+"no-inherit", NO_INHERIT
+"no-preserve", NO_PRESERVE
+"of", OF
+"option", OPTION
+"ordered", ORDERED
+"ordering", ORDERING
+"order", ORDER
+"or", OR
+"parent", PARENT
+"precedes", PRECEDES
+"preceding", PRECEDING
+"preceding-sibling", PRECEDING_SIBLING
+"preserve", PRESERVE
+"processing-instruction", PROCESSING_INSTRUCTION
+"return", RETURN
+"satisfies", SATISFIES
+"schema-attribute", SCHEMA_ATTRIBUTE
+"schema-element", SCHEMA_ELEMENT
+"schema", SCHEMA
+"self", SELF
+"some", SOME
+"stable", STABLE
+"strict", STRICT
+"strip", STRIP
+"text", TEXT
+"then", THEN
+"to", TO
+"treat", TREAT
+"typeswitch", TYPESWITCH
+"union", UNION
+"unordered", UNORDERED
+"validate", VALIDATE
+"variable", VARIABLE
+"version", VERSION
+"where", WHERE
+"xquery", XQUERY
+%%
+
+} /* Close the QPatternist namespace. */
+
+QT_END_NAMESPACE
diff --git a/src/xmlpatterns/parser/createParser.sh b/src/xmlpatterns/parser/createParser.sh
new file mode 100755
index 0000000000..51453eeaf5
--- /dev/null
+++ b/src/xmlpatterns/parser/createParser.sh
@@ -0,0 +1,15 @@
+#!/bin/bash
+
+files="qquerytransformparser_p.h qquerytransformparser.cpp"
+
+#p4 revert $files
+#p4 edit $files
+bison --defines=qquerytransformparser_p.h querytransformparser.ypp
+
+addHeaderScript="1{h; r trolltechHeader.txt
+ D; }
+2{x; G; }"
+sed -i -e "$addHeaderScript" $files
+
+sed -i -f winCEWorkaround.sed qquerytransformparser_p.h
+#p4 revert -a $files
diff --git a/src/xmlpatterns/parser/createTokenLookup.sh b/src/xmlpatterns/parser/createTokenLookup.sh
new file mode 100755
index 0000000000..a4e1effb3d
--- /dev/null
+++ b/src/xmlpatterns/parser/createTokenLookup.sh
@@ -0,0 +1,5 @@
+outFile="qtokenlookup.cpp"
+
+# Watch out, the --output option is not supported in the
+# gperf version that apt-get pulls in on Mac OS X.
+gperf TokenLookup.gperf > $outFile
diff --git a/src/xmlpatterns/parser/createXSLTTokenLookup.sh b/src/xmlpatterns/parser/createXSLTTokenLookup.sh
new file mode 100755
index 0000000000..3a60dc4eff
--- /dev/null
+++ b/src/xmlpatterns/parser/createXSLTTokenLookup.sh
@@ -0,0 +1,3 @@
+#!/bin/sh
+xmllint --noout --schema ../qtokenautomaton/qtokenautomaton.xsd qxslttokenlookup.xml
+java net.sf.saxon.Transform -xsl:../qtokenautomaton/qautomaton2cpp.xsl qxslttokenlookup.xml
diff --git a/src/xmlpatterns/parser/parser.pri b/src/xmlpatterns/parser/parser.pri
new file mode 100644
index 0000000000..6656290fe8
--- /dev/null
+++ b/src/xmlpatterns/parser/parser.pri
@@ -0,0 +1,19 @@
+hpux-g++*:QMAKE_CXXFLAGS += -mbig-switch
+
+HEADERS += $$PWD/qparsercontext_p.h \
+ $$PWD/qmaintainingreader_p.h \
+ $$PWD/qquerytransformparser_p.h \
+ $$PWD/qtokenizer_p.h \
+ $$PWD/qtokenrevealer_p.h \
+ $$PWD/qtokensource_p.h \
+ $$PWD/qxquerytokenizer_p.h \
+ $$PWD/qxslttokenizer_p.h \
+ $$PWD/qxslttokenlookup_p.h
+
+SOURCES += $$PWD/qquerytransformparser.cpp \
+ $$PWD/qparsercontext.cpp \
+ $$PWD/qtokenrevealer.cpp \
+ $$PWD/qtokensource.cpp \
+ $$PWD/qxquerytokenizer.cpp \
+ $$PWD/qxslttokenizer.cpp \
+ $$PWD/qxslttokenlookup.cpp
diff --git a/src/xmlpatterns/parser/qmaintainingreader.cpp b/src/xmlpatterns/parser/qmaintainingreader.cpp
new file mode 100644
index 0000000000..0ac0804323
--- /dev/null
+++ b/src/xmlpatterns/parser/qmaintainingreader.cpp
@@ -0,0 +1,273 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/**
+ * @file
+ * @short This file is included by qcastingplatform_p.h.
+ * If you need includes in this file, put them in CasttingPlatform.h,
+ * outside of the namespace.
+ */
+
+template<typename TokenLookupClass,
+ typename LookupKey>
+MaintainingReader<TokenLookupClass, LookupKey>::MaintainingReader(const typename ElementDescription<TokenLookupClass, LookupKey>::Hash &elementDescriptions,
+ const QSet<typename TokenLookupClass::NodeName> &standardAttributes,
+ const ReportContext::Ptr &context,
+ QIODevice *const queryDevice) : QXmlStreamReader(queryDevice)
+ , m_hasHandledStandardAttributes(false)
+ , m_context(context)
+ , m_elementDescriptions(elementDescriptions)
+ , m_standardAttributes(standardAttributes)
+{
+ Q_ASSERT(m_context);
+ Q_ASSERT(!m_elementDescriptions.isEmpty());
+
+ /* We start with stripping. */
+ m_stripWhitespace.push(true);
+}
+
+template<typename TokenLookupClass,
+ typename LookupKey>
+MaintainingReader<TokenLookupClass, LookupKey>::~MaintainingReader()
+{
+}
+
+template<typename TokenLookupClass,
+ typename LookupKey>
+QSourceLocation MaintainingReader<TokenLookupClass, LookupKey>::currentLocation() const
+{
+ return QSourceLocation(documentURI(),
+ lineNumber(),
+ columnNumber());
+}
+
+template<typename TokenLookupClass,
+ typename LookupKey>
+QXmlStreamReader::TokenType MaintainingReader<TokenLookupClass, LookupKey>::readNext()
+{
+ const TokenType retval = QXmlStreamReader::readNext();
+
+ switch(retval)
+ {
+ case StartElement:
+ {
+ m_currentElementName = TokenLookupClass::toToken(name());
+ m_currentAttributes = attributes();
+ m_hasHandledStandardAttributes = false;
+
+ if(!m_currentAttributes.hasAttribute(QLatin1String("xml:space")))
+ m_stripWhitespace.push(m_stripWhitespace.top());
+ break;
+ }
+ case EndElement:
+ m_currentElementName = TokenLookupClass::toToken(name());
+ m_stripWhitespace.pop();
+ break;
+ default:
+ break;
+ }
+
+ return retval;
+}
+
+template<typename TokenLookupClass,
+ typename LookupKey>
+bool MaintainingReader<TokenLookupClass, LookupKey>::isWhitespace() const
+{
+ return QXmlStreamReader::isWhitespace()
+ || XPathHelper::isWhitespaceOnly(text());
+}
+
+
+template<typename TokenLookupClass,
+ typename LookupKey>
+void MaintainingReader<TokenLookupClass, LookupKey>::error(const QString &message,
+ const ReportContext::ErrorCode code) const
+{
+ m_context->error(message, code, currentLocation());
+}
+
+template<typename TokenLookupClass,
+ typename LookupKey>
+void MaintainingReader<TokenLookupClass, LookupKey>::warning(const QString &message) const
+{
+ m_context->warning(message, currentLocation());
+}
+
+template<typename TokenLookupClass,
+ typename LookupKey>
+typename TokenLookupClass::NodeName MaintainingReader<TokenLookupClass, LookupKey>::currentElementName() const
+{
+ return m_currentElementName;
+}
+
+template<typename TokenLookupClass,
+ typename LookupKey>
+void MaintainingReader<TokenLookupClass, LookupKey>::validateElement(const LookupKey elementName) const
+{
+ Q_ASSERT(tokenType() == QXmlStreamReader::StartElement);
+
+ if(m_elementDescriptions.contains(elementName))
+ {
+ const ElementDescription<TokenLookupClass, LookupKey> &desc = m_elementDescriptions.value(elementName);
+ const int attCount = m_currentAttributes.count();
+
+ QSet<typename TokenLookupClass::NodeName> encounteredXSLTAtts;
+
+ for(int i = 0; i < attCount; ++i)
+ {
+ const QXmlStreamAttribute &attr = m_currentAttributes.at(i);
+ if(attr.namespaceUri().isEmpty())
+ {
+ const typename TokenLookupClass::NodeName attrName(TokenLookupClass::toToken(attr.name()));
+ encounteredXSLTAtts.insert(attrName);
+
+ if(!desc.requiredAttributes.contains(attrName) &&
+ !desc.optionalAttributes.contains(attrName) &&
+ !m_standardAttributes.contains(attrName) &&
+ !isAnyAttributeAllowed())
+ {
+ QString translationString;
+
+ QList<typename TokenLookupClass::NodeName> all(desc.requiredAttributes.toList() + desc.optionalAttributes.toList());
+ const int totalCount = all.count();
+ QStringList allowed;
+
+ for(int i = 0; i < totalCount; ++i)
+ allowed.append(formatKeyword(toString(all.at(i))));
+
+ /* Note, we can't run toString() on attrName, because we're in this branch,
+ * the token lookup doesn't have the string(!).*/
+ const QString stringedName(attr.name().toString());
+
+ if(totalCount == 0)
+ {
+ translationString = QtXmlPatterns::tr("Attribute %1 cannot appear on the element %2. Only the standard attributes can appear.")
+ .arg(formatKeyword(stringedName),
+ formatKeyword(name()));
+ }
+ else if(totalCount == 1)
+ {
+ translationString = QtXmlPatterns::tr("Attribute %1 cannot appear on the element %2. Only %3 is allowed, and the standard attributes.")
+ .arg(formatKeyword(stringedName),
+ formatKeyword(name()),
+ allowed.first());
+ }
+ else if(totalCount == 1)
+ {
+ /* Note, allowed has already had formatKeyword() applied. */
+ translationString = QtXmlPatterns::tr("Attribute %1 cannot appear on the element %2. Allowed is %3, %4, and the standard attributes.")
+ .arg(formatKeyword(stringedName),
+ formatKeyword(name()),
+ allowed.first(),
+ allowed.last());
+ }
+ else
+ {
+ /* Note, allowed has already had formatKeyword() applied. */
+ translationString = QtXmlPatterns::tr("Attribute %1 cannot appear on the element %2. Allowed is %3, and the standard attributes.")
+ .arg(formatKeyword(stringedName),
+ formatKeyword(name()),
+ allowed.join(QLatin1String(", ")));
+ }
+
+ m_context->error(translationString,
+ ReportContext::XTSE0090,
+ currentLocation());
+ }
+ }
+ else if(attr.namespaceUri() == namespaceUri())
+ {
+ m_context->error(QtXmlPatterns::tr("XSL-T attributes on XSL-T elements must be in the null namespace, not in the XSL-T namespace which %1 is.")
+ .arg(formatKeyword(attr.name())),
+ ReportContext::XTSE0090,
+ currentLocation());
+ }
+ /* Else, attributes in other namespaces are allowed, continue. */
+ }
+
+ const QSet<typename TokenLookupClass::NodeName> requiredButMissing(QSet<typename TokenLookupClass::NodeName>(desc.requiredAttributes).subtract(encounteredXSLTAtts));
+
+ if(!requiredButMissing.isEmpty())
+ {
+ error(QtXmlPatterns::tr("The attribute %1 must appear on element %2.")
+ .arg(formatKeyword(toString(*requiredButMissing.constBegin())),
+ formatKeyword(name())),
+ ReportContext::XTSE0010);
+ }
+ }
+ else
+ {
+ error(QtXmlPatterns::tr("The element with local name %1 does not exist in XSL-T.").arg(formatKeyword(name())),
+ ReportContext::XTSE0010);
+ }
+}
+
+template<typename TokenLookupClass,
+ typename LookupKey>
+bool MaintainingReader<TokenLookupClass, LookupKey>::hasAttribute(const QString &namespaceURI,
+ const QString &localName) const
+{
+ Q_ASSERT(tokenType() == QXmlStreamReader::StartElement);
+ return m_currentAttributes.hasAttribute(namespaceURI, localName);
+}
+
+template<typename TokenLookupClass,
+ typename LookupKey>
+bool MaintainingReader<TokenLookupClass, LookupKey>::hasAttribute(const QString &localName) const
+{
+ return hasAttribute(QString(), localName);
+}
+
+template<typename TokenLookupClass,
+ typename LookupKey>
+QString MaintainingReader<TokenLookupClass, LookupKey>::readAttribute(const QString &localName,
+ const QString &namespaceURI) const
+{
+ Q_ASSERT(tokenType() == QXmlStreamReader::StartElement);
+
+ Q_ASSERT_X(m_currentAttributes.hasAttribute(namespaceURI, localName),
+ Q_FUNC_INFO,
+ "Validation must be done before this function is called.");
+
+ return m_currentAttributes.value(namespaceURI, localName).toString();
+}
+
diff --git a/src/xmlpatterns/parser/qmaintainingreader_p.h b/src/xmlpatterns/parser/qmaintainingreader_p.h
new file mode 100644
index 0000000000..2fab61fc3b
--- /dev/null
+++ b/src/xmlpatterns/parser/qmaintainingreader_p.h
@@ -0,0 +1,233 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@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.
+
+#ifndef Patternist_MaintainingReader_H
+#define Patternist_MaintainingReader_H
+
+#include <QSet>
+#include <QSourceLocation>
+#include <QStack>
+#include <QStringList>
+#include <QXmlStreamReader>
+
+#include "qxpathhelper_p.h"
+
+class QUrl;
+
+QT_BEGIN_HEADER
+QT_BEGIN_NAMESPACE
+
+namespace QPatternist
+{
+ /**
+ * @short A structure that lists the optional and required
+ * attributes of an element. Used with MaintainingReader.
+ *
+ * A constant source to misunderstandings is mixing up the order of
+ * arguments for functions that takes a local name and a namespace. Be wary
+ * of this.
+ *
+ * @author Frans Englich <fenglich@trolltech.com>
+ * @since 4.5
+ */
+ template<typename TokenLookupClass,
+ typename LookupKey = typename TokenLookupClass::NodeName>
+ class ElementDescription
+ {
+ public:
+ typedef QHash<LookupKey, ElementDescription<TokenLookupClass, LookupKey> > Hash;
+ QSet<typename TokenLookupClass::NodeName> requiredAttributes;
+ QSet<typename TokenLookupClass::NodeName> optionalAttributes;
+ };
+
+ /**
+ * @short Base class for tokenizers that reads XML formats. This is
+ * XSLTTokenizer, and the W3C XML Schema parser.
+ *
+ * MaintainingReader is intended for sub-classing.
+ *
+ * @tparam TokenLookupClass The name of the class that is generated by
+ * QTokenAutomaton and which supplies tokenizing tokens. For XSLTTokenizer,
+ * this is XSLTTokenLookup, for instance.
+ *
+ * @tparam LookupKey The type that is passed to validateElement() and is
+ * the key in ElementDescription. For the schema code, where elements have
+ * different interpretations depending on context, the lookup key is hence
+ * not equal element name.
+ *
+ * @author Frans Englich <fenglich@trolltech.com>
+ * @since 4.5
+ */
+ template<typename TokenLookupClass,
+ typename LookupKey = typename TokenLookupClass::NodeName>
+ class MaintainingReader : public QXmlStreamReader
+ , protected TokenLookupClass
+ {
+ protected:
+
+ MaintainingReader(const typename ElementDescription<TokenLookupClass, LookupKey>::Hash &elementDescriptions,
+ const QSet<typename TokenLookupClass::NodeName> &standardAttributes,
+ const ReportContext::Ptr &context,
+ QIODevice *const queryDevice);
+
+ virtual ~MaintainingReader();
+
+ TokenType readNext();
+
+ /**
+ * Returns the name of the current element.
+ */
+ inline typename TokenLookupClass::NodeName currentElementName() const;
+
+ /**
+ * @short Convenience function for calling ReportContext::error().
+ */
+ void error(const QString &message,
+ const ReportContext::ErrorCode code) const;
+
+ /**
+ * @short Convenience function for calling ReportContext::warning().
+ */
+ void warning(const QString &message) const;
+
+ /**
+ * @short Returns the location of the document that MaintainingReader
+ * is parsing. Used for error reporting
+ */
+ virtual QUrl documentURI() const = 0;
+
+ /**
+ * @short Returns @c true, if any attribute is allowed on the
+ * element currently being validated.
+ */
+ virtual bool isAnyAttributeAllowed() const = 0;
+
+ /**
+ * QXmlStreamReader::isWhitespace() returns true for whitespace that is
+ * not expressed as character references, while XSL-T operatates ontop
+ * of the XDM, which means we needs to return true for those too.
+ *
+ * @see <a href="http://www.w3.org/TR/xslt20/#data-model">4 Data Model</a>
+ */
+ bool isWhitespace() const;
+
+ /**
+ * This function is not merged with handleStandardAttributes() because
+ * handleStandardAttributes() needs to be called for all elements,
+ * while validateElement() only applies to XSL-T elements.
+ *
+ * @see handleStandardAttributes()
+ */
+ void validateElement(const LookupKey name) const;
+
+ QXmlStreamAttributes m_currentAttributes;
+
+ bool m_hasHandledStandardAttributes;
+
+ /**
+ * This stack mirrors the depth of elements in the parsed document. If
+ * no @c xml:space is present on the current element, MaintainingReader
+ * simply pushes the current top(). However, it never sets the value
+ * depending on @c xml:space's value.
+ */
+ QStack<bool> m_stripWhitespace;
+
+ /**
+ * @short Returns the value for attribute by name \a name.
+ *
+ * If it doesn't exist, an error is raised.
+ *
+ * It is assumed that m_reader's current state is
+ * QXmlStreamReader::StartElement.
+ */
+ QString readAttribute(const QString &localName,
+ const QString &namespaceURI = QString()) const;
+
+ /**
+ * @short Returns @c true if the current element has an attribute whose
+ * name is @p namespaceURI and local name is @p localName.
+ */
+ bool hasAttribute(const QString &namespaceURI, const QString &localName) const;
+
+ /**
+ * @short Returns @c true if the current element has an attribute whose
+ * local name is @p localName and namespace URI is null.
+ */
+ inline bool hasAttribute(const QString &localName) const;
+
+ private:
+ typename TokenLookupClass::NodeName m_currentElementName;
+
+ /**
+ * This member is private, see the error() and warning() functions in
+ * this class.
+ */
+ const ReportContext::Ptr m_context;
+
+ /**
+ * Returns the current location that QXmlStreamReader has.
+ */
+ inline QSourceLocation currentLocation() const;
+
+ const typename ElementDescription<TokenLookupClass, LookupKey>::Hash m_elementDescriptions;
+ const QSet<typename TokenLookupClass::NodeName> m_standardAttributes;
+ Q_DISABLE_COPY(MaintainingReader)
+ };
+
+#include "qmaintainingreader.cpp"
+
+}
+
+QT_END_NAMESPACE
+QT_END_HEADER
+
+#endif
+
diff --git a/src/xmlpatterns/parser/qparsercontext.cpp b/src/xmlpatterns/parser/qparsercontext.cpp
new file mode 100644
index 0000000000..7c48deec7f
--- /dev/null
+++ b/src/xmlpatterns/parser/qparsercontext.cpp
@@ -0,0 +1,100 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtGlobal>
+
+#include "qexpression_p.h"
+#include "qstaticcontext_p.h"
+#include "qtokenizer_p.h"
+
+#include "qparsercontext_p.h"
+
+QT_BEGIN_NAMESPACE
+
+using namespace QPatternist;
+
+ParserContext::ParserContext(const StaticContext::Ptr &context,
+ const QXmlQuery::QueryLanguage lang,
+ Tokenizer *const tokener) : staticContext(context)
+ , tokenizer(tokener)
+ , languageAccent(lang)
+ , nodeTestSource(BuiltinTypes::element)
+ , moduleNamespace(StandardNamespaces::empty)
+ , isPreviousEnclosedExpr(false)
+ , elementConstructorDepth(0)
+ , hasSecondPrologPart(false)
+ , preserveNamespacesMode(true)
+ , inheritNamespacesMode(true)
+ , isParsingPattern(false)
+ , currentImportPrecedence(1)
+ , m_evaluationCacheSlot(-1)
+ , m_expressionSlot(0)
+ , m_positionSlot(-1)
+ , m_globalVariableSlot(-1)
+ , m_currentTemplateID(InitialTemplateID)
+{
+ resolvers.push(context->namespaceBindings());
+ Q_ASSERT(tokenizer);
+ Q_ASSERT(context);
+ m_isParsingWithParam.push(false);
+ isBackwardsCompat.push(false);
+}
+
+void ParserContext::finalizePushedVariable(const int amount,
+ const bool shouldPop)
+{
+ for(int i = 0; i < amount; ++i)
+ {
+ const VariableDeclaration::Ptr var(shouldPop ? variables.pop() : variables.top());
+ Q_ASSERT(var);
+
+ if(var->isUsed())
+ continue;
+ else
+ {
+ staticContext->warning(QtXmlPatterns::tr("The variable %1 is unused")
+ .arg(formatKeyword(var, staticContext->namePool())));
+ }
+ }
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/xmlpatterns/parser/qparsercontext_p.h b/src/xmlpatterns/parser/qparsercontext_p.h
new file mode 100644
index 0000000000..941b6d3ed9
--- /dev/null
+++ b/src/xmlpatterns/parser/qparsercontext_p.h
@@ -0,0 +1,433 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@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.
+
+#ifndef Patternist_ParserContext_H
+#define Patternist_ParserContext_H
+
+#include <QFlags>
+#include <QSharedData>
+#include <QStack>
+#include <QStringList>
+#include <QtGlobal>
+#include <QXmlQuery>
+
+#include "qbuiltintypes_p.h"
+#include "qfunctionsignature_p.h"
+#include "qorderby_p.h"
+#include "qtemplatemode_p.h"
+#include "quserfunctioncallsite_p.h"
+#include "quserfunction_p.h"
+#include "qvariabledeclaration_p.h"
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+namespace QPatternist
+{
+ class Tokenizer;
+
+ /**
+ * @short Contains data used when parsing and tokenizing.
+ *
+ * When ExpressionFactory::create() is called, an instance of this class
+ * is passed to the scanner and parser. It holds all information that is
+ * needed to create the expression.
+ *
+ * @author Frans Englich <fenglich@trolltech.com>
+ */
+ class ParserContext : public QSharedData
+ {
+ public:
+ typedef QExplicitlySharedDataPointer<ParserContext> Ptr;
+
+ enum PrologDeclaration
+ {
+ BoundarySpaceDecl = 1,
+ DefaultCollationDecl = 2,
+ BaseURIDecl = 4,
+ ConstructionDecl = 8,
+ OrderingModeDecl = 16,
+ EmptyOrderDecl = 32,
+ CopyNamespacesDecl = 64,
+ DeclareDefaultElementNamespace = 128,
+ DeclareDefaultFunctionNamespace = 256
+ };
+
+ typedef QFlags<PrologDeclaration> PrologDeclarations;
+
+ /**
+ * Constructs a ParserContext instance.
+ *
+ * @param context the static context as defined in XPath. This contain
+ * namespace bindings, error handler, and other information necessary
+ * for creating an XPath expression.
+ * @param lang the particular XPath language sub-set that should be parsed
+ * @param tokenizer the Tokenizer to use.
+ * @see ExpressionFactory::LanguageAccent
+ */
+ ParserContext(const StaticContext::Ptr &context,
+ const QXmlQuery::QueryLanguage lang,
+ Tokenizer *const tokenizer);
+
+ /**
+ * @short Removes the recently pushed variables from
+ * scope. The amount of removed variables is @p amount.
+ *
+ * finalizePushedVariable() can be seen as popping the variable.
+ *
+ */
+ void finalizePushedVariable(const int amount = 1,
+ const bool shouldPop = true);
+
+ inline VariableSlotID allocatePositionalSlot()
+ {
+ ++m_positionSlot;
+ return m_positionSlot;
+ }
+
+ inline VariableSlotID allocateExpressionSlot()
+ {
+ const VariableSlotID retval = m_expressionSlot;
+ ++m_expressionSlot;
+ return retval;
+ }
+
+ inline VariableSlotID allocateGlobalVariableSlot()
+ {
+ ++m_globalVariableSlot;
+ return m_globalVariableSlot;
+ }
+
+ inline bool hasDeclaration(const PrologDeclaration decl) const
+ {
+ return m_prologDeclarations.testFlag(decl);
+ }
+
+ inline void registerDeclaration(const PrologDeclaration decl)
+ {
+ m_prologDeclarations |= decl;
+ }
+
+ /**
+ * The namespaces declared with <tt>declare namespace</tt>.
+ */
+ QStringList declaredPrefixes;
+
+ /**
+ * This is a temporary stack, used for keeping variables in scope,
+ * such as for function arguments & let clauses.
+ */
+ VariableDeclaration::Stack variables;
+
+ inline bool isXSLT() const
+ {
+ return languageAccent == QXmlQuery::XSLT20;
+ }
+
+ const StaticContext::Ptr staticContext;
+ /**
+ * We don't store a Tokenizer::Ptr here, because then we would get a
+ * circular referencing between ParserContext and XSLTTokenizer, and
+ * hence they would never destruct.
+ */
+ Tokenizer *const tokenizer;
+ const QXmlQuery::QueryLanguage languageAccent;
+
+ /**
+ * Only used in the case of XSL-T. Is the name of the initial template
+ * to call. If null, no name was provided, and regular template
+ * matching should be done.
+ */
+ QXmlName initialTemplateName;
+
+ /**
+ * Used when parsing direct element constructors. It is used
+ * for ensuring tags are well-balanced.
+ */
+ QStack<QXmlName> tagStack;
+
+ /**
+ * The actual expression, the Query. This member may be @c null,
+ * such as in the case of an XQuery library module.
+ */
+ Expression::Ptr queryBody;
+
+ /**
+ * The user functions declared in the prolog.
+ */
+ UserFunction::List userFunctions;
+
+ /**
+ * Contains all calls to user defined functions.
+ */
+ UserFunctionCallsite::List userFunctionCallsites;
+
+ /**
+ * All variables declared with <tt>declare variable</tt>.
+ */
+ VariableDeclaration::List declaredVariables;
+
+ inline VariableSlotID currentPositionSlot() const
+ {
+ return m_positionSlot;
+ }
+
+ inline VariableSlotID currentExpressionSlot() const
+ {
+ return m_expressionSlot;
+ }
+
+ inline void restoreNodeTestSource()
+ {
+ nodeTestSource = BuiltinTypes::element;
+ }
+
+ inline VariableSlotID allocateCacheSlot()
+ {
+ return ++m_evaluationCacheSlot;
+ }
+
+ inline VariableSlotID allocateCacheSlots(const int count)
+ {
+ const VariableSlotID retval = m_evaluationCacheSlot + 1;
+ m_evaluationCacheSlot += count + 1;
+ return retval;
+ }
+
+ ItemType::Ptr nodeTestSource;
+
+ QStack<Expression::Ptr> typeswitchSource;
+
+ /**
+ * The library module namespace set with <tt>declare module</tt>.
+ */
+ QXmlName::NamespaceCode moduleNamespace;
+
+ /**
+ * When a direct element constructor is processed, resolvers are
+ * created in order to carry the namespace declarations. In such case,
+ * the old resolver is pushed here.
+ */
+ QStack<NamespaceResolver::Ptr> resolvers;
+
+ /**
+ * This is used for handling the following obscene case:
+ *
+ * - <tt>\<e\>{1}{1}\<\/e\></tt> produce <tt>\<e\>11\</e\></tt>
+ * - <tt>\<e\>{1, 1}\<\/e\></tt> produce <tt>\<e\>1 1\</e\></tt>
+ *
+ * This boolean tracks whether the previous reduction inside element
+ * content was done with an enclosed expression.
+ */
+ bool isPreviousEnclosedExpr;
+
+ int elementConstructorDepth;
+
+ QStack<bool> scanOnlyStack;
+
+ QStack<OrderBy::Stability> orderStability;
+
+ /**
+ * Whether any prolog declaration that must occur after the first
+ * group has been encountered.
+ */
+ bool hasSecondPrologPart;
+
+ bool preserveNamespacesMode;
+ bool inheritNamespacesMode;
+
+ /**
+ * Contains all named templates. Since named templates
+ * can also have rules, each body may also be in templateRules.
+ */
+ QHash<QXmlName, Template::Ptr> namedTemplates;
+
+ /**
+ * All the @c xsl:call-template instructions that we have encountered.
+ */
+ QVector<Expression::Ptr> templateCalls;
+
+ /**
+ * If we're in XSL-T, and a variable reference is encountered
+ * which isn't in-scope, it's added to this hash since a global
+ * variable declaration may appear later on.
+ *
+ * We use a multi hash, since we can encounter several references to
+ * the same variable before it's declared.
+ */
+ QMultiHash<QXmlName, Expression::Ptr> unresolvedVariableReferences;
+
+ /**
+ *
+ * Contains the encountered template rules, as opposed
+ * to named templates.
+ *
+ * The key is the name of the template mode. If it's a default
+ * constructed value, it's the default mode.
+ *
+ * Since templates rules may also be named, each body may also be in
+ * namedTemplates.
+ *
+ * To be specific, the values are not the templates, the values are
+ * modes, and the TemplateMode contains the patterns and bodies.
+ */
+ QHash<QXmlName, TemplateMode::Ptr> templateRules;
+
+ /**
+ * @short Returns the TemplateMode for @p modeName or @c null if the
+ * mode being asked for is @c #current.
+ */
+ TemplateMode::Ptr modeFor(const QXmlName &modeName)
+ {
+ /* #current is not a mode, so it cannot contain templates. #current
+ * specifies how to look up templates wrt. mode. This check helps
+ * code that calls us, asking for the mode it needs to lookup in.
+ */
+ if(modeName == QXmlName(StandardNamespaces::InternalXSLT, StandardLocalNames::current))
+ return TemplateMode::Ptr();
+
+ TemplateMode::Ptr &mode = templateRules[modeName];
+
+ if(!mode)
+ mode = TemplateMode::Ptr(new TemplateMode(modeName));
+
+ Q_ASSERT(templateRules[modeName]);
+ return mode;
+ }
+
+ inline TemplatePattern::ID allocateTemplateID()
+ {
+ ++m_currentTemplateID;
+ return m_currentTemplateID;
+ }
+
+ /**
+ * The @c xsl:param appearing inside template.
+ */
+ VariableDeclaration::List templateParameters;
+
+ /**
+ * The @c xsl:with-param appearing in template calling instruction.
+ */
+ WithParam::Hash templateWithParams;
+
+ inline void templateParametersHandled()
+ {
+ finalizePushedVariable(templateParameters.count());
+ templateParameters.clear();
+ }
+
+ inline void templateWithParametersHandled()
+ {
+ templateWithParams.clear();
+ }
+
+ inline bool isParsingWithParam() const
+ {
+ return m_isParsingWithParam.top();
+ }
+
+ void startParsingWithParam()
+ {
+ m_isParsingWithParam.push(true);
+ }
+
+ void endParsingWithParam()
+ {
+ m_isParsingWithParam.pop();
+ }
+
+ /**
+ * This is used to deal with XSL-T's exception to the @c node() type,
+ * which doesn't match document nodes.
+ */
+ bool isParsingPattern;
+
+ ImportPrecedence currentImportPrecedence;
+
+ bool isFirstTemplate() const
+ {
+ return m_currentTemplateID == InitialTemplateID;
+ }
+
+ /**
+ * Whether we're processing XSL-T 1.0 code.
+ */
+ QStack<bool> isBackwardsCompat;
+
+ private:
+ enum
+ {
+ InitialTemplateID = -1
+ };
+
+ VariableSlotID m_evaluationCacheSlot;
+ VariableSlotID m_expressionSlot;
+ VariableSlotID m_positionSlot;
+ PrologDeclarations m_prologDeclarations;
+ VariableSlotID m_globalVariableSlot;
+ TemplatePattern::ID m_currentTemplateID;
+
+ /**
+ * The default is @c false. If we're not parsing @c xsl:with-param,
+ * hence parsing @c xsl:param, the value has changed.
+ */
+ QStack<bool> m_isParsingWithParam;
+ Q_DISABLE_COPY(ParserContext)
+ };
+}
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/xmlpatterns/parser/qquerytransformparser.cpp b/src/xmlpatterns/parser/qquerytransformparser.cpp
new file mode 100644
index 0000000000..60e3a0ccdf
--- /dev/null
+++ b/src/xmlpatterns/parser/qquerytransformparser.cpp
@@ -0,0 +1,7976 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@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.
+
+/* A Bison parser, made by GNU Bison 2.3a. */
+
+/* Skeleton implementation for Bison's Yacc-like parsers in C
+
+ Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+ Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA. */
+
+/* As a special exception, you may create a larger work that contains
+ part or all of the Bison parser skeleton and distribute that work
+ under terms of your choice, so long as that work isn't itself a
+ parser generator using the skeleton or a modified version thereof
+ as a parser skeleton. Alternatively, if you modify or redistribute
+ the parser skeleton itself, you may (at your option) remove this
+ special exception, which will cause the skeleton and the resulting
+ Bison output files to be licensed under the GNU General Public
+ License without this special exception.
+
+ This special exception was added by the Free Software Foundation in
+ version 2.2 of Bison. */
+
+/* C LALR(1) parser skeleton written by Richard Stallman, by
+ simplifying the original so-called "semantic" parser. */
+
+/* All symbols defined below should begin with yy or YY, to avoid
+ infringing on user name space. This should be done even for local
+ variables, as they might otherwise be expanded by user macros.
+ There are some unavoidable exceptions within include files to
+ define necessary library symbols; they are noted "INFRINGES ON
+ USER NAME SPACE" below. */
+
+/* Identify Bison output. */
+#define YYBISON 1
+
+/* Bison version. */
+#define YYBISON_VERSION "2.3a"
+
+/* Skeleton name. */
+#define YYSKELETON_NAME "yacc.c"
+
+/* Pure parsers. */
+#define YYPURE 1
+
+/* Using locations. */
+#define YYLSP_NEEDED 1
+
+/* Substitute the variable and function names. */
+#define yyparse XPathparse
+#define yylex XPathlex
+#define yyerror XPatherror
+#define yylval XPathlval
+#define yychar XPathchar
+#define yydebug XPathdebug
+#define yynerrs XPathnerrs
+#define yylloc XPathlloc
+
+/* Copy the first part of user declarations. */
+/* Line 164 of yacc.c. */
+#line 22 "querytransformparser.ypp"
+
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@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);
+}
+
+/**
+ * @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, 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 which is
+ * unavailable in XPath.
+ *
+ * If @p isInternal is @c true, no error is raised. Otherwise, if the current
+ * language is not XQuery, an error is raised.
+ */
+static void disallowedConstruct(const ParserContext *const parseInfo,
+ const YYLTYPE &sourceLocator,
+ const bool isInternal = false)
+{
+ if(!isInternal && parseInfo->languageAccent != QXmlQuery::XQuery10)
+ {
+ parseInfo->staticContext->error(QtXmlPatterns::tr("A construct was encountered which only is allowed in XQuery."),
+ 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 by 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);
+}
+
+
+
+/* Enabling traces. */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+
+/* Enabling verbose error messages. */
+#ifdef YYERROR_VERBOSE
+# undef YYERROR_VERBOSE
+# define YYERROR_VERBOSE 1
+#else
+# define YYERROR_VERBOSE 1
+#endif
+
+/* Enabling the token table. */
+#ifndef YYTOKEN_TABLE
+# define YYTOKEN_TABLE 0
+#endif
+
+
+/* Tokens. */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+ /* Put the tokens into the symbol table, so that GDB and other debuggers
+ know about them. */
+ enum yytokentype {
+ END_OF_FILE = 0,
+ STRING_LITERAL = 258,
+ NON_BOUNDARY_WS = 259,
+ XPATH2_STRING_LITERAL = 260,
+ QNAME = 261,
+ NCNAME = 262,
+ CLARK_NAME = 263,
+ ANY_LOCAL_NAME = 264,
+ ANY_PREFIX = 265,
+ NUMBER = 266,
+ XPATH2_NUMBER = 267,
+ ANCESTOR = 268,
+ ANCESTOR_OR_SELF = 269,
+ AND = 270,
+ APOS = 271,
+ APPLY_TEMPLATE = 272,
+ AS = 273,
+ ASCENDING = 274,
+ ASSIGN = 275,
+ AT = 276,
+ AT_SIGN = 277,
+ ATTRIBUTE = 278,
+ AVT = 279,
+ BAR = 280,
+ BASEURI = 281,
+ BEGIN_END_TAG = 282,
+ BOUNDARY_SPACE = 283,
+ BY = 284,
+ CALL_TEMPLATE = 285,
+ CASE = 286,
+ CASTABLE = 287,
+ CAST = 288,
+ CHILD = 289,
+ COLLATION = 290,
+ COLONCOLON = 291,
+ COMMA = 292,
+ COMMENT = 293,
+ COMMENT_START = 294,
+ CONSTRUCTION = 295,
+ COPY_NAMESPACES = 296,
+ CURLY_LBRACE = 297,
+ CURLY_RBRACE = 298,
+ DECLARE = 299,
+ DEFAULT = 300,
+ DESCENDANT = 301,
+ DESCENDANT_OR_SELF = 302,
+ DESCENDING = 303,
+ DIV = 304,
+ DOCUMENT = 305,
+ DOCUMENT_NODE = 306,
+ DOLLAR = 307,
+ DOT = 308,
+ DOTDOT = 309,
+ ELEMENT = 310,
+ ELSE = 311,
+ EMPTY = 312,
+ EMPTY_SEQUENCE = 313,
+ ENCODING = 314,
+ END_SORT = 315,
+ EQ = 316,
+ ERROR = 317,
+ EVERY = 318,
+ EXCEPT = 319,
+ EXTERNAL = 320,
+ FOLLOWING = 321,
+ FOLLOWING_SIBLING = 322,
+ FOLLOWS = 323,
+ FOR_APPLY_TEMPLATE = 324,
+ FOR = 325,
+ FUNCTION = 326,
+ GE = 327,
+ G_EQ = 328,
+ G_GE = 329,
+ G_GT = 330,
+ G_LE = 331,
+ G_LT = 332,
+ G_NE = 333,
+ GREATEST = 334,
+ GT = 335,
+ IDIV = 336,
+ IF = 337,
+ IMPORT = 338,
+ INHERIT = 339,
+ IN = 340,
+ INSTANCE = 341,
+ INTERSECT = 342,
+ IS = 343,
+ ITEM = 344,
+ LAX = 345,
+ LBRACKET = 346,
+ LEAST = 347,
+ LE = 348,
+ LET = 349,
+ LPAREN = 350,
+ LT = 351,
+ MAP = 352,
+ MATCHES = 353,
+ MINUS = 354,
+ MODE = 355,
+ MOD = 356,
+ MODULE = 357,
+ NAME = 358,
+ NAMESPACE = 359,
+ NE = 360,
+ NODE = 361,
+ NO_INHERIT = 362,
+ NO_PRESERVE = 363,
+ OF = 364,
+ OPTION = 365,
+ ORDERED = 366,
+ ORDERING = 367,
+ ORDER = 368,
+ OR = 369,
+ PARENT = 370,
+ PI_START = 371,
+ PLUS = 372,
+ POSITION_SET = 373,
+ PRAGMA_END = 374,
+ PRAGMA_START = 375,
+ PRECEDES = 376,
+ PRECEDING = 377,
+ PRECEDING_SIBLING = 378,
+ PRESERVE = 379,
+ PRIORITY = 380,
+ PROCESSING_INSTRUCTION = 381,
+ QUESTION = 382,
+ QUICK_TAG_END = 383,
+ QUOTE = 384,
+ RBRACKET = 385,
+ RETURN = 386,
+ RPAREN = 387,
+ SATISFIES = 388,
+ SCHEMA_ATTRIBUTE = 389,
+ SCHEMA_ELEMENT = 390,
+ SCHEMA = 391,
+ SELF = 392,
+ SEMI_COLON = 393,
+ SLASH = 394,
+ SLASHSLASH = 395,
+ SOME = 396,
+ SORT = 397,
+ STABLE = 398,
+ STAR = 399,
+ STRICT = 400,
+ STRIP = 401,
+ SUCCESS = 402,
+ COMMENT_CONTENT = 403,
+ PI_CONTENT = 404,
+ PI_TARGET = 405,
+ XSLT_VERSION = 406,
+ TEMPLATE = 407,
+ TEXT = 408,
+ THEN = 409,
+ TO = 410,
+ TREAT = 411,
+ TUNNEL = 412,
+ TYPESWITCH = 413,
+ UNION = 414,
+ UNORDERED = 415,
+ VALIDATE = 416,
+ VARIABLE = 417,
+ VERSION = 418,
+ WHERE = 419,
+ XQUERY = 420,
+ INTERNAL = 421,
+ INTERNAL_NAME = 422,
+ CURRENT = 423
+ };
+#endif
+
+
+
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+
+# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+# define YYSTYPE_IS_DECLARED 1
+#endif
+
+#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
+typedef struct YYLTYPE
+{
+ int first_line;
+ int first_column;
+ int last_line;
+ int last_column;
+} YYLTYPE;
+# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
+# define YYLTYPE_IS_DECLARED 1
+# define YYLTYPE_IS_TRIVIAL 1
+#endif
+
+
+/* Copy the second part of user declarations. */
+
+/* Line 221 of yacc.c. */
+#line 1289 "qquerytransformparser.cpp"
+
+#ifdef short
+# undef short
+#endif
+
+#ifdef YYTYPE_UINT8
+typedef YYTYPE_UINT8 yytype_uint8;
+#else
+typedef unsigned char yytype_uint8;
+#endif
+
+#ifdef YYTYPE_INT8
+typedef YYTYPE_INT8 yytype_int8;
+#elif (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+typedef signed char yytype_int8;
+#else
+typedef short int yytype_int8;
+#endif
+
+#ifdef YYTYPE_UINT16
+typedef YYTYPE_UINT16 yytype_uint16;
+#else
+typedef unsigned short int yytype_uint16;
+#endif
+
+#ifdef YYTYPE_INT16
+typedef YYTYPE_INT16 yytype_int16;
+#else
+typedef short int yytype_int16;
+#endif
+
+#ifndef YYSIZE_T
+# ifdef __SIZE_TYPE__
+# define YYSIZE_T __SIZE_TYPE__
+# elif defined size_t
+# define YYSIZE_T size_t
+# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+# define YYSIZE_T size_t
+# else
+# define YYSIZE_T unsigned int
+# endif
+#endif
+
+#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
+
+#ifndef YY_
+# if YYENABLE_NLS
+# if ENABLE_NLS
+# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
+# define YY_(msgid) dgettext ("bison-runtime", msgid)
+# endif
+# endif
+# ifndef YY_
+# define YY_(msgid) msgid
+# endif
+#endif
+
+/* Suppress unused-variable warnings by "using" E. */
+#if ! defined lint || defined __GNUC__
+# define YYUSE(e) ((void) (e))
+#else
+# define YYUSE(e) /* empty */
+#endif
+
+/* Identity function, used to suppress warnings about constant conditions. */
+#ifndef lint
+# define YYID(n) (n)
+#else
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+static int
+YYID (int yyi)
+#else
+static int
+YYID (yyi)
+ int yyi;
+#endif
+{
+ return yyi;
+}
+#endif
+
+#if ! defined yyoverflow || YYERROR_VERBOSE
+
+/* The parser invokes alloca or malloc; define the necessary symbols. */
+
+# ifdef YYSTACK_USE_ALLOCA
+# if YYSTACK_USE_ALLOCA
+# ifdef __GNUC__
+# define YYSTACK_ALLOC __builtin_alloca
+# elif defined __BUILTIN_VA_ARG_INCR
+# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
+# elif defined _AIX
+# define YYSTACK_ALLOC __alloca
+# elif defined _MSC_VER
+# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
+# define alloca _alloca
+# else
+# define YYSTACK_ALLOC alloca
+# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+# ifndef _STDLIB_H
+# define _STDLIB_H 1
+# endif
+# endif
+# endif
+# endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+ /* Pacify GCC's `empty if-body' warning. */
+# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
+# ifndef YYSTACK_ALLOC_MAXIMUM
+ /* The OS might guarantee only one guard page at the bottom of the stack,
+ and a page size can be as small as 4096 bytes. So we cannot safely
+ invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
+ to allow for a few compiler-allocated temporary stack slots. */
+# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
+# endif
+# else
+# define YYSTACK_ALLOC YYMALLOC
+# define YYSTACK_FREE YYFREE
+# ifndef YYSTACK_ALLOC_MAXIMUM
+# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
+# endif
+# if (defined __cplusplus && ! defined _STDLIB_H \
+ && ! ((defined YYMALLOC || defined malloc) \
+ && (defined YYFREE || defined free)))
+# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+# ifndef _STDLIB_H
+# define _STDLIB_H 1
+# endif
+# endif
+# ifndef YYMALLOC
+# define YYMALLOC malloc
+# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+# endif
+# endif
+# ifndef YYFREE
+# define YYFREE free
+# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+# endif
+# endif
+# endif
+#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
+
+
+#if (! defined yyoverflow \
+ && (! defined __cplusplus \
+ || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
+ && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+
+/* A type that is properly aligned for any stack member. */
+union yyalloc
+{
+ yytype_int16 yyss;
+ YYSTYPE yyvs;
+ YYLTYPE yyls;
+};
+
+/* The size of the maximum gap between one aligned stack and the next. */
+# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
+
+/* The size of an array large to enough to hold all stacks, each with
+ N elements. */
+# define YYSTACK_BYTES(N) \
+ ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
+ + 2 * YYSTACK_GAP_MAXIMUM)
+
+/* Copy COUNT objects from FROM to TO. The source and destination do
+ not overlap. */
+# ifndef YYCOPY
+# if defined __GNUC__ && 1 < __GNUC__
+# define YYCOPY(To, From, Count) \
+ __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
+# else
+# define YYCOPY(To, From, Count) \
+ do \
+ { \
+ YYSIZE_T yyi; \
+ for (yyi = 0; yyi < (Count); yyi++) \
+ (To)[yyi] = (From)[yyi]; \
+ } \
+ while (YYID (0))
+# endif
+# endif
+
+/* Relocate STACK from its old location to the new one. The
+ local variables YYSIZE and YYSTACKSIZE give the old and new number of
+ elements in the stack, and YYPTR gives the new location of the
+ stack. Advance YYPTR to a properly aligned location for the next
+ stack. */
+# define YYSTACK_RELOCATE(Stack) \
+ do \
+ { \
+ YYSIZE_T yynewbytes; \
+ YYCOPY (&yyptr->Stack, Stack, yysize); \
+ Stack = &yyptr->Stack; \
+ yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
+ yyptr += yynewbytes / sizeof (*yyptr); \
+ } \
+ while (YYID (0))
+
+#endif
+
+/* YYFINAL -- State number of the termination state. */
+#define YYFINAL 5
+/* YYLAST -- Last index in YYTABLE. */
+#define YYLAST 2052
+
+/* YYNTOKENS -- Number of terminals. */
+#define YYNTOKENS 169
+/* YYNNTS -- Number of nonterminals. */
+#define YYNNTS 237
+/* YYNRULES -- Number of rules. */
+#define YYNRULES 472
+/* YYNRULES -- Number of states. */
+#define YYNSTATES 812
+
+/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
+#define YYUNDEFTOK 2
+#define YYMAXUTOK 423
+
+#define YYTRANSLATE(YYX) \
+ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+
+/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
+static const yytype_uint8 yytranslate[] =
+{
+ 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
+ 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+ 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
+ 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
+ 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
+ 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
+ 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
+ 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
+ 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
+ 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
+ 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
+ 115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
+ 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
+ 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
+ 145, 146, 147, 148, 149, 150, 151, 152, 153, 154,
+ 155, 156, 157, 158, 159, 160, 161, 162, 163, 164,
+ 165, 166, 167, 168
+};
+
+#if YYDEBUG
+/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
+ YYRHS. */
+static const yytype_uint16 yyprhs[] =
+{
+ 0, 0, 3, 6, 9, 10, 16, 17, 20, 23,
+ 26, 33, 34, 37, 40, 43, 46, 49, 52, 55,
+ 58, 66, 67, 68, 84, 85, 88, 89, 91, 94,
+ 96, 98, 100, 102, 104, 106, 108, 110, 112, 114,
+ 122, 127, 129, 131, 133, 135, 142, 149, 155, 160,
+ 162, 164, 170, 173, 176, 183, 185, 187, 189, 191,
+ 197, 203, 210, 211, 215, 219, 226, 227, 231, 232,
+ 235, 237, 241, 251, 253, 256, 257, 260, 265, 267,
+ 269, 270, 282, 283, 285, 289, 293, 295, 297, 301,
+ 303, 305, 309, 311, 313, 316, 319, 321, 325, 329,
+ 331, 333, 337, 341, 343, 345, 347, 351, 355, 357,
+ 359, 361, 363, 365, 370, 371, 374, 375, 378, 380,
+ 384, 386, 388, 390, 392, 393, 394, 405, 406, 407,
+ 418, 420, 422, 424, 425, 429, 430, 440, 441, 450,
+ 452, 454, 456, 460, 466, 467, 469, 472, 476, 478,
+ 483, 484, 486, 488, 489, 491, 492, 495, 499, 503,
+ 506, 508, 510, 511, 512, 522, 523, 524, 534, 536,
+ 537, 538, 548, 549, 550, 560, 562, 565, 566, 573,
+ 574, 575, 584, 586, 588, 589, 593, 597, 598, 605,
+ 614, 616, 620, 622, 626, 628, 630, 632, 634, 636,
+ 640, 642, 646, 648, 650, 652, 656, 658, 660, 662,
+ 664, 666, 670, 672, 676, 678, 680, 682, 684, 686,
+ 691, 693, 698, 700, 705, 707, 712, 714, 717, 719,
+ 721, 723, 725, 727, 731, 733, 735, 737, 739, 741,
+ 743, 747, 749, 751, 753, 755, 757, 759, 763, 765,
+ 767, 769, 772, 774, 777, 780, 783, 786, 790, 793,
+ 795, 800, 801, 803, 806, 809, 811, 813, 815, 819,
+ 827, 831, 833, 835, 838, 839, 843, 849, 850, 860,
+ 866, 867, 870, 871, 873, 877, 878, 882, 888, 889,
+ 891, 892, 895, 897, 899, 901, 903, 908, 910, 912,
+ 913, 917, 919, 921, 923, 926, 928, 930, 932, 934,
+ 936, 938, 940, 942, 944, 946, 948, 950, 951, 955,
+ 957, 959, 961, 963, 965, 967, 969, 971, 973, 975,
+ 977, 979, 984, 986, 988, 990, 992, 994, 996, 998,
+ 1004, 1006, 1008, 1010, 1012, 1015, 1017, 1019, 1023, 1026,
+ 1028, 1031, 1036, 1037, 1039, 1041, 1043, 1045, 1047, 1049,
+ 1051, 1052, 1053, 1062, 1064, 1070, 1071, 1074, 1078, 1082,
+ 1086, 1087, 1090, 1093, 1094, 1097, 1100, 1103, 1106, 1109,
+ 1113, 1115, 1117, 1119, 1121, 1123, 1125, 1127, 1131, 1132,
+ 1138, 1139, 1141, 1146, 1150, 1154, 1158, 1159, 1160, 1164,
+ 1166, 1168, 1170, 1172, 1174, 1176, 1180, 1182, 1185, 1186,
+ 1189, 1192, 1195, 1196, 1198, 1200, 1202, 1204, 1206, 1208,
+ 1211, 1213, 1215, 1217, 1219, 1221, 1223, 1225, 1227, 1230,
+ 1233, 1238, 1240, 1242, 1245, 1248, 1251, 1256, 1261, 1263,
+ 1265, 1268, 1273, 1278, 1285, 1292, 1297, 1300, 1305, 1310,
+ 1318, 1326, 1327, 1329, 1334, 1337, 1339, 1341, 1343, 1345,
+ 1347, 1349, 1351, 1353, 1356, 1358, 1360, 1362, 1364, 1366,
+ 1368, 1370, 1372
+};
+
+/* YYRHS -- A `-1'-separated list of the rules' RHS. */
+static const yytype_int16 yyrhs[] =
+{
+ 170, 0, -1, 171, 174, -1, 171, 173, -1, -1,
+ 165, 163, 404, 172, 185, -1, -1, 59, 404, -1,
+ 176, 219, -1, 175, 176, -1, 102, 104, 7, 73,
+ 403, 185, -1, -1, 176, 189, -1, 176, 183, -1,
+ 176, 186, -1, 176, 184, -1, 176, 177, -1, 176,
+ 208, -1, 176, 213, -1, 176, 192, -1, 44, 152,
+ 182, 317, 377, 305, 185, -1, -1, -1, 44, 152,
+ 181, 98, 95, 178, 220, 179, 132, 228, 180, 317,
+ 377, 305, 185, -1, -1, 125, 404, -1, -1, 182,
+ -1, 103, 397, -1, 187, -1, 200, -1, 201, -1,
+ 211, -1, 193, -1, 195, -1, 197, -1, 202, -1,
+ 204, -1, 138, -1, 44, 104, 7, 73, 403, 364,
+ 185, -1, 44, 28, 188, 185, -1, 146, -1, 124,
+ -1, 190, -1, 191, -1, 44, 45, 55, 104, 403,
+ 185, -1, 44, 45, 71, 104, 403, 185, -1, 44,
+ 110, 397, 404, 185, -1, 44, 112, 194, 185, -1,
+ 111, -1, 160, -1, 44, 45, 113, 196, 185, -1,
+ 57, 92, -1, 57, 79, -1, 44, 41, 198, 37,
+ 199, 185, -1, 124, -1, 108, -1, 84, -1, 107,
+ -1, 44, 45, 35, 404, 185, -1, 44, 26, 364,
+ 403, 185, -1, 83, 136, 203, 403, 206, 185, -1,
+ -1, 45, 55, 104, -1, 104, 7, 73, -1, 83,
+ 102, 205, 403, 206, 185, -1, -1, 104, 7, 73,
+ -1, -1, 21, 207, -1, 403, -1, 207, 37, 403,
+ -1, 44, 162, 364, 52, 341, 377, 209, 210, 185,
+ -1, 65, -1, 20, 227, -1, -1, 20, 227, -1,
+ 44, 40, 212, 185, -1, 146, -1, 124, -1, -1,
+ 44, 71, 364, 399, 95, 215, 132, 214, 377, 217,
+ 185, -1, -1, 216, -1, 215, 37, 216, -1, 52,
+ 341, 377, -1, 65, -1, 218, -1, 42, 225, 43,
+ -1, 225, -1, 221, -1, 220, 25, 221, -1, 223,
+ -1, 139, -1, 139, 223, -1, 140, 223, -1, 222,
+ -1, 222, 139, 223, -1, 222, 140, 223, -1, 345,
+ -1, 224, -1, 223, 139, 224, -1, 223, 140, 224,
+ -1, 322, -1, 227, -1, 226, -1, 227, 37, 227,
+ -1, 226, 37, 227, -1, 277, -1, 232, -1, 253,
+ -1, 267, -1, 276, -1, 24, 95, 356, 132, -1,
+ -1, 100, 230, -1, -1, 100, 231, -1, 231, -1,
+ 230, 37, 231, -1, 405, -1, 7, -1, 233, -1,
+ 240, -1, -1, -1, 70, 52, 341, 377, 239, 85,
+ 227, 234, 235, 236, -1, -1, -1, 37, 52, 341,
+ 377, 239, 85, 227, 237, 238, 236, -1, 244, -1,
+ 233, -1, 240, -1, -1, 21, 52, 341, -1, -1,
+ 94, 364, 52, 341, 377, 20, 227, 241, 242, -1,
+ -1, 37, 52, 341, 377, 20, 227, 243, 242, -1,
+ 244, -1, 233, -1, 240, -1, 245, 131, 227, -1,
+ 164, 227, 245, 131, 227, -1, -1, 246, -1, 252,
+ 247, -1, 247, 37, 248, -1, 248, -1, 227, 249,
+ 250, 251, -1, -1, 19, -1, 48, -1, -1, 196,
+ -1, -1, 35, 403, -1, 166, 35, 227, -1, 143,
+ 113, 29, -1, 113, 29, -1, 254, -1, 260, -1,
+ -1, -1, 141, 52, 341, 377, 85, 227, 255, 256,
+ 257, -1, -1, -1, 37, 52, 341, 377, 85, 227,
+ 258, 259, 257, -1, 266, -1, -1, -1, 63, 52,
+ 341, 377, 85, 227, 261, 262, 263, -1, -1, -1,
+ 37, 52, 341, 377, 85, 227, 264, 265, 263, -1,
+ 266, -1, 133, 227, -1, -1, 158, 95, 225, 132,
+ 268, 269, -1, -1, -1, 31, 273, 378, 270, 131,
+ 227, 271, 272, -1, 269, -1, 274, -1, -1, 52,
+ 397, 18, -1, 45, 131, 227, -1, -1, 45, 52,
+ 397, 275, 131, 227, -1, 82, 95, 225, 132, 154,
+ 227, 56, 227, -1, 278, -1, 277, 114, 278, -1,
+ 279, -1, 278, 15, 279, -1, 280, -1, 298, -1,
+ 296, -1, 300, -1, 281, -1, 281, 155, 281, -1,
+ 283, -1, 281, 282, 283, -1, 117, -1, 99, -1,
+ 285, -1, 283, 284, 285, -1, 144, -1, 49, -1,
+ 81, -1, 101, -1, 286, -1, 285, 287, 286, -1,
+ 289, -1, 286, 288, 289, -1, 159, -1, 25, -1,
+ 87, -1, 64, -1, 290, -1, 290, 86, 109, 378,
+ -1, 291, -1, 291, 156, 18, 378, -1, 292, -1,
+ 292, 32, 18, 376, -1, 293, -1, 293, 33, 18,
+ 376, -1, 295, -1, 294, 293, -1, 117, -1, 99,
+ -1, 302, -1, 309, -1, 304, -1, 280, 297, 280,
+ -1, 73, -1, 78, -1, 74, -1, 75, -1, 76,
+ -1, 77, -1, 280, 299, 280, -1, 61, -1, 105,
+ -1, 72, -1, 80, -1, 93, -1, 96, -1, 280,
+ 301, 280, -1, 88, -1, 121, -1, 68, -1, 303,
+ 218, -1, 161, -1, 161, 145, -1, 161, 90, -1,
+ 306, 305, -1, 42, 43, -1, 42, 225, 43, -1,
+ 306, 307, -1, 307, -1, 120, 402, 308, 119, -1,
+ -1, 404, -1, 139, 310, -1, 140, 310, -1, 139,
+ -1, 310, -1, 311, -1, 310, 321, 311, -1, 310,
+ 321, 142, 246, 131, 311, 60, -1, 310, 140, 311,
+ -1, 322, -1, 336, -1, 168, 218, -1, -1, 151,
+ 312, 218, -1, 26, 404, 42, 225, 43, -1, -1,
+ 44, 104, 7, 73, 3, 42, 313, 225, 43, -1,
+ 30, 397, 95, 314, 132, -1, -1, 315, 316, -1,
+ -1, 318, -1, 316, 37, 318, -1, -1, 95, 316,
+ 132, -1, 319, 52, 341, 377, 320, -1, -1, 157,
+ -1, -1, 20, 227, -1, 139, -1, 97, -1, 69,
+ -1, 323, -1, 322, 91, 225, 130, -1, 324, -1,
+ 331, -1, -1, 327, 325, 326, -1, 329, -1, 333,
+ -1, 389, -1, 328, 36, -1, 14, -1, 13, -1,
+ 23, -1, 34, -1, 47, -1, 46, -1, 66, -1,
+ 122, -1, 67, -1, 123, -1, 115, -1, 137, -1,
+ -1, 22, 330, 333, -1, 333, -1, 389, -1, 332,
+ -1, 54, -1, 334, -1, 382, -1, 397, -1, 335,
+ -1, 144, -1, 9, -1, 10, -1, 337, -1, 336,
+ 91, 225, 130, -1, 338, -1, 340, -1, 342, -1,
+ 343, -1, 345, -1, 344, -1, 347, -1, 17, 229,
+ 95, 314, 132, -1, 339, -1, 404, -1, 12, -1,
+ 11, -1, 52, 341, -1, 7, -1, 405, -1, 95,
+ 225, 132, -1, 95, 132, -1, 53, -1, 194, 218,
+ -1, 399, 95, 346, 132, -1, -1, 227, -1, 226,
+ -1, 348, -1, 360, -1, 349, -1, 358, -1, 359,
+ -1, -1, -1, 77, 401, 350, 353, 351, 118, 353,
+ 352, -1, 128, -1, 75, 357, 27, 397, 75, -1,
+ -1, 353, 354, -1, 401, 73, 355, -1, 129, 356,
+ 129, -1, 16, 356, 16, -1, -1, 218, 356, -1,
+ 404, 356, -1, -1, 357, 348, -1, 357, 404, -1,
+ 357, 4, -1, 357, 218, -1, 39, 148, -1, 116,
+ 150, 149, -1, 361, -1, 362, -1, 365, -1, 366,
+ -1, 367, -1, 368, -1, 375, -1, 50, 364, 218,
+ -1, -1, 55, 364, 372, 363, 305, -1, -1, 166,
+ -1, 23, 364, 369, 305, -1, 153, 364, 218, -1,
+ 38, 364, 218, -1, 126, 374, 305, -1, -1, -1,
+ 370, 397, 371, -1, 373, -1, 397, -1, 373, -1,
+ 218, -1, 7, -1, 218, -1, 104, 218, 218, -1,
+ 381, -1, 381, 127, -1, -1, 18, 378, -1, 380,
+ 379, -1, 58, 395, -1, -1, 117, -1, 144, -1,
+ 127, -1, 381, -1, 382, -1, 389, -1, 89, 395,
+ -1, 397, -1, 384, -1, 392, -1, 394, -1, 388,
+ -1, 387, -1, 386, -1, 383, -1, 106, 395, -1,
+ 51, 395, -1, 51, 95, 385, 132, -1, 392, -1,
+ 394, -1, 153, 395, -1, 38, 395, -1, 126, 395,
+ -1, 126, 95, 7, 132, -1, 126, 95, 404, 132,
+ -1, 390, -1, 391, -1, 23, 395, -1, 23, 95,
+ 144, 132, -1, 23, 95, 396, 132, -1, 23, 95,
+ 396, 37, 398, 132, -1, 23, 95, 144, 37, 398,
+ 132, -1, 134, 95, 397, 132, -1, 55, 395, -1,
+ 55, 95, 144, 132, -1, 55, 95, 397, 132, -1,
+ 55, 95, 397, 37, 398, 393, 132, -1, 55, 95,
+ 144, 37, 398, 393, 132, -1, -1, 127, -1, 135,
+ 95, 397, 132, -1, 95, 132, -1, 7, -1, 405,
+ -1, 7, -1, 405, -1, 397, -1, 400, -1, 405,
+ -1, 7, -1, 167, 7, -1, 7, -1, 6, -1,
+ 7, -1, 405, -1, 404, -1, 3, -1, 5, -1,
+ 6, -1, 8, -1
+};
+
+/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
+static const yytype_uint16 yyrline[] =
+{
+ 0, 1341, 1341, 1342, 1344, 1345, 1376, 1377, 1393, 1491,
+ 1493, 1499, 1501, 1508, 1514, 1520, 1527, 1530, 1534, 1538,
+ 1558, 1572, 1576, 1570, 1639, 1643, 1660, 1663, 1665, 1670,
+ 1671, 1675, 1676, 1680, 1684, 1688, 1690, 1691, 1693, 1695,
+ 1741, 1755, 1760, 1765, 1766, 1768, 1783, 1798, 1808, 1823,
+ 1827, 1832, 1846, 1850, 1855, 1869, 1874, 1879, 1884, 1889,
+ 1905, 1928, 1936, 1937, 1938, 1940, 1957, 1958, 1960, 1961,
+ 1963, 1964, 1966, 2021, 2025, 2031, 2034, 2039, 2053, 2057,
+ 2063, 2062, 2171, 2174, 2180, 2201, 2207, 2211, 2213, 2218,
+ 2228, 2229, 2234, 2235, 2244, 2314, 2325, 2326, 2330, 2335,
+ 2404, 2405, 2409, 2414, 2458, 2459, 2464, 2471, 2477, 2478,
+ 2479, 2480, 2481, 2482, 2488, 2493, 2499, 2502, 2507, 2513,
+ 2519, 2523, 2548, 2549, 2553, 2557, 2551, 2598, 2601, 2596,
+ 2617, 2618, 2619, 2622, 2626, 2634, 2633, 2647, 2646, 2655,
+ 2656, 2657, 2659, 2667, 2678, 2681, 2683, 2688, 2695, 2702,
+ 2708, 2728, 2733, 2739, 2742, 2744, 2745, 2752, 2758, 2762,
+ 2767, 2768, 2771, 2775, 2770, 2784, 2788, 2783, 2796, 2799,
+ 2803, 2798, 2812, 2816, 2811, 2824, 2826, 2854, 2853, 2865,
+ 2873, 2864, 2884, 2885, 2888, 2892, 2897, 2902, 2901, 2917,
+ 2922, 2923, 2928, 2929, 2934, 2935, 2936, 2937, 2939, 2940,
+ 2945, 2946, 2951, 2952, 2954, 2955, 2960, 2961, 2962, 2963,
+ 2965, 2966, 2971, 2972, 2977, 2978, 2980, 2984, 2989, 2990,
+ 2996, 2997, 3002, 3003, 3008, 3009, 3014, 3015, 3020, 3024,
+ 3029, 3030, 3031, 3033, 3038, 3039, 3040, 3041, 3042, 3043,
+ 3045, 3050, 3051, 3052, 3053, 3054, 3055, 3057, 3062, 3063,
+ 3064, 3066, 3080, 3081, 3082, 3084, 3100, 3104, 3109, 3110,
+ 3112, 3117, 3118, 3120, 3126, 3130, 3136, 3139, 3140, 3144,
+ 3153, 3158, 3162, 3163, 3168, 3167, 3182, 3189, 3188, 3203,
+ 3211, 3211, 3220, 3222, 3225, 3230, 3232, 3236, 3302, 3305,
+ 3311, 3314, 3323, 3327, 3331, 3336, 3337, 3342, 3343, 3346,
+ 3345, 3375, 3377, 3378, 3380, 3394, 3395, 3396, 3397, 3398,
+ 3399, 3400, 3401, 3402, 3403, 3404, 3405, 3408, 3407, 3417,
+ 3428, 3433, 3435, 3440, 3441, 3443, 3447, 3449, 3453, 3462,
+ 3468, 3469, 3474, 3475, 3476, 3477, 3478, 3479, 3480, 3481,
+ 3491, 3492, 3497, 3501, 3506, 3511, 3516, 3521, 3525, 3530,
+ 3535, 3540, 3569, 3573, 3580, 3582, 3586, 3588, 3589, 3590,
+ 3624, 3633, 3622, 3874, 3878, 3898, 3901, 3907, 3912, 3917,
+ 3923, 3926, 3936, 3943, 3947, 3953, 3967, 3973, 3990, 3995,
+ 4008, 4009, 4010, 4011, 4012, 4013, 4014, 4016, 4024, 4023,
+ 4063, 4066, 4071, 4086, 4091, 4098, 4110, 4114, 4110, 4120,
+ 4122, 4126, 4128, 4143, 4147, 4156, 4161, 4165, 4171, 4174,
+ 4179, 4184, 4189, 4190, 4191, 4192, 4194, 4195, 4196, 4197,
+ 4202, 4238, 4239, 4240, 4241, 4242, 4243, 4244, 4246, 4251,
+ 4256, 4262, 4263, 4265, 4270, 4275, 4280, 4285, 4301, 4302,
+ 4304, 4309, 4314, 4318, 4330, 4343, 4353, 4358, 4363, 4368,
+ 4382, 4396, 4397, 4399, 4409, 4411, 4416, 4423, 4430, 4432,
+ 4434, 4435, 4437, 4441, 4446, 4447, 4449, 4455, 4457, 4459,
+ 4460, 4462, 4474
+};
+#endif
+
+#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+ First, the terminals, then, starting at YYNTOKENS, nonterminals. */
+static const char *const yytname[] =
+{
+ "\"end of file\"", "error", "$undefined", "\"<string literal>\"",
+ "\"<non-boundary text node>\"", "\"<string literal(XPath 2.0)>\"",
+ "\"QName\"", "\"NCName\"", "\"ClarkName\"", "ANY_LOCAL_NAME",
+ "ANY_PREFIX", "\"<number literal>\"", "\"<number literal(XPath 2.0)>\"",
+ "\"ancestor\"", "\"ancestor-or-self\"", "\"and\"", "\"'\"",
+ "\"apply-template\"", "\"as\"", "\"ascending\"", "\":=\"", "\"at\"",
+ "\"@\"", "\"attribute\"", "AVT", "\"|\"", "\"base-uri\"", "\"</\"",
+ "\"boundary-space\"", "\"by\"", "\"call-template\"", "\"case\"",
+ "\"castable\"", "\"cast\"", "\"child\"", "\"collation\"", "\"::\"",
+ "\",\"", "\"comment\"", "\"<!--\"", "\"construction\"",
+ "\"copy-namespaces\"", "\"{\"", "\"}\"", "\"declare\"", "\"default\"",
+ "\"descendant\"", "\"descendant-or-self\"", "\"descending\"", "\"div\"",
+ "\"document\"", "\"document-node\"", "\"$\"", "\".\"", "\"..\"",
+ "\"element\"", "\"else\"", "\"empty\"", "\"empty-sequence\"",
+ "\"encoding\"", "\"end_sort\"", "\"eq\"", "\"unknown keyword\"",
+ "\"every\"", "\"except\"", "\"external\"", "\"following\"",
+ "\"following-sibling\"", "\">>\"", "\"for-apply-template\"", "\"for\"",
+ "\"function\"", "\"ge\"", "\"=\"", "\">=\"", "\">\"", "\"<=\"", "\"<\"",
+ "\"!=\"", "\"greatest\"", "\"gt\"", "\"idiv\"", "\"if\"", "\"import\"",
+ "\"inherit\"", "\"in\"", "\"instance\"", "\"intersect\"", "\"is\"",
+ "\"item\"", "\"lax\"", "\"[\"", "\"least\"", "\"le\"", "\"let\"",
+ "\"(\"", "\"lt\"", "\"map\"", "\"matches\"", "\"-\"", "\"mode\"",
+ "\"mod\"", "\"module\"", "\"name\"", "\"namespace\"", "\"ne\"",
+ "\"node\"", "\"no-inherit\"", "\"no-preserve\"", "\"of\"", "\"option\"",
+ "\"ordered\"", "\"ordering\"", "\"order\"", "\"or\"", "\"parent\"",
+ "\"<?\"", "\"+\"", "POSITION_SET", "\"#)\"", "\"(#\"", "\"<<\"",
+ "\"preceding\"", "\"preceding-sibling\"", "\"preserve\"", "\"priority\"",
+ "\"processing-instruction\"", "\"?\"", "\"/>\"", "\"\\\"\"", "\"]\"",
+ "\"return\"", "\")\"", "\"satisfies\"", "\"schema-attribute\"",
+ "\"schema-element\"", "\"schema\"", "\"self\"", "\";\"", "\"/\"",
+ "\"//\"", "\"some\"", "\"sort\"", "\"stable\"", "\"*\"", "\"strict\"",
+ "\"strip\"", "SUCCESS", "COMMENT_CONTENT", "PI_CONTENT", "PI_TARGET",
+ "XSLT_VERSION", "\"template\"", "\"text\"", "\"then\"", "\"to\"",
+ "\"treat\"", "\"tunnel\"", "\"typeswitch\"", "\"union\"",
+ "\"unordered\"", "\"validate\"", "\"variable\"", "\"version\"",
+ "\"where\"", "\"xquery\"", "\"internal\"", "\"internal-name\"",
+ "\"current\"", "$accept", "Module", "VersionDecl", "Encoding",
+ "MainModule", "LibraryModule", "ModuleDecl", "Prolog", "TemplateDecl",
+ "@1", "@2", "OptionalPriority", "OptionalTemplateName", "TemplateName",
+ "Setter", "Import", "Separator", "NamespaceDecl", "BoundarySpaceDecl",
+ "BoundarySpacePolicy", "DefaultNamespaceDecl",
+ "DeclareDefaultElementNamespace", "DeclareDefaultFunctionNamespace",
+ "OptionDecl", "OrderingModeDecl", "OrderingMode", "EmptyOrderDecl",
+ "OrderingEmptySequence", "CopyNamespacesDecl", "PreserveMode",
+ "InheritMode", "DefaultCollationDecl", "BaseURIDecl", "SchemaImport",
+ "SchemaPrefix", "ModuleImport", "ModuleNamespaceDecl", "FileLocations",
+ "FileLocation", "VarDecl", "VariableValue", "OptionalDefaultValue",
+ "ConstructionDecl", "ConstructionMode", "FunctionDecl", "@3",
+ "ParamList", "Param", "FunctionBody", "EnclosedExpr", "QueryBody",
+ "Pattern", "PathPattern", "IdKeyPattern", "RelativePathPattern",
+ "PatternStep", "Expr", "ExpressionSequence", "ExprSingle",
+ "OptionalModes", "OptionalMode", "Modes", "Mode", "FLWORExpr",
+ "ForClause", "@4", "@5", "ForTail", "@6", "@7", "PositionalVar",
+ "LetClause", "@8", "LetTail", "@9", "WhereClause", "OrderByClause",
+ "MandatoryOrderByClause", "OrderSpecList", "OrderSpec",
+ "DirectionModifier", "EmptynessModifier", "CollationModifier",
+ "OrderByInputOrder", "QuantifiedExpr", "SomeQuantificationExpr", "@10",
+ "@11", "SomeQuantificationTail", "@12", "@13", "EveryQuantificationExpr",
+ "@14", "@15", "EveryQuantificationTail", "@16", "@17", "SatisfiesClause",
+ "TypeswitchExpr", "@18", "CaseClause", "@19", "@20", "CaseTail",
+ "CaseVariable", "CaseDefault", "@21", "IfExpr", "OrExpr", "AndExpr",
+ "ComparisonExpr", "RangeExpr", "AdditiveExpr", "AdditiveOperator",
+ "MultiplicativeExpr", "MultiplyOperator", "UnionExpr",
+ "IntersectExceptExpr", "UnionOperator", "IntersectOperator",
+ "InstanceOfExpr", "TreatExpr", "CastableExpr", "CastExpr", "UnaryExpr",
+ "UnaryOperator", "ValueExpr", "GeneralComp", "GeneralComparisonOperator",
+ "ValueComp", "ValueComparisonOperator", "NodeComp", "NodeOperator",
+ "ValidateExpr", "ValidationMode", "ExtensionExpr",
+ "EnclosedOptionalExpr", "Pragmas", "Pragma", "PragmaContents",
+ "PathExpr", "RelativePathExpr", "StepExpr", "@22", "@23",
+ "TemplateWithParameters", "@24", "TemplateParameters",
+ "OptionalTemplateParameters", "TemplateParameter", "IsTunnel",
+ "OptionalAssign", "MapOrSlash", "FilteredAxisStep", "AxisStep",
+ "ForwardStep", "@25", "NodeTestInAxisStep", "Axis", "AxisToken",
+ "AbbrevForwardStep", "@26", "ReverseStep", "AbbrevReverseStep",
+ "NodeTest", "NameTest", "WildCard", "FilterExpr", "PrimaryExpr",
+ "Literal", "NumericLiteral", "VarRef", "VarName", "ParenthesizedExpr",
+ "ContextItemExpr", "OrderingExpr", "FunctionCallExpr",
+ "FunctionArguments", "Constructor", "DirectConstructor",
+ "DirElemConstructor", "@27", "@28", "DirElemConstructorTail",
+ "DirAttributeList", "Attribute", "DirAttributeValue", "AttrValueContent",
+ "DirElemContent", "DirCommentConstructor", "DirPIConstructor",
+ "ComputedConstructor", "CompDocConstructor", "CompElemConstructor",
+ "@29", "IsInternal", "CompAttrConstructor", "CompTextConstructor",
+ "CompCommentConstructor", "CompPIConstructor", "CompAttributeName",
+ "@30", "@31", "CompElementName", "CompNameExpr", "CompPIName",
+ "CompNamespaceConstructor", "SingleType", "TypeDeclaration",
+ "SequenceType", "OccurrenceIndicator", "ItemType", "AtomicType",
+ "KindTest", "AnyKindTest", "DocumentTest", "AnyElementTest", "TextTest",
+ "CommentTest", "PITest", "AnyAttributeTest", "AttributeTest",
+ "SchemaAttributeTest", "ElementTest", "OptionalQuestionMark",
+ "SchemaElementTest", "EmptyParanteses", "AttributeName", "ElementName",
+ "TypeName", "FunctionName", "NCName", "LexicalName", "PragmaName",
+ "URILiteral", "StringLiteral", "QName", 0
+};
+#endif
+
+# ifdef YYPRINT
+/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
+ token YYLEX-NUM. */
+static const yytype_uint16 yytoknum[] =
+{
+ 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
+ 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
+ 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
+ 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
+ 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
+ 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
+ 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
+ 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
+ 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
+ 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
+ 355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
+ 365, 366, 367, 368, 369, 370, 371, 372, 373, 374,
+ 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
+ 385, 386, 387, 388, 389, 390, 391, 392, 393, 394,
+ 395, 396, 397, 398, 399, 400, 401, 402, 403, 404,
+ 405, 406, 407, 408, 409, 410, 411, 412, 413, 414,
+ 415, 416, 417, 418, 419, 420, 421, 422, 423
+};
+# endif
+
+/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
+static const yytype_uint16 yyr1[] =
+{
+ 0, 169, 170, 170, 171, 171, 172, 172, 173, 174,
+ 175, 176, 176, 176, 176, 176, 176, 176, 176, 176,
+ 177, 178, 179, 177, 180, 180, 181, 181, 182, 183,
+ 183, 183, 183, 183, 183, 183, 184, 184, 185, 186,
+ 187, 188, 188, 189, 189, 190, 191, 192, 193, 194,
+ 194, 195, 196, 196, 197, 198, 198, 199, 199, 200,
+ 201, 202, 203, 203, 203, 204, 205, 205, 206, 206,
+ 207, 207, 208, 209, 209, 210, 210, 211, 212, 212,
+ 214, 213, 215, 215, 215, 216, 217, 217, 218, 219,
+ 220, 220, 221, 221, 221, 221, 221, 221, 221, 222,
+ 223, 223, 223, 224, 225, 225, 226, 226, 227, 227,
+ 227, 227, 227, 227, 228, 228, 229, 229, 230, 230,
+ 231, 231, 232, 232, 234, 235, 233, 237, 238, 236,
+ 236, 236, 236, 239, 239, 241, 240, 243, 242, 242,
+ 242, 242, 244, 244, 245, 245, 246, 247, 247, 248,
+ 249, 249, 249, 250, 250, 251, 251, 251, 252, 252,
+ 253, 253, 255, 256, 254, 258, 259, 257, 257, 261,
+ 262, 260, 264, 265, 263, 263, 266, 268, 267, 270,
+ 271, 269, 272, 272, 273, 273, 274, 275, 274, 276,
+ 277, 277, 278, 278, 279, 279, 279, 279, 280, 280,
+ 281, 281, 282, 282, 283, 283, 284, 284, 284, 284,
+ 285, 285, 286, 286, 287, 287, 288, 288, 289, 289,
+ 290, 290, 291, 291, 292, 292, 293, 293, 294, 294,
+ 295, 295, 295, 296, 297, 297, 297, 297, 297, 297,
+ 298, 299, 299, 299, 299, 299, 299, 300, 301, 301,
+ 301, 302, 303, 303, 303, 304, 305, 305, 306, 306,
+ 307, 308, 308, 309, 309, 309, 309, 310, 310, 310,
+ 310, 311, 311, 311, 312, 311, 311, 313, 311, 311,
+ 315, 314, 316, 316, 316, 317, 317, 318, 319, 319,
+ 320, 320, 321, 321, 321, 322, 322, 323, 323, 325,
+ 324, 324, 326, 326, 327, 328, 328, 328, 328, 328,
+ 328, 328, 328, 328, 328, 328, 328, 330, 329, 329,
+ 329, 331, 332, 333, 333, 334, 334, 335, 335, 335,
+ 336, 336, 337, 337, 337, 337, 337, 337, 337, 337,
+ 338, 338, 339, 339, 340, 341, 341, 342, 342, 343,
+ 344, 345, 346, 346, 346, 347, 347, 348, 348, 348,
+ 350, 351, 349, 352, 352, 353, 353, 354, 355, 355,
+ 356, 356, 356, 357, 357, 357, 357, 357, 358, 359,
+ 360, 360, 360, 360, 360, 360, 360, 361, 363, 362,
+ 364, 364, 365, 366, 367, 368, 370, 371, 369, 369,
+ 372, 372, 373, 374, 374, 375, 376, 376, 377, 377,
+ 378, 378, 379, 379, 379, 379, 380, 380, 380, 380,
+ 381, 382, 382, 382, 382, 382, 382, 382, 383, 384,
+ 384, 385, 385, 386, 387, 388, 388, 388, 389, 389,
+ 390, 390, 390, 390, 390, 391, 392, 392, 392, 392,
+ 392, 393, 393, 394, 395, 396, 396, 397, 397, 398,
+ 399, 399, 400, 400, 401, 401, 402, 402, 403, 404,
+ 404, 405, 405
+};
+
+/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
+static const yytype_uint8 yyr2[] =
+{
+ 0, 2, 2, 2, 0, 5, 0, 2, 2, 2,
+ 6, 0, 2, 2, 2, 2, 2, 2, 2, 2,
+ 7, 0, 0, 15, 0, 2, 0, 1, 2, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 7,
+ 4, 1, 1, 1, 1, 6, 6, 5, 4, 1,
+ 1, 5, 2, 2, 6, 1, 1, 1, 1, 5,
+ 5, 6, 0, 3, 3, 6, 0, 3, 0, 2,
+ 1, 3, 9, 1, 2, 0, 2, 4, 1, 1,
+ 0, 11, 0, 1, 3, 3, 1, 1, 3, 1,
+ 1, 3, 1, 1, 2, 2, 1, 3, 3, 1,
+ 1, 3, 3, 1, 1, 1, 3, 3, 1, 1,
+ 1, 1, 1, 4, 0, 2, 0, 2, 1, 3,
+ 1, 1, 1, 1, 0, 0, 10, 0, 0, 10,
+ 1, 1, 1, 0, 3, 0, 9, 0, 8, 1,
+ 1, 1, 3, 5, 0, 1, 2, 3, 1, 4,
+ 0, 1, 1, 0, 1, 0, 2, 3, 3, 2,
+ 1, 1, 0, 0, 9, 0, 0, 9, 1, 0,
+ 0, 9, 0, 0, 9, 1, 2, 0, 6, 0,
+ 0, 8, 1, 1, 0, 3, 3, 0, 6, 8,
+ 1, 3, 1, 3, 1, 1, 1, 1, 1, 3,
+ 1, 3, 1, 1, 1, 3, 1, 1, 1, 1,
+ 1, 3, 1, 3, 1, 1, 1, 1, 1, 4,
+ 1, 4, 1, 4, 1, 4, 1, 2, 1, 1,
+ 1, 1, 1, 3, 1, 1, 1, 1, 1, 1,
+ 3, 1, 1, 1, 1, 1, 1, 3, 1, 1,
+ 1, 2, 1, 2, 2, 2, 2, 3, 2, 1,
+ 4, 0, 1, 2, 2, 1, 1, 1, 3, 7,
+ 3, 1, 1, 2, 0, 3, 5, 0, 9, 5,
+ 0, 2, 0, 1, 3, 0, 3, 5, 0, 1,
+ 0, 2, 1, 1, 1, 1, 4, 1, 1, 0,
+ 3, 1, 1, 1, 2, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 0, 3, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 4, 1, 1, 1, 1, 1, 1, 1, 5,
+ 1, 1, 1, 1, 2, 1, 1, 3, 2, 1,
+ 2, 4, 0, 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 8, 1, 5, 0, 2, 3, 3, 3,
+ 0, 2, 2, 0, 2, 2, 2, 2, 2, 3,
+ 1, 1, 1, 1, 1, 1, 1, 3, 0, 5,
+ 0, 1, 4, 3, 3, 3, 0, 0, 3, 1,
+ 1, 1, 1, 1, 1, 3, 1, 2, 0, 2,
+ 2, 2, 0, 1, 1, 1, 1, 1, 1, 2,
+ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
+ 4, 1, 1, 2, 2, 2, 4, 4, 1, 1,
+ 2, 4, 4, 6, 6, 4, 2, 4, 4, 7,
+ 7, 0, 1, 4, 2, 1, 1, 1, 1, 1,
+ 1, 1, 1, 2, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1
+};
+
+/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
+ STATE-NUM when YYTABLE doesn't specify something else to do. Zero
+ means the default is an error. */
+static const yytype_uint16 yydefact[] =
+{
+ 4, 0, 0, 11, 0, 1, 0, 3, 2, 11,
+ 0, 469, 470, 6, 0, 9, 471, 457, 472, 328,
+ 329, 343, 342, 306, 305, 116, 317, 390, 0, 0,
+ 0, 308, 390, 0, 0, 310, 309, 390, 0, 0,
+ 349, 322, 390, 0, 311, 313, 0, 0, 0, 0,
+ 390, 0, 229, 0, 0, 49, 315, 0, 228, 0,
+ 312, 314, 0, 0, 0, 316, 265, 0, 0, 327,
+ 274, 390, 0, 50, 252, 0, 0, 16, 13, 15,
+ 14, 29, 12, 43, 44, 19, 33, 0, 34, 35,
+ 30, 31, 36, 37, 17, 32, 18, 8, 89, 105,
+ 104, 109, 122, 123, 110, 160, 161, 111, 112, 108,
+ 190, 192, 194, 198, 200, 204, 210, 212, 218, 220,
+ 222, 224, 0, 226, 196, 195, 197, 230, 0, 232,
+ 0, 259, 231, 266, 267, 271, 295, 297, 299, 0,
+ 301, 298, 321, 319, 323, 326, 272, 330, 332, 340,
+ 333, 334, 335, 337, 336, 338, 355, 357, 358, 359,
+ 356, 380, 381, 382, 383, 384, 385, 386, 324, 427,
+ 421, 426, 425, 424, 320, 438, 439, 422, 423, 325,
+ 0, 460, 341, 458, 0, 0, 0, 0, 0, 0,
+ 0, 0, 391, 396, 440, 370, 0, 457, 0, 458,
+ 0, 0, 434, 378, 390, 0, 0, 0, 0, 390,
+ 0, 0, 0, 26, 390, 0, 0, 429, 345, 344,
+ 346, 0, 0, 446, 0, 0, 465, 464, 360, 0,
+ 66, 62, 0, 0, 348, 0, 0, 0, 428, 0,
+ 466, 261, 467, 403, 0, 404, 0, 435, 0, 0,
+ 263, 264, 0, 0, 0, 433, 0, 254, 253, 463,
+ 273, 350, 0, 0, 0, 0, 241, 250, 243, 234,
+ 236, 237, 238, 239, 235, 244, 248, 245, 246, 242,
+ 249, 0, 0, 0, 203, 202, 0, 0, 207, 208,
+ 209, 206, 0, 215, 214, 0, 217, 216, 0, 0,
+ 0, 0, 0, 227, 251, 0, 255, 258, 294, 293,
+ 292, 0, 0, 0, 0, 304, 0, 352, 7, 38,
+ 5, 0, 0, 121, 117, 120, 280, 0, 0, 0,
+ 0, 318, 455, 454, 0, 0, 456, 402, 0, 0,
+ 399, 370, 0, 370, 0, 280, 394, 0, 42, 41,
+ 0, 79, 78, 0, 56, 55, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 285, 0, 387,
+ 0, 431, 432, 0, 0, 388, 401, 400, 408, 408,
+ 365, 0, 0, 0, 0, 0, 0, 0, 0, 347,
+ 0, 405, 379, 0, 262, 0, 0, 395, 0, 0,
+ 408, 275, 393, 0, 107, 106, 191, 193, 233, 240,
+ 247, 199, 201, 205, 211, 213, 0, 0, 0, 0,
+ 256, 0, 270, 0, 268, 0, 0, 300, 302, 303,
+ 0, 354, 353, 0, 0, 468, 0, 0, 282, 0,
+ 441, 0, 442, 392, 397, 371, 113, 372, 0, 0,
+ 0, 40, 77, 0, 0, 0, 0, 0, 0, 462,
+ 0, 461, 0, 0, 48, 28, 0, 282, 408, 0,
+ 430, 0, 447, 0, 448, 0, 0, 0, 133, 361,
+ 0, 0, 68, 0, 0, 68, 408, 0, 88, 260,
+ 436, 437, 445, 453, 0, 177, 0, 0, 219, 412,
+ 416, 417, 418, 420, 221, 223, 406, 225, 257, 0,
+ 0, 0, 0, 296, 331, 351, 10, 0, 339, 289,
+ 281, 283, 0, 459, 0, 0, 398, 276, 279, 60,
+ 57, 58, 0, 59, 0, 0, 53, 52, 51, 82,
+ 469, 390, 47, 21, 0, 0, 408, 451, 451, 389,
+ 409, 0, 0, 0, 0, 366, 0, 0, 67, 0,
+ 0, 63, 64, 0, 0, 0, 0, 0, 411, 419,
+ 413, 415, 414, 410, 407, 159, 0, 0, 150, 146,
+ 148, 288, 0, 444, 443, 54, 45, 46, 0, 0,
+ 83, 277, 0, 0, 286, 0, 0, 452, 0, 0,
+ 169, 0, 0, 365, 0, 0, 69, 70, 65, 61,
+ 0, 0, 162, 184, 178, 158, 0, 151, 152, 153,
+ 0, 284, 408, 408, 0, 80, 0, 39, 307, 93,
+ 0, 22, 90, 96, 92, 100, 103, 99, 20, 0,
+ 73, 75, 450, 449, 170, 134, 124, 0, 370, 370,
+ 367, 0, 0, 135, 163, 0, 0, 269, 154, 155,
+ 147, 290, 85, 84, 408, 0, 94, 95, 0, 0,
+ 0, 0, 0, 0, 74, 0, 0, 0, 125, 373,
+ 363, 362, 0, 0, 189, 71, 144, 0, 0, 179,
+ 0, 0, 149, 0, 287, 0, 278, 91, 114, 97,
+ 98, 101, 102, 76, 72, 0, 0, 171, 175, 144,
+ 0, 369, 368, 0, 0, 140, 141, 136, 139, 0,
+ 145, 0, 164, 168, 185, 0, 156, 0, 291, 86,
+ 0, 87, 0, 24, 0, 176, 0, 131, 126, 132,
+ 130, 376, 0, 377, 374, 375, 0, 144, 0, 0,
+ 0, 157, 81, 115, 118, 0, 285, 408, 0, 0,
+ 408, 0, 142, 408, 180, 0, 25, 408, 0, 408,
+ 364, 0, 0, 0, 0, 119, 0, 0, 133, 0,
+ 143, 0, 0, 182, 181, 183, 0, 172, 0, 137,
+ 165, 0, 0, 23, 173, 0, 144, 166, 187, 186,
+ 0, 127, 138, 0, 0, 174, 128, 167, 0, 144,
+ 188, 129
+};
+
+/* YYDEFGOTO[NTERM-NUM]. */
+static const yytype_int16 yydefgoto[] =
+{
+ -1, 2, 3, 185, 7, 8, 9, 10, 77, 593,
+ 669, 756, 366, 367, 78, 79, 320, 80, 81, 350,
+ 82, 83, 84, 85, 86, 87, 88, 458, 89, 356,
+ 532, 90, 91, 92, 386, 93, 383, 560, 606, 94,
+ 641, 676, 95, 353, 96, 664, 589, 590, 730, 341,
+ 97, 631, 632, 633, 634, 635, 98, 99, 100, 733,
+ 189, 753, 324, 101, 102, 678, 709, 738, 806, 809,
+ 553, 103, 686, 717, 796, 718, 719, 720, 579, 580,
+ 619, 659, 692, 512, 104, 105, 654, 687, 722, 797,
+ 803, 106, 644, 677, 707, 794, 800, 708, 107, 567,
+ 614, 725, 774, 784, 656, 785, 804, 108, 109, 110,
+ 111, 112, 113, 287, 114, 292, 115, 116, 295, 298,
+ 117, 118, 119, 120, 121, 122, 123, 124, 281, 125,
+ 282, 126, 283, 127, 128, 129, 306, 130, 131, 393,
+ 132, 133, 134, 253, 626, 437, 438, 520, 468, 521,
+ 522, 694, 312, 135, 136, 137, 314, 427, 138, 139,
+ 140, 190, 141, 142, 143, 144, 145, 146, 147, 148,
+ 149, 150, 219, 151, 152, 153, 154, 433, 155, 156,
+ 157, 380, 554, 681, 479, 555, 650, 342, 710, 158,
+ 159, 160, 161, 162, 475, 193, 163, 164, 165, 166,
+ 338, 339, 526, 375, 340, 246, 167, 505, 477, 498,
+ 573, 499, 500, 168, 169, 170, 370, 171, 172, 173,
+ 174, 175, 176, 177, 598, 178, 194, 335, 179, 524,
+ 180, 181, 556, 241, 541, 182, 183
+};
+
+/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+ STATE-NUM. */
+#define YYPACT_NINF -668
+static const yytype_int16 yypact[] =
+{
+ -63, -28, 185, 86, 337, -668, 117, -668, -668, -668,
+ 734, -668, -668, 181, 253, 156, -668, 213, -668, -668,
+ -668, -668, -668, -668, -668, 212, -668, -12, 230, 337,
+ 342, -668, -38, 189, 298, -668, -668, 188, 272, 353,
+ -668, -668, 71, 316, -668, -668, 318, 239, 276, 134,
+ 188, 900, -668, 334, 282, -668, -668, 233, -668, 367,
+ -668, -668, 133, 290, 295, -668, 1730, 1730, 345, -668,
+ -668, -38, 305, -668, -36, 396, 334, -668, -668, -668,
+ -668, -668, -668, -668, -668, -668, -668, 334, -668, -668,
+ -668, -668, -668, -668, -668, -668, -668, -668, -668, 369,
+ 370, -668, -668, -668, -668, -668, -668, -668, -668, 307,
+ 389, -668, 601, 173, 24, -22, 32, -668, 338, 267,
+ 393, 394, 1398, -668, -668, -668, -668, -668, 334, -668,
+ 59, -668, -668, 166, -668, 339, -668, -668, -668, 395,
+ -668, -668, -668, -668, -668, -668, 341, -668, -668, -668,
+ -668, -668, -668, -668, -668, -668, -668, -668, -668, -668,
+ -668, -668, -668, -668, -668, -668, -668, -668, -668, -668,
+ -668, -668, -668, -668, -668, -668, -668, -668, -668, -668,
+ 340, -668, -668, 347, 337, 291, 360, 493, 373, 349,
+ 1885, 64, -668, 334, -668, 226, 392, -668, 358, -668,
+ 304, 334, -668, -668, 188, 167, 174, 206, 21, 188,
+ 430, 342, -53, 351, 188, 334, 6, -668, -668, -668,
+ -668, 79, 287, -668, 353, 353, -668, -668, -668, 1232,
+ 336, 18, 403, 344, -668, 324, 1232, 334, -668, 308,
+ -668, 337, -668, -668, 23, -668, 416, -668, 342, 342,
+ 166, 166, 353, 334, 334, -668, 1232, -668, -668, -668,
+ -668, -668, 1232, 1232, 1398, 1398, -668, -668, -668, -668,
+ -668, -668, -668, -668, -668, -668, -668, -668, -668, -668,
+ -668, 1398, 1398, 1398, -668, -668, 1398, 1398, -668, -668,
+ -668, -668, 1398, -668, -668, 1398, -668, -668, 1398, 352,
+ 447, 448, 449, -668, -668, 1066, -668, -668, -668, -668,
+ -668, 1730, 1564, 1232, 108, -668, 1232, 1232, -668, -668,
+ -668, 337, 461, -668, -668, -668, -668, 282, 374, 378,
+ 282, -668, -668, -668, 0, 51, -668, -668, 416, 342,
+ -668, 226, 343, 226, 1232, -668, -668, 337, -668, -668,
+ 291, -668, -668, 291, -668, -668, 437, 337, 372, 376,
+ 421, 26, 408, 337, 291, 342, 384, -1, 431, -668,
+ 355, -668, -668, 52, 69, -668, -668, -668, 466, 466,
+ -668, 356, 482, 337, 435, 484, 337, 353, 485, -668,
+ 453, -668, -668, 379, -668, 365, 368, -668, 371, 377,
+ 466, -668, -668, 380, -668, -668, 389, -668, -668, -668,
+ -668, 168, 24, -22, 32, -668, 456, 456, 342, 342,
+ -668, 459, -668, 191, -668, 375, 404, -668, -668, -668,
+ 383, 369, 370, 386, 291, -668, 442, 388, -6, 342,
+ -668, 342, -668, -668, -668, -668, -668, -668, 465, 391,
+ 291, -668, -668, 157, 291, 337, 337, 16, 291, -668,
+ 409, -668, 348, 291, -668, -668, 415, -6, 466, 353,
+ -668, 342, -668, 342, -668, 416, 456, 440, 495, 239,
+ 381, 454, 507, 425, 457, 507, 466, 463, -668, -668,
+ -668, -668, -668, -668, 462, -668, 282, 282, -668, 121,
+ -668, -668, -668, -668, -668, -668, 412, -668, -668, 512,
+ 433, 417, 1232, -668, -668, -668, -668, 337, -668, -668,
+ 513, -668, 497, -668, 422, 423, -668, -668, -668, -668,
+ -668, -668, 291, -668, 291, 291, -668, -668, -668, 504,
+ 515, 188, -668, -668, 83, 416, 466, 432, 432, -668,
+ -668, 1232, 508, 476, 450, -668, 492, 1232, -668, 337,
+ 291, -668, -668, 291, 547, 566, 1232, 539, -668, -668,
+ -668, -668, -668, -668, -668, -668, 543, 1730, 62, 536,
+ -668, 419, 353, -668, -668, -668, -668, -668, 353, 84,
+ -668, -668, 291, 1804, -668, 291, 46, -668, 445, 446,
+ -668, 353, 1232, -668, 33, 524, 550, -668, -668, -668,
+ 1232, 515, -668, 537, -668, -668, 528, -668, -668, 421,
+ 1232, -668, 466, 466, 504, -668, 1232, -668, 404, 1899,
+ 1899, 567, -668, 140, 148, -668, 339, -668, -668, 1232,
+ -668, 573, -668, -668, -668, -668, -668, 92, 226, 226,
+ -668, 1232, 337, -668, -668, 342, 456, -668, -668, -23,
+ -668, 574, -668, -668, 466, 552, 148, 148, 1804, 464,
+ 1899, 1899, 1899, 1899, -668, 1232, 291, 11, -668, -668,
+ -668, -668, 582, 472, -668, -668, 10, 47, 584, -668,
+ 337, 569, -668, 1232, -668, 234, -668, -668, 506, 148,
+ 148, -668, -668, -668, -668, 555, 1232, -668, -668, 63,
+ 250, -668, -668, 556, 1232, -668, -668, -668, -668, 479,
+ -668, 559, -668, -668, -668, 481, -668, 1232, -668, -668,
+ 291, -668, 373, 488, 353, -668, 562, -668, -668, -668,
+ -668, -668, 342, -668, -668, -668, 353, 191, 1232, 353,
+ 1232, -668, -668, 578, -668, 337, 521, 466, 353, 542,
+ 466, 487, -668, 466, -668, 373, -668, 466, 534, 466,
+ -668, 600, 1232, 538, 125, -668, 416, 1232, 495, 1232,
+ -668, 1232, -2, -668, -668, -668, 291, -668, 544, -668,
+ -668, 342, 1232, -668, -668, 1232, 10, -668, -668, -668,
+ 11, -668, -668, 47, 490, -668, -668, -668, 1232, 63,
+ -668, -668
+};
+
+/* YYPGOTO[NTERM-NUM]. */
+static const yytype_int16 yypgoto[] =
+{
+ -668, -668, -668, -668, -668, -668, -668, 613, -668, -668,
+ -668, -668, -668, -668, -668, -668, -285, -668, -668, -668,
+ -668, -668, -668, -668, -668, 418, -668, 5, -668, -668,
+ -668, -668, -668, -668, -668, -668, -668, 142, -668, -668,
+ -668, -668, -668, -668, -668, -668, -668, 4, -668, -51,
+ -668, -668, -35, -668, -397, -340, -47, 317, -255, -668,
+ -668, -668, -641, -668, -619, -668, -668, -174, -668, -668,
+ -142, -583, -668, -159, -668, -657, -109, 216, -668, 27,
+ -668, -668, -668, -668, -668, -668, -668, -668, -157, -668,
+ -668, -668, -668, -668, -152, -668, -668, -667, -668, -668,
+ -125, -668, -668, -668, -668, -668, -668, -668, -668, 387,
+ 385, 131, 366, -668, 397, -668, 361, 359, -668, -668,
+ 362, -668, -668, -668, 535, -668, -668, -668, -668, -668,
+ -668, -668, -668, -668, -668, -668, -245, -668, 526, -668,
+ -668, 279, -294, -668, -668, 313, -668, 194, -91, 85,
+ -668, -668, -668, -87, -668, -668, -668, -668, -668, -668,
+ -668, -668, -668, -668, -175, -668, -668, -668, -668, -668,
+ -668, -668, -183, -668, -668, -668, -538, -668, -668, -42,
+ -668, -668, -668, -668, 67, -668, -668, -327, -668, -668,
+ -668, -668, -668, -668, -668, 3, -668, -668, -668, -668,
+ -668, -668, -668, -668, 458, -668, -668, 252, -341, -412,
+ -668, -668, -55, -394, -668, -668, -668, -668, -668, -668,
+ -304, -668, -668, 467, 124, 469, -11, -668, -24, -170,
+ 321, -668, 639, -668, -308, 15, -30
+};
+
+/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
+ positive, shift that token. If negative, reduce the rule which
+ number is the opposite. If zero, do what YYDEFACT says.
+ If YYTABLE_NINF, syntax error. */
+#define YYTABLE_NINF -463
+static const yytype_int16 yytable[] =
+{
+ 199, 397, 237, 293, 235, 504, 198, 404, 405, 220,
+ 429, 245, 690, 434, 445, 331, 447, 422, 424, 13,
+ 723, 202, 501, 501, -307, 260, 11, 217, 12, 242,
+ 395, 223, 16, 459, 18, 201, 261, 439, 478, 450,
+ 215, 378, 379, 238, 196, 222, -288, 713, 705, 648,
+ 791, 247, 740, 232, 257, 637, 357, 200, 55, 494,
+ 255, 328, 432, 384, 550, 451, 639, 715, 452, 400,
+ 16, 332, 18, 288, 254, 482, 358, 304, 485, 464,
+ 46, 617, 501, 191, 721, 16, 197, 18, 441, 471,
+ 737, 754, 359, 443, 467, 536, 296, -27, 226, 227,
+ 736, 305, 1, 716, 50, 289, 473, 73, 537, 258,
+ 618, 640, 502, 502, 16, 197, 18, 19, 20, 297,
+ 581, 624, 385, 509, 775, 290, 739, 545, 192, 792,
+ 637, 426, 440, 46, 360, 4, 723, 294, 333, 428,
+ 243, 64, 337, 691, 706, 564, 327, 534, 535, 516,
+ 346, 519, 740, 510, 192, 333, 613, 50, 325, 38,
+ 199, 336, 649, 328, 369, 529, 221, 679, 291, 533,
+ 782, 337, 502, 538, 714, 236, 509, 715, 542, 59,
+ 706, 199, 381, 442, 472, 5, 391, 363, 6, 390,
+ 737, 199, 199, 75, 220, 220, 333, 374, 377, 318,
+ 187, 474, 401, 402, 486, 596, 510, 347, 334, 403,
+ 343, 333, 361, 716, 54, 594, 625, 368, 199, 199,
+ 680, 14, 220, 373, 398, 399, 739, 714, 244, 11,
+ 549, 12, 666, 667, 329, 308, 230, 192, 570, 49,
+ 184, 530, 63, 64, 689, 226, 227, 585, 571, 586,
+ 587, 607, 69, 11, 741, 12, 394, 578, 421, 396,
+ 186, 330, 501, 309, 531, 572, 425, 284, 236, 430,
+ 231, 525, 284, 699, 700, 608, 236, 742, 609, 670,
+ 671, 661, 662, 616, 199, 285, 546, 672, 673, 33,
+ 285, 348, 236, 16, 197, 18, 600, 448, 351, 729,
+ 595, 547, 605, 548, 509, 310, 311, 627, -462, 199,
+ 638, 612, 188, 349, 354, 444, 202, 223, 247, 255,
+ 352, 682, 683, 695, 204, 195, 205, 47, 286, 236,
+ 355, 461, 701, 702, 510, 199, 435, 203, 206, 207,
+ 11, 465, 12, 208, 685, 250, 251, 646, 16, 197,
+ 18, 540, 502, 12, 192, 653, 343, 220, 343, 16,
+ 218, 18, 435, 506, 506, 578, 57, 216, 224, 209,
+ 225, 229, 454, 16, 240, 18, 236, 200, 463, 16,
+ 323, 18, 726, 239, 674, 248, 199, 199, 199, 199,
+ 249, 704, 503, 503, 503, 503, 684, 252, 435, 622,
+ 256, 435, 210, 259, 265, 623, 262, 263, 211, 199,
+ 212, 199, 408, 409, 410, 523, 768, 523, 645, 771,
+ 703, 264, 773, 300, 299, 301, 776, 302, 778, 319,
+ 313, 315, 316, 321, 344, 317, 333, 362, 728, 220,
+ 382, 199, -461, 199, 326, 752, 199, 523, 388, 523,
+ 213, 735, 503, 345, 365, 387, 389, 392, 305, 747,
+ 214, 416, 16, 197, 18, 417, 418, 419, 436, 221,
+ 435, 435, 751, 244, 453, 446, 455, 435, 457, 426,
+ 456, 462, 466, 469, 476, 568, 569, 470, 480, 481,
+ 483, 484, 487, 762, 327, 764, 488, 490, 489, 191,
+ 491, 793, 508, 492, 539, 513, 636, 38, 527, 493,
+ 543, 328, 495, 514, 496, 517, 552, 780, 515, 204,
+ 518, 205, 787, 528, 789, 551, 790, 558, 559, 561,
+ 562, 786, 435, 206, 207, 557, 565, 799, 208, 574,
+ 801, 575, 636, 636, 592, 497, 576, 566, 577, 582,
+ 581, 757, 220, 810, 583, 584, 588, 591, 220, 597,
+ 601, 602, 54, 760, 209, 604, 763, 610, 603, 611,
+ 613, 220, 615, 620, 435, 769, 519, 642, 643, 665,
+ 651, 636, 329, 636, 636, 636, 636, 652, 657, 655,
+ 63, 64, 668, 675, 693, 696, 698, 322, 711, 199,
+ 199, 712, 724, 211, 727, 212, 732, 734, 746, 330,
+ 748, 749, 750, 755, 758, 765, 467, 770, 772, 777,
+ 779, 808, 15, 781, 658, 199, 199, 563, 663, 795,
+ 364, 688, 503, 697, 431, 811, 788, 802, 761, 511,
+ 199, 199, 199, 199, 731, 213, 807, 660, 805, 783,
+ 407, 406, 411, 413, 414, 214, 307, 303, 449, 743,
+ 415, 544, 266, 343, 343, 767, 621, 435, 744, 267,
+ 647, 507, 599, 268, 269, 270, 271, 272, 273, 274,
+ 376, 275, 460, 371, 412, 372, 228, 0, 0, 276,
+ 0, 0, 0, 0, 277, 0, 0, 278, 0, 0,
+ 0, 0, 325, 0, 220, 435, 279, 0, 0, 0,
+ 0, 0, 199, 0, 0, 0, 220, 0, 759, 220,
+ 0, 0, 280, 0, 0, 745, 0, 0, 220, 0,
+ 0, 0, 0, 0, 0, 325, 0, 11, 0, 12,
+ 16, 17, 18, 19, 20, 21, 22, 23, 24, 0,
+ 0, 25, 0, 0, 0, 0, 26, 27, 28, 0,
+ 29, 199, 0, 0, 30, 0, 0, 798, 31, 0,
+ 766, 0, 32, 33, 0, 0, 0, 0, 34, 0,
+ 35, 36, 0, 0, 37, 38, 39, 40, 41, 42,
+ 0, 0, 0, 0, 0, 0, 0, 43, 0, 0,
+ 44, 45, 0, 0, 46, 0, 0, 0, 0, 0,
+ 0, 47, 0, 0, 0, 0, 48, 49, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 50, 51,
+ 0, 0, 0, 52, 0, 0, 0, 0, 53, 0,
+ 54, 0, 0, 0, 0, 55, 0, 0, 0, 56,
+ 57, 58, 0, 0, 59, 0, 60, 61, 0, 0,
+ 62, 0, 0, 0, 0, 0, 0, 0, 63, 64,
+ 0, 65, 0, 66, 67, 68, 0, 0, 69, 0,
+ 0, 0, 0, 0, 0, 70, 0, 71, 0, 0,
+ 0, 0, 72, 0, 73, 74, 0, 0, 0, 0,
+ 0, 75, 76, 11, 0, 12, 16, 17, 18, 19,
+ 20, 21, 22, 23, 24, 0, 0, 25, 0, 0,
+ 0, 0, 26, 27, 28, 0, 29, 0, 0, 0,
+ 30, 0, 0, 0, 31, 0, 0, 0, 32, 33,
+ 0, 0, 0, 0, 233, 0, 35, 36, 0, 0,
+ 37, 38, 39, 40, 41, 42, 0, 0, 0, 0,
+ 0, 0, 0, 43, 0, 0, 44, 45, 0, 0,
+ 46, 0, 0, 0, 0, 0, 0, 47, 0, 0,
+ 0, 0, 48, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 50, 51, 0, 0, 0, 52,
+ 0, 0, 0, 0, 53, 0, 54, 0, 0, 0,
+ 0, 55, 0, 0, 0, 56, 57, 58, 0, 0,
+ 59, 0, 60, 61, 0, 0, 62, 0, 0, 0,
+ 0, 0, 234, 0, 63, 64, 0, 65, 0, 66,
+ 67, 68, 0, 0, 69, 0, 0, 0, 0, 0,
+ 0, 70, 0, 71, 0, 0, 0, 0, 72, 0,
+ 73, 74, 0, 0, 0, 0, 0, 75, 76, 11,
+ 0, 12, 16, 17, 18, 19, 20, 21, 22, 23,
+ 24, 0, 0, 25, 0, 0, 0, 0, 26, 27,
+ 28, 0, 29, 0, 0, 0, 30, 0, 0, 0,
+ 31, 0, 0, 0, 32, 33, 0, 0, 0, 420,
+ 233, 0, 35, 36, 0, 0, 37, 38, 39, 40,
+ 41, 42, 0, 0, 0, 0, 0, 0, 0, 43,
+ 0, 0, 44, 45, 0, 0, 46, 0, 0, 0,
+ 0, 0, 0, 47, 0, 0, 0, 0, 48, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 50, 51, 0, 0, 0, 52, 0, 0, 0, 0,
+ 53, 0, 54, 0, 0, 0, 0, 55, 0, 0,
+ 0, 56, 57, 58, 0, 0, 59, 0, 60, 61,
+ 0, 0, 62, 0, 0, 0, 0, 0, 0, 0,
+ 63, 64, 0, 65, 0, 66, 67, 68, 0, 0,
+ 69, 0, 0, 0, 0, 0, 0, 70, 0, 71,
+ 0, 0, 0, 0, 72, 0, 73, 74, 0, 0,
+ 0, 0, 0, 75, 76, 11, 0, 12, 16, 17,
+ 18, 19, 20, 21, 22, 23, 24, 0, 0, 25,
+ 0, 0, 0, 0, 26, 27, 28, 0, 29, 0,
+ 0, 0, 30, 0, 0, 0, 31, 0, 0, 0,
+ 32, 33, 0, 0, 0, 0, 233, 0, 35, 36,
+ 0, 0, 37, 38, 39, 40, 41, 42, 0, 0,
+ 0, 0, 0, 0, 0, 43, 0, 0, 44, 45,
+ 0, 0, 46, 0, 0, 0, 0, 0, 0, 47,
+ 0, 0, 0, 0, 48, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 50, 51, 0, 0,
+ 0, 52, 0, 0, 0, 0, 53, 0, 54, 0,
+ 0, 0, 0, 55, 0, 0, 0, 56, 57, 58,
+ 0, 0, 59, 0, 60, 61, 0, 0, 62, 0,
+ 0, 0, 0, 0, 0, 0, 63, 64, 0, 65,
+ 0, 66, 67, 68, 0, 0, 69, 0, 0, 0,
+ 0, 0, 0, 70, 0, 71, 0, 0, 0, 0,
+ 72, 0, 73, 74, 0, 0, 0, 0, 0, 75,
+ 76, 11, 0, 12, 16, 17, 18, 19, 20, 21,
+ 22, 23, 24, 0, 0, 25, 0, 0, 0, 0,
+ 26, 27, 0, 0, 29, 0, 0, 0, 30, 0,
+ 0, 0, 31, 0, 0, 0, 32, 33, 0, 0,
+ 0, 0, 233, 0, 35, 36, 0, 0, 37, 38,
+ 39, 40, 41, 42, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 44, 45, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 47, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 51, 0, 0, 0, 52, 0, 0,
+ 0, 0, 53, 0, 54, 0, 0, 0, 0, 55,
+ 0, 0, 0, 56, 57, 58, 0, 0, 59, 0,
+ 60, 61, 0, 0, 62, 0, 0, 0, 0, 0,
+ 0, 0, 63, 64, 0, 65, 0, 66, 67, 0,
+ 0, 0, 69, 0, 0, 0, 0, 0, 0, 70,
+ 0, 71, 0, 0, 0, 0, 0, 0, 73, 74,
+ 0, 0, 0, 0, 0, 75, 76, 11, 0, 12,
+ 16, 17, 18, 19, 20, 21, 22, 23, 24, 0,
+ 0, 25, 0, 0, 0, 0, 26, 27, 0, 0,
+ 29, 0, 0, 0, 30, 0, 0, 0, 31, 0,
+ 0, 0, 32, 33, 0, 0, 0, 0, 233, 0,
+ 35, 36, 0, 0, 37, 38, 39, 40, 41, 42,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 44, 45, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 47, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 51,
+ 0, 0, 0, 0, 0, 0, 0, 0, 53, 0,
+ 54, 0, 0, 0, 0, 55, 0, 0, 0, 56,
+ 57, 0, 0, 0, 0, 0, 60, 61, 0, 0,
+ 62, 0, 0, 0, 0, 0, 0, 0, 63, 64,
+ 0, 65, 0, 0, 0, 0, 423, 0, 69, 0,
+ 0, 0, 0, 0, 0, 70, 0, 71, 0, 0,
+ 0, 0, 0, 0, 73, 0, 0, 0, 0, 0,
+ 0, 75, 76, 11, 0, 12, 16, 17, 18, 19,
+ 20, 21, 22, 23, 24, 0, 0, 25, 0, 0,
+ 0, 0, 26, 27, 0, 0, 29, 0, 0, 0,
+ 30, 0, 0, 0, 31, 0, 0, 0, 32, 33,
+ 0, 0, 0, 0, 233, 0, 35, 36, 0, 0,
+ 37, 38, 39, 40, 41, 42, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 44, 45, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 47, 0, 0,
+ 16, 17, 18, 19, 20, 0, 0, 23, 24, 0,
+ 0, 0, 0, 0, 0, 51, 26, 628, 0, 0,
+ 0, 0, 0, 0, 53, 0, 54, 0, 31, 0,
+ 0, 55, 327, 0, 0, 56, 57, 0, 0, 0,
+ 35, 36, 60, 61, 0, 38, 62, 0, 41, 328,
+ 0, 0, 0, 0, 63, 64, 0, 65, 0, 0,
+ 44, 45, 0, 0, 69, 0, 0, 0, 0, 0,
+ 0, 70, 0, 71, 0, 0, 0, 0, 0, 0,
+ 73, 16, 197, 18, 19, 20, 0, 75, 76, 0,
+ 0, 0, 0, 0, 0, 16, 197, 18, 19, 20,
+ 54, 0, 23, 24, 0, 0, 0, 0, 0, 56,
+ 0, 26, 628, 327, 0, 0, 60, 61, 0, 0,
+ 329, 0, 0, 31, 0, 0, 38, 327, 63, 64,
+ 328, 65, 0, 629, 630, 35, 36, 0, 69, 0,
+ 38, 0, 0, 41, 328, 0, 0, 330, 0, 0,
+ 0, 0, 0, 0, 0, 44, 45, 0, 0, 0,
+ 0, 75, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 54, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 54, 0, 0, 0, 0,
+ 0, 329, 0, 0, 56, 0, 0, 0, 0, 0,
+ 64, 60, 61, 0, 0, 329, 0, 0, 0, 69,
+ 0, 0, 0, 63, 64, 0, 65, 0, 330, 0,
+ 0, 0, 0, 69, 0, 0, 0, 0, 0, 0,
+ 0, 0, 330
+};
+
+static const yytype_int16 yycheck[] =
+{
+ 30, 246, 53, 25, 51, 417, 30, 262, 263, 39,
+ 314, 62, 35, 321, 341, 190, 343, 311, 312, 4,
+ 687, 32, 416, 417, 36, 76, 3, 38, 5, 59,
+ 7, 42, 6, 7, 8, 32, 87, 37, 379, 347,
+ 37, 224, 225, 54, 29, 42, 52, 37, 37, 16,
+ 52, 62, 709, 50, 90, 593, 35, 95, 111, 400,
+ 71, 55, 317, 45, 476, 350, 20, 686, 353, 252,
+ 6, 7, 8, 49, 71, 383, 55, 128, 386, 364,
+ 70, 19, 476, 95, 37, 6, 7, 8, 37, 37,
+ 709, 732, 71, 338, 95, 79, 64, 98, 6, 7,
+ 37, 42, 165, 686, 94, 81, 37, 160, 92, 145,
+ 48, 65, 416, 417, 6, 7, 8, 9, 10, 87,
+ 37, 37, 104, 113, 765, 101, 709, 468, 166, 131,
+ 668, 23, 132, 70, 113, 163, 803, 159, 132, 314,
+ 7, 135, 193, 166, 133, 486, 38, 455, 456, 434,
+ 201, 157, 809, 143, 166, 132, 31, 94, 188, 51,
+ 190, 191, 129, 55, 215, 450, 95, 75, 144, 454,
+ 45, 222, 476, 458, 164, 42, 113, 796, 463, 120,
+ 133, 211, 229, 132, 132, 0, 237, 211, 102, 236,
+ 809, 221, 222, 167, 224, 225, 132, 221, 222, 184,
+ 44, 132, 253, 254, 387, 546, 143, 204, 144, 256,
+ 195, 132, 209, 796, 106, 132, 132, 214, 248, 249,
+ 128, 104, 252, 144, 248, 249, 809, 164, 95, 3,
+ 475, 5, 629, 630, 126, 69, 102, 166, 117, 83,
+ 59, 84, 134, 135, 656, 6, 7, 532, 127, 534,
+ 535, 559, 144, 3, 4, 5, 241, 512, 305, 244,
+ 7, 153, 656, 97, 107, 144, 313, 99, 42, 316,
+ 136, 441, 99, 670, 671, 560, 42, 27, 563, 139,
+ 140, 622, 623, 577, 314, 117, 469, 139, 140, 39,
+ 117, 124, 42, 6, 7, 8, 551, 344, 124, 65,
+ 545, 471, 557, 473, 113, 139, 140, 592, 95, 339,
+ 595, 566, 100, 146, 108, 339, 327, 328, 329, 330,
+ 146, 648, 649, 664, 26, 95, 28, 77, 155, 42,
+ 124, 361, 672, 673, 143, 365, 321, 148, 40, 41,
+ 3, 365, 5, 45, 652, 66, 67, 602, 6, 7,
+ 8, 3, 656, 5, 166, 610, 341, 387, 343, 6,
+ 7, 8, 347, 418, 419, 620, 116, 95, 52, 71,
+ 52, 95, 357, 6, 7, 8, 42, 95, 363, 6,
+ 7, 8, 690, 150, 639, 95, 416, 417, 418, 419,
+ 95, 676, 416, 417, 418, 419, 651, 52, 383, 582,
+ 95, 386, 104, 7, 15, 588, 37, 37, 110, 439,
+ 112, 441, 281, 282, 283, 439, 757, 441, 601, 760,
+ 675, 114, 763, 156, 86, 32, 767, 33, 769, 138,
+ 91, 36, 91, 73, 42, 95, 132, 7, 693, 469,
+ 104, 471, 95, 473, 95, 730, 476, 471, 104, 473,
+ 152, 706, 476, 95, 103, 52, 132, 149, 42, 714,
+ 162, 109, 6, 7, 8, 18, 18, 18, 7, 95,
+ 455, 456, 727, 95, 37, 132, 104, 462, 57, 23,
+ 104, 73, 98, 52, 18, 496, 497, 132, 132, 7,
+ 55, 7, 7, 748, 38, 750, 43, 132, 119, 95,
+ 132, 786, 43, 132, 95, 130, 593, 51, 43, 132,
+ 95, 55, 132, 130, 58, 73, 21, 772, 132, 26,
+ 132, 28, 777, 132, 779, 85, 781, 73, 21, 104,
+ 73, 776, 517, 40, 41, 154, 73, 792, 45, 127,
+ 795, 29, 629, 630, 541, 89, 113, 85, 131, 52,
+ 37, 734, 582, 808, 132, 132, 52, 42, 588, 127,
+ 52, 85, 106, 746, 71, 73, 749, 20, 118, 3,
+ 31, 601, 29, 37, 559, 758, 157, 132, 132, 626,
+ 56, 668, 126, 670, 671, 672, 673, 37, 60, 52,
+ 134, 135, 25, 20, 20, 43, 132, 104, 16, 629,
+ 630, 129, 18, 110, 35, 112, 100, 52, 52, 153,
+ 131, 52, 131, 125, 52, 37, 95, 75, 131, 85,
+ 20, 131, 9, 85, 619, 655, 656, 485, 624, 85,
+ 212, 655, 656, 668, 317, 809, 778, 796, 747, 423,
+ 670, 671, 672, 673, 695, 152, 803, 620, 800, 774,
+ 265, 264, 286, 292, 295, 162, 130, 122, 345, 710,
+ 298, 467, 61, 648, 649, 756, 581, 652, 710, 68,
+ 603, 419, 548, 72, 73, 74, 75, 76, 77, 78,
+ 222, 80, 361, 216, 287, 216, 47, -1, -1, 88,
+ -1, -1, -1, -1, 93, -1, -1, 96, -1, -1,
+ -1, -1, 732, -1, 734, 690, 105, -1, -1, -1,
+ -1, -1, 742, -1, -1, -1, 746, -1, 742, 749,
+ -1, -1, 121, -1, -1, 710, -1, -1, 758, -1,
+ -1, -1, -1, -1, -1, 765, -1, 3, -1, 5,
+ 6, 7, 8, 9, 10, 11, 12, 13, 14, -1,
+ -1, 17, -1, -1, -1, -1, 22, 23, 24, -1,
+ 26, 791, -1, -1, 30, -1, -1, 791, 34, -1,
+ 755, -1, 38, 39, -1, -1, -1, -1, 44, -1,
+ 46, 47, -1, -1, 50, 51, 52, 53, 54, 55,
+ -1, -1, -1, -1, -1, -1, -1, 63, -1, -1,
+ 66, 67, -1, -1, 70, -1, -1, -1, -1, -1,
+ -1, 77, -1, -1, -1, -1, 82, 83, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 94, 95,
+ -1, -1, -1, 99, -1, -1, -1, -1, 104, -1,
+ 106, -1, -1, -1, -1, 111, -1, -1, -1, 115,
+ 116, 117, -1, -1, 120, -1, 122, 123, -1, -1,
+ 126, -1, -1, -1, -1, -1, -1, -1, 134, 135,
+ -1, 137, -1, 139, 140, 141, -1, -1, 144, -1,
+ -1, -1, -1, -1, -1, 151, -1, 153, -1, -1,
+ -1, -1, 158, -1, 160, 161, -1, -1, -1, -1,
+ -1, 167, 168, 3, -1, 5, 6, 7, 8, 9,
+ 10, 11, 12, 13, 14, -1, -1, 17, -1, -1,
+ -1, -1, 22, 23, 24, -1, 26, -1, -1, -1,
+ 30, -1, -1, -1, 34, -1, -1, -1, 38, 39,
+ -1, -1, -1, -1, 44, -1, 46, 47, -1, -1,
+ 50, 51, 52, 53, 54, 55, -1, -1, -1, -1,
+ -1, -1, -1, 63, -1, -1, 66, 67, -1, -1,
+ 70, -1, -1, -1, -1, -1, -1, 77, -1, -1,
+ -1, -1, 82, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 94, 95, -1, -1, -1, 99,
+ -1, -1, -1, -1, 104, -1, 106, -1, -1, -1,
+ -1, 111, -1, -1, -1, 115, 116, 117, -1, -1,
+ 120, -1, 122, 123, -1, -1, 126, -1, -1, -1,
+ -1, -1, 132, -1, 134, 135, -1, 137, -1, 139,
+ 140, 141, -1, -1, 144, -1, -1, -1, -1, -1,
+ -1, 151, -1, 153, -1, -1, -1, -1, 158, -1,
+ 160, 161, -1, -1, -1, -1, -1, 167, 168, 3,
+ -1, 5, 6, 7, 8, 9, 10, 11, 12, 13,
+ 14, -1, -1, 17, -1, -1, -1, -1, 22, 23,
+ 24, -1, 26, -1, -1, -1, 30, -1, -1, -1,
+ 34, -1, -1, -1, 38, 39, -1, -1, -1, 43,
+ 44, -1, 46, 47, -1, -1, 50, 51, 52, 53,
+ 54, 55, -1, -1, -1, -1, -1, -1, -1, 63,
+ -1, -1, 66, 67, -1, -1, 70, -1, -1, -1,
+ -1, -1, -1, 77, -1, -1, -1, -1, 82, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 94, 95, -1, -1, -1, 99, -1, -1, -1, -1,
+ 104, -1, 106, -1, -1, -1, -1, 111, -1, -1,
+ -1, 115, 116, 117, -1, -1, 120, -1, 122, 123,
+ -1, -1, 126, -1, -1, -1, -1, -1, -1, -1,
+ 134, 135, -1, 137, -1, 139, 140, 141, -1, -1,
+ 144, -1, -1, -1, -1, -1, -1, 151, -1, 153,
+ -1, -1, -1, -1, 158, -1, 160, 161, -1, -1,
+ -1, -1, -1, 167, 168, 3, -1, 5, 6, 7,
+ 8, 9, 10, 11, 12, 13, 14, -1, -1, 17,
+ -1, -1, -1, -1, 22, 23, 24, -1, 26, -1,
+ -1, -1, 30, -1, -1, -1, 34, -1, -1, -1,
+ 38, 39, -1, -1, -1, -1, 44, -1, 46, 47,
+ -1, -1, 50, 51, 52, 53, 54, 55, -1, -1,
+ -1, -1, -1, -1, -1, 63, -1, -1, 66, 67,
+ -1, -1, 70, -1, -1, -1, -1, -1, -1, 77,
+ -1, -1, -1, -1, 82, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 94, 95, -1, -1,
+ -1, 99, -1, -1, -1, -1, 104, -1, 106, -1,
+ -1, -1, -1, 111, -1, -1, -1, 115, 116, 117,
+ -1, -1, 120, -1, 122, 123, -1, -1, 126, -1,
+ -1, -1, -1, -1, -1, -1, 134, 135, -1, 137,
+ -1, 139, 140, 141, -1, -1, 144, -1, -1, -1,
+ -1, -1, -1, 151, -1, 153, -1, -1, -1, -1,
+ 158, -1, 160, 161, -1, -1, -1, -1, -1, 167,
+ 168, 3, -1, 5, 6, 7, 8, 9, 10, 11,
+ 12, 13, 14, -1, -1, 17, -1, -1, -1, -1,
+ 22, 23, -1, -1, 26, -1, -1, -1, 30, -1,
+ -1, -1, 34, -1, -1, -1, 38, 39, -1, -1,
+ -1, -1, 44, -1, 46, 47, -1, -1, 50, 51,
+ 52, 53, 54, 55, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 66, 67, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 77, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 95, -1, -1, -1, 99, -1, -1,
+ -1, -1, 104, -1, 106, -1, -1, -1, -1, 111,
+ -1, -1, -1, 115, 116, 117, -1, -1, 120, -1,
+ 122, 123, -1, -1, 126, -1, -1, -1, -1, -1,
+ -1, -1, 134, 135, -1, 137, -1, 139, 140, -1,
+ -1, -1, 144, -1, -1, -1, -1, -1, -1, 151,
+ -1, 153, -1, -1, -1, -1, -1, -1, 160, 161,
+ -1, -1, -1, -1, -1, 167, 168, 3, -1, 5,
+ 6, 7, 8, 9, 10, 11, 12, 13, 14, -1,
+ -1, 17, -1, -1, -1, -1, 22, 23, -1, -1,
+ 26, -1, -1, -1, 30, -1, -1, -1, 34, -1,
+ -1, -1, 38, 39, -1, -1, -1, -1, 44, -1,
+ 46, 47, -1, -1, 50, 51, 52, 53, 54, 55,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 77, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 95,
+ -1, -1, -1, -1, -1, -1, -1, -1, 104, -1,
+ 106, -1, -1, -1, -1, 111, -1, -1, -1, 115,
+ 116, -1, -1, -1, -1, -1, 122, 123, -1, -1,
+ 126, -1, -1, -1, -1, -1, -1, -1, 134, 135,
+ -1, 137, -1, -1, -1, -1, 142, -1, 144, -1,
+ -1, -1, -1, -1, -1, 151, -1, 153, -1, -1,
+ -1, -1, -1, -1, 160, -1, -1, -1, -1, -1,
+ -1, 167, 168, 3, -1, 5, 6, 7, 8, 9,
+ 10, 11, 12, 13, 14, -1, -1, 17, -1, -1,
+ -1, -1, 22, 23, -1, -1, 26, -1, -1, -1,
+ 30, -1, -1, -1, 34, -1, -1, -1, 38, 39,
+ -1, -1, -1, -1, 44, -1, 46, 47, -1, -1,
+ 50, 51, 52, 53, 54, 55, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 66, 67, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 77, -1, -1,
+ 6, 7, 8, 9, 10, -1, -1, 13, 14, -1,
+ -1, -1, -1, -1, -1, 95, 22, 23, -1, -1,
+ -1, -1, -1, -1, 104, -1, 106, -1, 34, -1,
+ -1, 111, 38, -1, -1, 115, 116, -1, -1, -1,
+ 46, 47, 122, 123, -1, 51, 126, -1, 54, 55,
+ -1, -1, -1, -1, 134, 135, -1, 137, -1, -1,
+ 66, 67, -1, -1, 144, -1, -1, -1, -1, -1,
+ -1, 151, -1, 153, -1, -1, -1, -1, -1, -1,
+ 160, 6, 7, 8, 9, 10, -1, 167, 168, -1,
+ -1, -1, -1, -1, -1, 6, 7, 8, 9, 10,
+ 106, -1, 13, 14, -1, -1, -1, -1, -1, 115,
+ -1, 22, 23, 38, -1, -1, 122, 123, -1, -1,
+ 126, -1, -1, 34, -1, -1, 51, 38, 134, 135,
+ 55, 137, -1, 139, 140, 46, 47, -1, 144, -1,
+ 51, -1, -1, 54, 55, -1, -1, 153, -1, -1,
+ -1, -1, -1, -1, -1, 66, 67, -1, -1, -1,
+ -1, 167, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 106, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 106, -1, -1, -1, -1,
+ -1, 126, -1, -1, 115, -1, -1, -1, -1, -1,
+ 135, 122, 123, -1, -1, 126, -1, -1, -1, 144,
+ -1, -1, -1, 134, 135, -1, 137, -1, 153, -1,
+ -1, -1, -1, 144, -1, -1, -1, -1, -1, -1,
+ -1, -1, 153
+};
+
+/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
+ symbol of state STATE-NUM. */
+static const yytype_uint16 yystos[] =
+{
+ 0, 165, 170, 171, 163, 0, 102, 173, 174, 175,
+ 176, 3, 5, 404, 104, 176, 6, 7, 8, 9,
+ 10, 11, 12, 13, 14, 17, 22, 23, 24, 26,
+ 30, 34, 38, 39, 44, 46, 47, 50, 51, 52,
+ 53, 54, 55, 63, 66, 67, 70, 77, 82, 83,
+ 94, 95, 99, 104, 106, 111, 115, 116, 117, 120,
+ 122, 123, 126, 134, 135, 137, 139, 140, 141, 144,
+ 151, 153, 158, 160, 161, 167, 168, 177, 183, 184,
+ 186, 187, 189, 190, 191, 192, 193, 194, 195, 197,
+ 200, 201, 202, 204, 208, 211, 213, 219, 225, 226,
+ 227, 232, 233, 240, 253, 254, 260, 267, 276, 277,
+ 278, 279, 280, 281, 283, 285, 286, 289, 290, 291,
+ 292, 293, 294, 295, 296, 298, 300, 302, 303, 304,
+ 306, 307, 309, 310, 311, 322, 323, 324, 327, 328,
+ 329, 331, 332, 333, 334, 335, 336, 337, 338, 339,
+ 340, 342, 343, 344, 345, 347, 348, 349, 358, 359,
+ 360, 361, 362, 365, 366, 367, 368, 375, 382, 383,
+ 384, 386, 387, 388, 389, 390, 391, 392, 394, 397,
+ 399, 400, 404, 405, 59, 172, 7, 44, 100, 229,
+ 330, 95, 166, 364, 395, 95, 404, 7, 397, 405,
+ 95, 364, 395, 148, 26, 28, 40, 41, 45, 71,
+ 104, 110, 112, 152, 162, 364, 95, 395, 7, 341,
+ 405, 95, 364, 395, 52, 52, 6, 7, 401, 95,
+ 102, 136, 364, 44, 132, 225, 42, 218, 395, 150,
+ 7, 402, 405, 7, 95, 218, 374, 395, 95, 95,
+ 310, 310, 52, 312, 364, 395, 95, 90, 145, 7,
+ 218, 218, 37, 37, 114, 15, 61, 68, 72, 73,
+ 74, 75, 76, 77, 78, 80, 88, 93, 96, 105,
+ 121, 297, 299, 301, 99, 117, 155, 282, 49, 81,
+ 101, 144, 284, 25, 159, 287, 64, 87, 288, 86,
+ 156, 32, 33, 293, 218, 42, 305, 307, 69, 97,
+ 139, 140, 321, 91, 325, 36, 91, 95, 404, 138,
+ 185, 73, 104, 7, 231, 405, 95, 38, 55, 126,
+ 153, 333, 7, 132, 144, 396, 405, 218, 369, 370,
+ 373, 218, 356, 404, 42, 95, 218, 364, 124, 146,
+ 188, 124, 146, 212, 108, 124, 198, 35, 55, 71,
+ 113, 364, 7, 397, 194, 103, 181, 182, 364, 218,
+ 385, 392, 394, 144, 397, 372, 373, 397, 341, 341,
+ 350, 225, 104, 205, 45, 104, 203, 52, 104, 132,
+ 225, 218, 149, 308, 404, 7, 404, 305, 397, 397,
+ 341, 218, 218, 225, 227, 227, 278, 279, 280, 280,
+ 280, 281, 283, 285, 286, 289, 109, 18, 18, 18,
+ 43, 225, 311, 142, 311, 225, 23, 326, 333, 389,
+ 225, 226, 227, 346, 403, 404, 7, 314, 315, 37,
+ 132, 37, 132, 305, 397, 356, 132, 356, 225, 314,
+ 403, 185, 185, 37, 404, 104, 104, 57, 196, 7,
+ 399, 405, 73, 404, 185, 397, 98, 95, 317, 52,
+ 132, 37, 132, 37, 132, 363, 18, 377, 377, 353,
+ 132, 7, 403, 55, 7, 403, 341, 7, 43, 119,
+ 132, 132, 132, 132, 377, 132, 58, 89, 378, 380,
+ 381, 382, 389, 397, 378, 376, 381, 376, 43, 113,
+ 143, 246, 252, 130, 130, 132, 185, 73, 132, 157,
+ 316, 318, 319, 397, 398, 398, 371, 43, 132, 185,
+ 84, 107, 199, 185, 403, 403, 79, 92, 185, 95,
+ 3, 403, 185, 95, 316, 377, 341, 398, 398, 305,
+ 378, 85, 21, 239, 351, 354, 401, 154, 73, 21,
+ 206, 104, 73, 206, 377, 73, 85, 268, 395, 395,
+ 117, 127, 144, 379, 127, 29, 113, 131, 227, 247,
+ 248, 37, 52, 132, 132, 185, 185, 185, 52, 215,
+ 216, 42, 364, 178, 132, 305, 377, 127, 393, 393,
+ 227, 52, 85, 118, 73, 227, 207, 403, 185, 185,
+ 20, 3, 227, 31, 269, 29, 311, 19, 48, 249,
+ 37, 318, 341, 341, 37, 132, 313, 185, 23, 139,
+ 140, 220, 221, 222, 223, 224, 322, 345, 185, 20,
+ 65, 209, 132, 132, 261, 341, 227, 353, 16, 129,
+ 355, 56, 37, 227, 255, 52, 273, 60, 196, 250,
+ 248, 377, 377, 216, 214, 225, 223, 223, 25, 179,
+ 139, 140, 139, 140, 227, 20, 210, 262, 234, 75,
+ 128, 352, 356, 356, 227, 403, 241, 256, 397, 378,
+ 35, 166, 251, 20, 320, 377, 43, 221, 132, 223,
+ 223, 224, 224, 227, 185, 37, 133, 263, 266, 235,
+ 357, 16, 129, 37, 164, 233, 240, 242, 244, 245,
+ 246, 37, 257, 266, 18, 270, 403, 35, 227, 65,
+ 217, 218, 100, 228, 52, 227, 37, 233, 236, 240,
+ 244, 4, 27, 218, 348, 404, 52, 227, 131, 52,
+ 131, 227, 185, 230, 231, 125, 180, 341, 52, 397,
+ 341, 245, 227, 341, 227, 37, 404, 317, 377, 341,
+ 75, 377, 131, 377, 271, 231, 377, 85, 377, 20,
+ 227, 85, 45, 269, 272, 274, 305, 227, 239, 227,
+ 227, 52, 131, 185, 264, 85, 243, 258, 397, 227,
+ 265, 227, 242, 259, 275, 263, 237, 257, 131, 238,
+ 227, 236
+};
+
+#define yyerrok (yyerrstatus = 0)
+#define yyclearin (yychar = YYEMPTY)
+#define YYEMPTY (-2)
+#define YYEOF 0
+
+#define YYACCEPT goto yyacceptlab
+#define YYABORT goto yyabortlab
+#define YYERROR goto yyerrorlab
+
+
+/* Like YYERROR except do call yyerror. This remains here temporarily
+ to ease the transition to the new meaning of YYERROR, for GCC.
+ Once GCC version 2 has supplanted version 1, this can go. */
+
+#define YYFAIL goto yyerrlab
+
+#define YYRECOVERING() (!!yyerrstatus)
+
+#define YYBACKUP(Token, Value) \
+do \
+ if (yychar == YYEMPTY && yylen == 1) \
+ { \
+ yychar = (Token); \
+ yylval = (Value); \
+ yytoken = YYTRANSLATE (yychar); \
+ YYPOPSTACK (1); \
+ goto yybackup; \
+ } \
+ else \
+ { \
+ yyerror (&yylloc, parseInfo, YY_("syntax error: cannot back up")); \
+ YYERROR; \
+ } \
+while (YYID (0))
+
+
+#define YYTERROR 1
+#define YYERRCODE 256
+
+
+/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
+ If N is 0, then set CURRENT to the empty location which ends
+ the previous symbol: RHS[0] (always defined). */
+
+#define YYRHSLOC(Rhs, K) ((Rhs)[K])
+#ifndef YYLLOC_DEFAULT
+# define YYLLOC_DEFAULT(Current, Rhs, N) \
+ do \
+ if (YYID (N)) \
+ { \
+ (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
+ (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
+ (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
+ (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
+ } \
+ else \
+ { \
+ (Current).first_line = (Current).last_line = \
+ YYRHSLOC (Rhs, 0).last_line; \
+ (Current).first_column = (Current).last_column = \
+ YYRHSLOC (Rhs, 0).last_column; \
+ } \
+ while (YYID (0))
+#endif
+
+
+/* YY_LOCATION_PRINT -- Print the location on the stream.
+ This macro was not mandated originally: define only if we know
+ we won't break user code: when these are the locations we know. */
+
+#ifndef YY_LOCATION_PRINT
+# if YYLTYPE_IS_TRIVIAL
+# define YY_LOCATION_PRINT(File, Loc) \
+ fprintf (File, "%d.%d-%d.%d", \
+ (Loc).first_line, (Loc).first_column, \
+ (Loc).last_line, (Loc).last_column)
+# else
+# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+# endif
+#endif
+
+
+/* YYLEX -- calling `yylex' with the right arguments. */
+
+#ifdef YYLEX_PARAM
+# define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
+#else
+# define YYLEX yylex (&yylval, &yylloc, parseInfo)
+#endif
+
+/* Enable debugging if requested. */
+#if YYDEBUG
+
+# ifndef YYFPRINTF
+# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+# define YYFPRINTF fprintf
+# endif
+
+# define YYDPRINTF(Args) \
+do { \
+ if (yydebug) \
+ YYFPRINTF Args; \
+} while (YYID (0))
+
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
+do { \
+ if (yydebug) \
+ { \
+ YYFPRINTF (stderr, "%s ", Title); \
+ yy_symbol_print (stderr, \
+ Type, Value, Location, parseInfo); \
+ YYFPRINTF (stderr, "\n"); \
+ } \
+} while (YYID (0))
+
+
+/*--------------------------------.
+| Print this symbol on YYOUTPUT. |
+`--------------------------------*/
+
+/*ARGSUSED*/
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+static void
+yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, ParserContext *const parseInfo)
+#else
+static void
+yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, parseInfo)
+ FILE *yyoutput;
+ int yytype;
+ YYSTYPE const * const yyvaluep;
+ YYLTYPE const * const yylocationp;
+ ParserContext *const parseInfo;
+#endif
+{
+ if (!yyvaluep)
+ return;
+ YYUSE (yylocationp);
+ YYUSE (parseInfo);
+# ifdef YYPRINT
+ if (yytype < YYNTOKENS)
+ YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+# else
+ YYUSE (yyoutput);
+# endif
+ switch (yytype)
+ {
+ default:
+ break;
+ }
+}
+
+
+/*--------------------------------.
+| Print this symbol on YYOUTPUT. |
+`--------------------------------*/
+
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+static void
+yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, ParserContext *const parseInfo)
+#else
+static void
+yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp, parseInfo)
+ FILE *yyoutput;
+ int yytype;
+ YYSTYPE const * const yyvaluep;
+ YYLTYPE const * const yylocationp;
+ ParserContext *const parseInfo;
+#endif
+{
+ if (yytype < YYNTOKENS)
+ YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
+ else
+ YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
+
+ YY_LOCATION_PRINT (yyoutput, *yylocationp);
+ YYFPRINTF (yyoutput, ": ");
+ yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, parseInfo);
+ YYFPRINTF (yyoutput, ")");
+}
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (included). |
+`------------------------------------------------------------------*/
+
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+static void
+yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
+#else
+static void
+yy_stack_print (yybottom, yytop)
+ yytype_int16 *yybottom;
+ yytype_int16 *yytop;
+#endif
+{
+ YYFPRINTF (stderr, "Stack now");
+ for (; yybottom <= yytop; yybottom++)
+ {
+ int yybot = *yybottom;
+ YYFPRINTF (stderr, " %d", yybot);
+ }
+ YYFPRINTF (stderr, "\n");
+}
+
+# define YY_STACK_PRINT(Bottom, Top) \
+do { \
+ if (yydebug) \
+ yy_stack_print ((Bottom), (Top)); \
+} while (YYID (0))
+
+
+/*------------------------------------------------.
+| Report that the YYRULE is going to be reduced. |
+`------------------------------------------------*/
+
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+static void
+yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, ParserContext *const parseInfo)
+#else
+static void
+yy_reduce_print (yyvsp, yylsp, yyrule, parseInfo)
+ YYSTYPE *yyvsp;
+ YYLTYPE *yylsp;
+ int yyrule;
+ ParserContext *const parseInfo;
+#endif
+{
+ int yynrhs = yyr2[yyrule];
+ int yyi;
+ unsigned long int yylno = yyrline[yyrule];
+ YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
+ yyrule - 1, yylno);
+ /* The symbols being reduced. */
+ for (yyi = 0; yyi < yynrhs; yyi++)
+ {
+ fprintf (stderr, " $%d = ", yyi + 1);
+ yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
+ &(yyvsp[(yyi + 1) - (yynrhs)])
+ , &(yylsp[(yyi + 1) - (yynrhs)]) , parseInfo);
+ fprintf (stderr, "\n");
+ }
+}
+
+# define YY_REDUCE_PRINT(Rule) \
+do { \
+ if (yydebug) \
+ yy_reduce_print (yyvsp, yylsp, Rule, parseInfo); \
+} while (YYID (0))
+
+/* Nonzero means print parse trace. It is left uninitialized so that
+ multiple parsers can coexist. */
+int yydebug;
+#else /* !YYDEBUG */
+# define YYDPRINTF(Args)
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
+# define YY_STACK_PRINT(Bottom, Top)
+# define YY_REDUCE_PRINT(Rule)
+#endif /* !YYDEBUG */
+
+
+/* YYINITDEPTH -- initial size of the parser's stacks. */
+#ifndef YYINITDEPTH
+# define YYINITDEPTH 200
+#endif
+
+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
+ if the built-in stack extension method is used).
+
+ Do not make this value too large; the results are undefined if
+ YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
+ evaluated with infinite-precision integer arithmetic. */
+
+#ifndef YYMAXDEPTH
+# define YYMAXDEPTH 10000
+#endif
+
+
+
+#if YYERROR_VERBOSE
+
+# ifndef yystrlen
+# if defined __GLIBC__ && defined _STRING_H
+# define yystrlen strlen
+# else
+/* Return the length of YYSTR. */
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+static YYSIZE_T
+yystrlen (const char *yystr)
+#else
+static YYSIZE_T
+yystrlen (yystr)
+ const char *yystr;
+#endif
+{
+ YYSIZE_T yylen;
+ for (yylen = 0; yystr[yylen]; yylen++)
+ continue;
+ return yylen;
+}
+# endif
+# endif
+
+# ifndef yystpcpy
+# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
+# define yystpcpy stpcpy
+# else
+/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+ YYDEST. */
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+static char *
+yystpcpy (char *yydest, const char *yysrc)
+#else
+static char *
+yystpcpy (yydest, yysrc)
+ char *yydest;
+ const char *yysrc;
+#endif
+{
+ char *yyd = yydest;
+ const char *yys = yysrc;
+
+ while ((*yyd++ = *yys++) != '\0')
+ continue;
+
+ return yyd - 1;
+}
+# endif
+# endif
+
+# ifndef yytnamerr
+/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
+ quotes and backslashes, so that it's suitable for yyerror. The
+ heuristic is that double-quoting is unnecessary unless the string
+ contains an apostrophe, a comma, or backslash (other than
+ backslash-backslash). YYSTR is taken from yytname. If YYRES is
+ null, do not copy; instead, return the length of what the result
+ would have been. */
+static YYSIZE_T
+yytnamerr (char *yyres, const char *yystr)
+{
+ if (*yystr == '"')
+ {
+ YYSIZE_T yyn = 0;
+ char const *yyp = yystr;
+
+ for (;;)
+ switch (*++yyp)
+ {
+ case '\'':
+ case ',':
+ goto do_not_strip_quotes;
+
+ case '\\':
+ if (*++yyp != '\\')
+ goto do_not_strip_quotes;
+ /* Fall through. */
+ default:
+ if (yyres)
+ yyres[yyn] = *yyp;
+ yyn++;
+ break;
+
+ case '"':
+ if (yyres)
+ yyres[yyn] = '\0';
+ return yyn;
+ }
+ do_not_strip_quotes: ;
+ }
+
+ if (! yyres)
+ return yystrlen (yystr);
+
+ return yystpcpy (yyres, yystr) - yyres;
+}
+# endif
+
+/* Copy into YYRESULT an error message about the unexpected token
+ YYCHAR while in state YYSTATE. Return the number of bytes copied,
+ including the terminating null byte. If YYRESULT is null, do not
+ copy anything; just return the number of bytes that would be
+ copied. As a special case, return 0 if an ordinary "syntax error"
+ message will do. Return YYSIZE_MAXIMUM if overflow occurs during
+ size calculation. */
+static YYSIZE_T
+yysyntax_error (char *yyresult, int yystate, int yychar)
+{
+ int yyn = yypact[yystate];
+
+ if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
+ return 0;
+ else
+ {
+ int yytype = YYTRANSLATE (yychar);
+ YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
+ YYSIZE_T yysize = yysize0;
+ YYSIZE_T yysize1;
+ int yysize_overflow = 0;
+ enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+ char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+ int yyx;
+
+# if 0
+ /* This is so xgettext sees the translatable formats that are
+ constructed on the fly. */
+ YY_("syntax error, unexpected %s");
+ YY_("syntax error, unexpected %s, expecting %s");
+ YY_("syntax error, unexpected %s, expecting %s or %s");
+ YY_("syntax error, unexpected %s, expecting %s or %s or %s");
+ YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
+# endif
+ char *yyfmt;
+ char const *yyf;
+ static char const yyunexpected[] = "syntax error, unexpected %s";
+ static char const yyexpecting[] = ", expecting %s";
+ static char const yyor[] = " or %s";
+ char yyformat[sizeof yyunexpected
+ + sizeof yyexpecting - 1
+ + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
+ * (sizeof yyor - 1))];
+ char const *yyprefix = yyexpecting;
+
+ /* Start YYX at -YYN if negative to avoid negative indexes in
+ YYCHECK. */
+ int yyxbegin = yyn < 0 ? -yyn : 0;
+
+ /* Stay within bounds of both yycheck and yytname. */
+ int yychecklim = YYLAST - yyn + 1;
+ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+ int yycount = 1;
+
+ yyarg[0] = yytname[yytype];
+ yyfmt = yystpcpy (yyformat, yyunexpected);
+
+ for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+ if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
+ {
+ if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+ {
+ yycount = 1;
+ yysize = yysize0;
+ yyformat[sizeof yyunexpected - 1] = '\0';
+ break;
+ }
+ yyarg[yycount++] = yytname[yyx];
+ yysize1 = yysize + yytnamerr (0, yytname[yyx]);
+ yysize_overflow |= (yysize1 < yysize);
+ yysize = yysize1;
+ yyfmt = yystpcpy (yyfmt, yyprefix);
+ yyprefix = yyor;
+ }
+
+ yyf = YY_(yyformat);
+ yysize1 = yysize + yystrlen (yyf);
+ yysize_overflow |= (yysize1 < yysize);
+ yysize = yysize1;
+
+ if (yysize_overflow)
+ return YYSIZE_MAXIMUM;
+
+ if (yyresult)
+ {
+ /* Avoid sprintf, as that infringes on the user's name space.
+ Don't have undefined behavior even if the translation
+ produced a string with the wrong number of "%s"s. */
+ char *yyp = yyresult;
+ int yyi = 0;
+ while ((*yyp = *yyf) != '\0')
+ {
+ if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
+ {
+ yyp += yytnamerr (yyp, yyarg[yyi++]);
+ yyf += 2;
+ }
+ else
+ {
+ yyp++;
+ yyf++;
+ }
+ }
+ }
+ return yysize;
+ }
+}
+#endif /* YYERROR_VERBOSE */
+
+
+/*-----------------------------------------------.
+| Release the memory associated to this symbol. |
+`-----------------------------------------------*/
+
+/*ARGSUSED*/
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+static void
+yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, ParserContext *const parseInfo)
+#else
+static void
+yydestruct (yymsg, yytype, yyvaluep, yylocationp, parseInfo)
+ const char *yymsg;
+ int yytype;
+ YYSTYPE *yyvaluep;
+ YYLTYPE *yylocationp;
+ ParserContext *const parseInfo;
+#endif
+{
+ YYUSE (yyvaluep);
+ YYUSE (yylocationp);
+ YYUSE (parseInfo);
+
+ if (!yymsg)
+ yymsg = "Deleting";
+ YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
+
+ switch (yytype)
+ {
+
+ default:
+ break;
+ }
+}
+
+
+/* Prevent warnings from -Wmissing-prototypes. */
+
+#ifdef YYPARSE_PARAM
+#if defined __STDC__ || defined __cplusplus
+int yyparse (void *YYPARSE_PARAM);
+#else
+int yyparse ();
+#endif
+#else /* ! YYPARSE_PARAM */
+#if defined __STDC__ || defined __cplusplus
+int yyparse (ParserContext *const parseInfo);
+#else
+int yyparse ();
+#endif
+#endif /* ! YYPARSE_PARAM */
+
+
+
+
+
+
+/*----------.
+| yyparse. |
+`----------*/
+
+#ifdef YYPARSE_PARAM
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+int
+yyparse (void *YYPARSE_PARAM)
+#else
+int
+yyparse (YYPARSE_PARAM)
+ void *YYPARSE_PARAM;
+#endif
+#else /* ! YYPARSE_PARAM */
+#if (defined __STDC__ || defined __C99__FUNC__ \
+ || defined __cplusplus || defined _MSC_VER)
+int
+yyparse (ParserContext *const parseInfo)
+#else
+int
+yyparse (parseInfo)
+ ParserContext *const parseInfo;
+#endif
+#endif
+{
+ /* The lookahead symbol. */
+int yychar;
+
+/* The semantic value of the lookahead symbol. */
+YYSTYPE yylval;
+
+/* Number of syntax errors so far. */
+int yynerrs;
+/* Location data for the lookahead symbol. */
+YYLTYPE yylloc;
+
+ int yystate;
+ int yyn;
+ int yyresult;
+ /* Number of tokens to shift before error messages enabled. */
+ int yyerrstatus;
+ /* Lookahead token as an internal (translated) token number. */
+ int yytoken = 0;
+#if YYERROR_VERBOSE
+ /* Buffer for error messages, and its allocated size. */
+ char yymsgbuf[128];
+ char *yymsg = yymsgbuf;
+ YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
+#endif
+
+ /* Three stacks and their tools:
+ `yyss': related to states,
+ `yyvs': related to semantic values,
+ `yyls': related to locations.
+
+ Refer to the stacks thru separate pointers, to allow yyoverflow
+ to reallocate them elsewhere. */
+
+ /* The state stack. */
+ yytype_int16 yyssa[YYINITDEPTH];
+ yytype_int16 *yyss = yyssa;
+ yytype_int16 *yyssp;
+
+ /* The semantic value stack. */
+ YYSTYPE yyvsa[YYINITDEPTH];
+ YYSTYPE *yyvs = yyvsa;
+ YYSTYPE *yyvsp;
+
+ /* The location stack. */
+ YYLTYPE yylsa[YYINITDEPTH];
+ YYLTYPE *yyls = yylsa;
+ YYLTYPE *yylsp;
+ /* The locations where the error started and ended. */
+ YYLTYPE yyerror_range[2];
+
+#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
+
+ YYSIZE_T yystacksize = YYINITDEPTH;
+
+ /* The variables used to return semantic value and location from the
+ action routines. */
+ YYSTYPE yyval;
+ YYLTYPE yyloc;
+
+ /* The number of symbols on the RHS of the reduced rule.
+ Keep to zero when no symbol should be popped. */
+ int yylen = 0;
+
+ YYDPRINTF ((stderr, "Starting parse\n"));
+
+ yystate = 0;
+ yyerrstatus = 0;
+ yynerrs = 0;
+ yychar = YYEMPTY; /* Cause a token to be read. */
+
+ /* Initialize stack pointers.
+ Waste one element of value and location stack
+ so that they stay on the same level as the state stack.
+ The wasted elements are never initialized. */
+
+ yyssp = yyss;
+ yyvsp = yyvs;
+ yylsp = yyls;
+#if YYLTYPE_IS_TRIVIAL
+ /* Initialize the default location before parsing starts. */
+ yylloc.first_line = yylloc.last_line = 1;
+ yylloc.first_column = yylloc.last_column = 1;
+#endif
+
+ goto yysetstate;
+
+/*------------------------------------------------------------.
+| yynewstate -- Push a new state, which is found in yystate. |
+`------------------------------------------------------------*/
+ yynewstate:
+ /* In all cases, when you get here, the value and location stacks
+ have just been pushed. So pushing a state here evens the stacks. */
+ yyssp++;
+
+ yysetstate:
+ *yyssp = yystate;
+
+ if (yyss + yystacksize - 1 <= yyssp)
+ {
+ /* Get the current used size of the three stacks, in elements. */
+ YYSIZE_T yysize = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+ {
+ /* Give user a chance to reallocate the stack. Use copies of
+ these so that the &'s don't force the real ones into
+ memory. */
+ YYSTYPE *yyvs1 = yyvs;
+ yytype_int16 *yyss1 = yyss;
+ YYLTYPE *yyls1 = yyls;
+
+ /* Each stack pointer address is followed by the size of the
+ data in use in that stack, in bytes. This used to be a
+ conditional around just the two extra args, but that might
+ be undefined if yyoverflow is a macro. */
+ yyoverflow (YY_("memory exhausted"),
+ &yyss1, yysize * sizeof (*yyssp),
+ &yyvs1, yysize * sizeof (*yyvsp),
+ &yyls1, yysize * sizeof (*yylsp),
+ &yystacksize);
+ yyls = yyls1;
+ yyss = yyss1;
+ yyvs = yyvs1;
+ }
+#else /* no yyoverflow */
+# ifndef YYSTACK_RELOCATE
+ goto yyexhaustedlab;
+# else
+ /* Extend the stack our own way. */
+ if (YYMAXDEPTH <= yystacksize)
+ goto yyexhaustedlab;
+ yystacksize *= 2;
+ if (YYMAXDEPTH < yystacksize)
+ yystacksize = YYMAXDEPTH;
+
+ {
+ yytype_int16 *yyss1 = yyss;
+ union yyalloc *yyptr =
+ (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
+ if (! yyptr)
+ goto yyexhaustedlab;
+ YYSTACK_RELOCATE (yyss);
+ YYSTACK_RELOCATE (yyvs);
+ YYSTACK_RELOCATE (yyls);
+# undef YYSTACK_RELOCATE
+ if (yyss1 != yyssa)
+ YYSTACK_FREE (yyss1);
+ }
+# endif
+#endif /* no yyoverflow */
+
+ yyssp = yyss + yysize - 1;
+ yyvsp = yyvs + yysize - 1;
+ yylsp = yyls + yysize - 1;
+
+ YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+ (unsigned long int) yystacksize));
+
+ if (yyss + yystacksize - 1 <= yyssp)
+ YYABORT;
+ }
+
+ YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+
+ if (yystate == YYFINAL)
+ YYACCEPT;
+
+ goto yybackup;
+
+/*-----------.
+| yybackup. |
+`-----------*/
+yybackup:
+
+ /* Do appropriate processing given the current state. Read a
+ lookahead token if we need one and don't already have one. */
+
+ /* First try to decide what to do without reference to lookahead token. */
+ yyn = yypact[yystate];
+ if (yyn == YYPACT_NINF)
+ goto yydefault;
+
+ /* Not known => get a lookahead token if don't already have one. */
+
+ /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
+ if (yychar == YYEMPTY)
+ {
+ YYDPRINTF ((stderr, "Reading a token: "));
+ yychar = YYLEX;
+ }
+
+ if (yychar <= YYEOF)
+ {
+ yychar = yytoken = YYEOF;
+ YYDPRINTF ((stderr, "Now at end of input.\n"));
+ }
+ else
+ {
+ yytoken = YYTRANSLATE (yychar);
+ YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
+ }
+
+ /* If the proper action on seeing token YYTOKEN is to reduce or to
+ detect an error, take that action. */
+ yyn += yytoken;
+ if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
+ goto yydefault;
+ yyn = yytable[yyn];
+ if (yyn <= 0)
+ {
+ if (yyn == 0 || yyn == YYTABLE_NINF)
+ goto yyerrlab;
+ yyn = -yyn;
+ goto yyreduce;
+ }
+
+ /* Count tokens shifted since error; after three, turn off error
+ status. */
+ if (yyerrstatus)
+ yyerrstatus--;
+
+ /* Shift the lookahead token. */
+ YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
+
+ /* Discard the shifted token. */
+ yychar = YYEMPTY;
+
+ yystate = yyn;
+ *++yyvsp = yylval;
+ *++yylsp = yylloc;
+ goto yynewstate;
+
+
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state. |
+`-----------------------------------------------------------*/
+yydefault:
+ yyn = yydefact[yystate];
+ if (yyn == 0)
+ goto yyerrlab;
+ goto yyreduce;
+
+
+/*-----------------------------.
+| yyreduce -- Do a reduction. |
+`-----------------------------*/
+yyreduce:
+ /* yyn is the number of a rule to reduce with. */
+ yylen = yyr2[yyn];
+
+ /* If YYLEN is nonzero, implement the default value of the action:
+ `$$ = $1'.
+
+ Otherwise, the following line sets YYVAL to garbage.
+ This behavior is undocumented and Bison
+ users should not rely upon it. Assigning to YYVAL
+ unconditionally makes the parser a bit smaller, and it avoids a
+ GCC warning that YYVAL may be used uninitialized. */
+ yyval = yyvsp[1-yylen];
+
+ /* Default location. */
+ YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
+ YY_REDUCE_PRINT (yyn);
+ switch (yyn)
+ {
+ case 5:
+/* Line 1269 of yacc.c. */
+#line 1346 "querytransformparser.ypp"
+ {
+
+/* 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((yyvsp[(3) - (5)].sval) != QLatin1String("1.0"))
+ {
+ const ReflectYYLTYPE ryy((yyloc), parseInfo);
+
+ parseInfo->staticContext->error(QtXmlPatterns::tr("Version %1 is not supported. The supported "
+ "XQuery version is 1.0.")
+ .arg(formatData((yyvsp[(3) - (5)].sval))),
+ ReportContext::XQST0031, &ryy);
+ }
+ }
+ break;
+
+ case 7:
+/* Line 1269 of yacc.c. */
+#line 1378 "querytransformparser.ypp"
+ {
+ const QRegExp encNameRegExp(QLatin1String("[A-Za-z][A-Za-z0-9._\\-]*"));
+
+ if(!encNameRegExp.exactMatch((yyvsp[(2) - (2)].sval)))
+ {
+ 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((yyloc), parseInfo));
+ }
+ }
+ break;
+
+ case 8:
+/* Line 1269 of yacc.c. */
+#line 1394 "querytransformparser.ypp"
+ {
+ /* 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(), (yyloc), 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((yyloc), 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()),
+ (yyloc), parseInfo);
+ parseInfo->templateCalls.append(parseInfo->queryBody);
+ /* We just discard the template body that XSLTTokenizer generated. */
+ }
+ else
+ parseInfo->queryBody = (yyvsp[(2) - (2)].expr);
+ }
+ break;
+
+ case 10:
+/* Line 1269 of yacc.c. */
+#line 1494 "querytransformparser.ypp"
+ {
+ // TODO add to namespace context
+ parseInfo->moduleNamespace = parseInfo->staticContext->namePool()->allocateNamespace((yyvsp[(3) - (6)].sval));
+ }
+ break;
+
+ case 12:
+/* Line 1269 of yacc.c. */
+#line 1502 "querytransformparser.ypp"
+ {
+ disallowedConstruct(parseInfo, (yyloc));
+ if(parseInfo->hasSecondPrologPart)
+ parseInfo->staticContext->error(QtXmlPatterns::tr("A default namespace declaration must occur before function, "
+ "variable, and option declarations."), ReportContext::XPST0003, fromYYLTYPE((yyloc), parseInfo));
+ }
+ break;
+
+ case 13:
+/* Line 1269 of yacc.c. */
+#line 1509 "querytransformparser.ypp"
+ {
+ if(parseInfo->hasSecondPrologPart)
+ parseInfo->staticContext->error(QtXmlPatterns::tr("A default namespace declaration must occur before function, "
+ "variable, and option declarations."), ReportContext::XPST0003, fromYYLTYPE((yyloc), parseInfo));
+ }
+ break;
+
+ case 14:
+/* Line 1269 of yacc.c. */
+#line 1515 "querytransformparser.ypp"
+ {
+ if(parseInfo->hasSecondPrologPart)
+ parseInfo->staticContext->error(QtXmlPatterns::tr("Namespace declarations must occur before function, "
+ "variable, and option declarations."), ReportContext::XPST0003, fromYYLTYPE((yyloc), parseInfo));
+ }
+ break;
+
+ case 15:
+/* Line 1269 of yacc.c. */
+#line 1521 "querytransformparser.ypp"
+ {
+ disallowedConstruct(parseInfo, (yyloc));
+ if(parseInfo->hasSecondPrologPart)
+ parseInfo->staticContext->error(QtXmlPatterns::tr("Module imports must occur before function, "
+ "variable, and option declarations."), ReportContext::XPST0003, fromYYLTYPE((yyloc), parseInfo));
+ }
+ break;
+
+ case 17:
+/* Line 1269 of yacc.c. */
+#line 1531 "querytransformparser.ypp"
+ {
+ parseInfo->hasSecondPrologPart = true;
+ }
+ break;
+
+ case 18:
+/* Line 1269 of yacc.c. */
+#line 1535 "querytransformparser.ypp"
+ {
+ parseInfo->hasSecondPrologPart = true;
+ }
+ break;
+
+ case 19:
+/* Line 1269 of yacc.c. */
+#line 1539 "querytransformparser.ypp"
+ {
+ disallowedConstruct(parseInfo, (yyloc));
+ parseInfo->hasSecondPrologPart = true;
+ }
+ break;
+
+ case 20:
+/* Line 1269 of yacc.c. */
+#line 1562 "querytransformparser.ypp"
+ {
+ Template::Ptr temp(create(new Template(parseInfo->currentImportPrecedence, (yyvsp[(5) - (7)].sequenceType)), (yyloc), parseInfo));
+
+ registerNamedTemplate((yyvsp[(3) - (7)].qName), typeCheckTemplateBody((yyvsp[(6) - (7)].expr), (yyvsp[(5) - (7)].sequenceType), parseInfo),
+ parseInfo, (yylsp[(1) - (7)]), temp);
+ temp->templateParameters = parseInfo->templateParameters;
+ parseInfo->templateParametersHandled();
+ }
+ break;
+
+ case 21:
+/* Line 1269 of yacc.c. */
+#line 1572 "querytransformparser.ypp"
+ {
+ parseInfo->isParsingPattern = true;
+ }
+ break;
+
+ case 22:
+/* Line 1269 of yacc.c. */
+#line 1576 "querytransformparser.ypp"
+ {
+ parseInfo->isParsingPattern = false;
+ }
+ break;
+
+ case 23:
+/* Line 1269 of yacc.c. */
+#line 1585 "querytransformparser.ypp"
+ {
+ /* 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((yyvsp[(7) - (15)].expr));
+ const TemplatePattern::ID templateID = parseInfo->allocateTemplateID();
+
+ Template::Ptr templ(create(new Template(ip, (yyvsp[(13) - (15)].sequenceType)), (yyloc), parseInfo));
+ templ->body = typeCheckTemplateBody((yyvsp[(14) - (15)].expr), (yyvsp[(13) - (15)].sequenceType), 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, (yyvsp[(11) - (15)].enums.Double), templ);
+ }
+
+ loadPattern(pattern, ourPatterns, templateID, (yyvsp[(11) - (15)].enums.Double), templ);
+
+ if(!(yyvsp[(3) - (15)].qName).isNull())
+ registerNamedTemplate((yyvsp[(3) - (15)].qName), (yyvsp[(14) - (15)].expr), parseInfo, (yylsp[(1) - (15)]), templ);
+
+ /* Now, let's add it to all the relevant templates. */
+ for(int i = 0; i < (yyvsp[(10) - (15)].qNameVector).count(); ++i) /* For each mode. */
+ {
+ const QXmlName &modeName = (yyvsp[(10) - (15)].qNameVector).at(i);
+
+ if(modeName == QXmlName(StandardNamespaces::InternalXSLT, StandardLocalNames::all) && (yyvsp[(10) - (15)].qNameVector).count() > 1)
+ {
+ parseInfo->staticContext->error(QtXmlPatterns::tr("The keyword %1 cannot occur with any other mode name.")
+ .arg(formatKeyword(QLatin1String("#all"))),
+ ReportContext::XTSE0530,
+ fromYYLTYPE((yyloc), 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));
+ }
+ }
+ break;
+
+ case 24:
+/* Line 1269 of yacc.c. */
+#line 1639 "querytransformparser.ypp"
+ {
+ (yyval.enums.Double) = std::numeric_limits<xsDouble>::quiet_NaN();
+ }
+ break;
+
+ case 25:
+/* Line 1269 of yacc.c. */
+#line 1644 "querytransformparser.ypp"
+ {
+ const AtomicValue::Ptr val(Decimal::fromLexical((yyvsp[(2) - (2)].sval)));
+ if(val->hasError())
+ {
+ parseInfo->staticContext->error(QtXmlPatterns::tr("The value of attribute %1 must of type %2, which %3 isn't.")
+ .arg(formatKeyword(QLatin1String("priority")),
+ formatType(parseInfo->staticContext->namePool(), BuiltinTypes::xsDecimal),
+ formatData((yyvsp[(2) - (2)].sval))),
+ ReportContext::XTSE0530,
+ fromYYLTYPE((yyloc), parseInfo));
+ }
+ else
+ (yyval.enums.Double) = val->as<Numeric>()->toDouble();
+ }
+ break;
+
+ case 26:
+/* Line 1269 of yacc.c. */
+#line 1660 "querytransformparser.ypp"
+ {
+ (yyval.qName) = QXmlName();
+ }
+ break;
+
+ case 28:
+/* Line 1269 of yacc.c. */
+#line 1666 "querytransformparser.ypp"
+ {
+ (yyval.qName) = (yyvsp[(2) - (2)].qName);
+ }
+ break;
+
+ case 30:
+/* Line 1269 of yacc.c. */
+#line 1672 "querytransformparser.ypp"
+ {
+ disallowedConstruct(parseInfo, (yyloc));
+ }
+ break;
+
+ case 32:
+/* Line 1269 of yacc.c. */
+#line 1677 "querytransformparser.ypp"
+ {
+ disallowedConstruct(parseInfo, (yyloc));
+ }
+ break;
+
+ case 33:
+/* Line 1269 of yacc.c. */
+#line 1681 "querytransformparser.ypp"
+ {
+ disallowedConstruct(parseInfo, (yyloc));
+ }
+ break;
+
+ case 34:
+/* Line 1269 of yacc.c. */
+#line 1685 "querytransformparser.ypp"
+ {
+ disallowedConstruct(parseInfo, (yyloc));
+ }
+ break;
+
+ case 39:
+/* Line 1269 of yacc.c. */
+#line 1696 "querytransformparser.ypp"
+ {
+ if(!(yyvsp[(6) - (7)].enums.Bool))
+ disallowedConstruct(parseInfo, (yyloc));
+
+ if((yyvsp[(3) - (7)].sval) == QLatin1String("xmlns"))
+ {
+ parseInfo->staticContext->error(QtXmlPatterns::tr("It is not possible to redeclare prefix %1.")
+ .arg(formatKeyword(QLatin1String("xmlns"))),
+ ReportContext::XQST0070, fromYYLTYPE((yyloc), parseInfo));
+ }
+ else if ((yyvsp[(5) - (7)].sval) == CommonNamespaces::XML || (yyvsp[(3) - (7)].sval) == 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((yyloc), parseInfo));
+ }
+ else if(parseInfo->declaredPrefixes.contains((yyvsp[(3) - (7)].sval)))
+ {
+ /* 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((yyvsp[(3) - (7)].sval))),
+ ReportContext::XQST0033, fromYYLTYPE((yyloc), parseInfo));
+ }
+ else
+ {
+ parseInfo->declaredPrefixes.append((yyvsp[(3) - (7)].sval));
+
+ if((yyvsp[(5) - (7)].sval).isEmpty())
+ {
+ parseInfo->staticContext->namespaceBindings()->addBinding(QXmlName(StandardNamespaces::UndeclarePrefix,
+ StandardLocalNames::empty,
+ parseInfo->staticContext->namePool()->allocatePrefix((yyvsp[(3) - (7)].sval))));
+ }
+ else
+ {
+ parseInfo->staticContext->namespaceBindings()->addBinding(parseInfo->staticContext->namePool()->allocateBinding((yyvsp[(3) - (7)].sval), (yyvsp[(5) - (7)].sval)));
+ }
+ }
+ }
+ break;
+
+ case 40:
+/* Line 1269 of yacc.c. */
+#line 1742 "querytransformparser.ypp"
+ {
+ if(parseInfo->hasDeclaration(ParserContext::BoundarySpaceDecl))
+ {
+ parseInfo->staticContext->error(prologMessage("declare boundary-space"),
+ ReportContext::XQST0068, fromYYLTYPE((yyloc), parseInfo));
+ }
+ else
+ {
+ parseInfo->staticContext->setBoundarySpacePolicy((yyvsp[(3) - (4)].enums.boundarySpacePolicy));
+ parseInfo->registerDeclaration(ParserContext::BoundarySpaceDecl);
+ }
+ }
+ break;
+
+ case 41:
+/* Line 1269 of yacc.c. */
+#line 1756 "querytransformparser.ypp"
+ {
+ (yyval.enums.boundarySpacePolicy) = StaticContext::BSPStrip;
+ }
+ break;
+
+ case 42:
+/* Line 1269 of yacc.c. */
+#line 1761 "querytransformparser.ypp"
+ {
+ (yyval.enums.boundarySpacePolicy) = StaticContext::BSPPreserve;
+ }
+ break;
+
+ case 45:
+/* Line 1269 of yacc.c. */
+#line 1770 "querytransformparser.ypp"
+ {
+ if(parseInfo->hasDeclaration(ParserContext::DeclareDefaultElementNamespace))
+ {
+ parseInfo->staticContext->error(prologMessage("declare default element namespace"),
+ ReportContext::XQST0066, fromYYLTYPE((yyloc), parseInfo));
+ }
+ else
+ {
+ parseInfo->staticContext->namespaceBindings()->addBinding(QXmlName(parseInfo->staticContext->namePool()->allocateNamespace((yyvsp[(5) - (6)].sval)), StandardLocalNames::empty));
+ parseInfo->registerDeclaration(ParserContext::DeclareDefaultElementNamespace);
+ }
+ }
+ break;
+
+ case 46:
+/* Line 1269 of yacc.c. */
+#line 1785 "querytransformparser.ypp"
+ {
+ if(parseInfo->hasDeclaration(ParserContext::DeclareDefaultFunctionNamespace))
+ {
+ parseInfo->staticContext->error(prologMessage("declare default function namespace"),
+ ReportContext::XQST0066, fromYYLTYPE((yyloc), parseInfo));
+ }
+ else
+ {
+ parseInfo->staticContext->setDefaultFunctionNamespace((yyvsp[(5) - (6)].sval));
+ parseInfo->registerDeclaration(ParserContext::DeclareDefaultFunctionNamespace);
+ }
+ }
+ break;
+
+ case 47:
+/* Line 1269 of yacc.c. */
+#line 1799 "querytransformparser.ypp"
+ {
+ if((yyvsp[(3) - (5)].qName).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((yyloc), parseInfo));
+ }
+ }
+ break;
+
+ case 48:
+/* Line 1269 of yacc.c. */
+#line 1809 "querytransformparser.ypp"
+ {
+ disallowedConstruct(parseInfo, (yyloc));
+ if(parseInfo->hasDeclaration(ParserContext::OrderingModeDecl))
+ {
+ parseInfo->staticContext->error(prologMessage("declare ordering"),
+ ReportContext::XQST0065, fromYYLTYPE((yyloc), parseInfo));
+ }
+ else
+ {
+ parseInfo->registerDeclaration(ParserContext::OrderingModeDecl);
+ parseInfo->staticContext->setOrderingMode((yyvsp[(3) - (4)].enums.orderingMode));
+ }
+ }
+ break;
+
+ case 49:
+/* Line 1269 of yacc.c. */
+#line 1824 "querytransformparser.ypp"
+ {
+ (yyval.enums.orderingMode) = StaticContext::Ordered;
+ }
+ break;
+
+ case 50:
+/* Line 1269 of yacc.c. */
+#line 1828 "querytransformparser.ypp"
+ {
+ (yyval.enums.orderingMode) = StaticContext::Unordered;
+ }
+ break;
+
+ case 51:
+/* Line 1269 of yacc.c. */
+#line 1833 "querytransformparser.ypp"
+ {
+ if(parseInfo->hasDeclaration(ParserContext::EmptyOrderDecl))
+ {
+ parseInfo->staticContext->error(prologMessage("declare default order"),
+ ReportContext::XQST0069, fromYYLTYPE((yyloc), parseInfo));
+ }
+ else
+ {
+ parseInfo->registerDeclaration(ParserContext::EmptyOrderDecl);
+ parseInfo->staticContext->setOrderingEmptySequence((yyvsp[(4) - (5)].enums.orderingEmptySequence));
+ }
+ }
+ break;
+
+ case 52:
+/* Line 1269 of yacc.c. */
+#line 1847 "querytransformparser.ypp"
+ {
+ (yyval.enums.orderingEmptySequence) = StaticContext::Least;
+ }
+ break;
+
+ case 53:
+/* Line 1269 of yacc.c. */
+#line 1851 "querytransformparser.ypp"
+ {
+ (yyval.enums.orderingEmptySequence) = StaticContext::Greatest;
+ }
+ break;
+
+ case 54:
+/* Line 1269 of yacc.c. */
+#line 1857 "querytransformparser.ypp"
+ {
+ if(parseInfo->hasDeclaration(ParserContext::CopyNamespacesDecl))
+ {
+ parseInfo->staticContext->error(prologMessage("declare copy-namespaces"),
+ ReportContext::XQST0055, fromYYLTYPE((yyloc), parseInfo));
+ }
+ else
+ {
+ parseInfo->registerDeclaration(ParserContext::CopyNamespacesDecl);
+ }
+ }
+ break;
+
+ case 55:
+/* Line 1269 of yacc.c. */
+#line 1870 "querytransformparser.ypp"
+ {
+ parseInfo->preserveNamespacesMode = true;
+ }
+ break;
+
+ case 56:
+/* Line 1269 of yacc.c. */
+#line 1875 "querytransformparser.ypp"
+ {
+ parseInfo->preserveNamespacesMode = false;
+ }
+ break;
+
+ case 57:
+/* Line 1269 of yacc.c. */
+#line 1880 "querytransformparser.ypp"
+ {
+ parseInfo->inheritNamespacesMode = true;
+ }
+ break;
+
+ case 58:
+/* Line 1269 of yacc.c. */
+#line 1885 "querytransformparser.ypp"
+ {
+ parseInfo->inheritNamespacesMode = false;
+ }
+ break;
+
+ case 59:
+/* Line 1269 of yacc.c. */
+#line 1890 "querytransformparser.ypp"
+ {
+ if(parseInfo->hasDeclaration(ParserContext::DefaultCollationDecl))
+ {
+ parseInfo->staticContext->error(prologMessage("declare default collation"),
+ ReportContext::XQST0038, fromYYLTYPE((yyloc), parseInfo));
+ }
+ else
+ {
+ const QUrl coll(resolveAndCheckCollation<ReportContext::XQST0038>((yyvsp[(4) - (5)].sval), parseInfo, (yyloc)));
+
+ parseInfo->registerDeclaration(ParserContext::DefaultCollationDecl);
+ parseInfo->staticContext->setDefaultCollation(coll);
+ }
+ }
+ break;
+
+ case 60:
+/* Line 1269 of yacc.c. */
+#line 1906 "querytransformparser.ypp"
+ {
+ disallowedConstruct(parseInfo, (yyloc), (yyvsp[(3) - (5)].enums.Bool));
+ if(parseInfo->hasDeclaration(ParserContext::BaseURIDecl))
+ {
+ parseInfo->staticContext->error(prologMessage("declare base-uri"),
+ ReportContext::XQST0032, fromYYLTYPE((yyloc), parseInfo));
+ }
+ else
+ {
+ parseInfo->registerDeclaration(ParserContext::BaseURIDecl);
+ const ReflectYYLTYPE ryy((yyloc), parseInfo);
+
+ QUrl toBeBase(AnyURI::toQUrl<ReportContext::XQST0046>((yyvsp[(4) - (5)].sval), 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);
+ }
+ }
+ break;
+
+ case 61:
+/* Line 1269 of yacc.c. */
+#line 1929 "querytransformparser.ypp"
+ {
+ 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((yyloc), parseInfo));
+ }
+ break;
+
+ case 65:
+/* Line 1269 of yacc.c. */
+#line 1941 "querytransformparser.ypp"
+ {
+ if((yyvsp[(4) - (6)].sval).isEmpty())
+ {
+ parseInfo->staticContext->error(QtXmlPatterns::tr("The target namespace of a %1 cannot be empty.")
+ .arg(formatKeyword("module import")),
+ ReportContext::XQST0088, fromYYLTYPE((yyloc), 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((yyloc), parseInfo));
+ }
+ }
+ break;
+
+ case 72:
+/* Line 1269 of yacc.c. */
+#line 1968 "querytransformparser.ypp"
+ {
+ disallowedConstruct(parseInfo, (yyloc), (yyvsp[(3) - (9)].enums.Bool));
+ if(variableByName((yyvsp[(5) - (9)].qName), parseInfo))
+ {
+ parseInfo->staticContext->error(QtXmlPatterns::tr("A variable by name %1 has already "
+ "been declared.")
+ .arg(formatKeyword(parseInfo->staticContext->namePool()->toLexical((yyvsp[(5) - (9)].qName)))),
+ parseInfo->isXSLT() ? ReportContext::XTSE0630 : ReportContext::XQST0049,
+ fromYYLTYPE((yyloc), parseInfo));
+ }
+ else
+ {
+ if((yyvsp[(7) - (9)].expr)) /* We got a value assigned. */
+ {
+ const Expression::Ptr checked
+ (TypeChecker::applyFunctionConversion((yyvsp[(7) - (9)].expr), (yyvsp[(6) - (9)].sequenceType), parseInfo->staticContext,
+ (yyvsp[(3) - (9)].enums.Bool) ? ReportContext::XTTE0570 : ReportContext::XPTY0004,
+ (yyvsp[(3) - (9)].enums.Bool) ? TypeChecker::Options(TypeChecker::CheckFocus | TypeChecker::AutomaticallyConvert) : TypeChecker::CheckFocus));
+
+ pushVariable((yyvsp[(5) - (9)].qName), (yyvsp[(6) - (9)].sequenceType), checked, VariableDeclaration::GlobalVariable, (yyloc), parseInfo);
+ parseInfo->declaredVariables.append(parseInfo->variables.last());
+ }
+ else /* We got an 'external' declaration. */
+ {
+ const SequenceType::Ptr varType(parseInfo->staticContext->
+ externalVariableLoader()->announceExternalVariable((yyvsp[(5) - (9)].qName), (yyvsp[(6) - (9)].sequenceType)));
+
+ 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((yyvsp[(5) - (9)].qName), varType, Expression::Ptr(), VariableDeclaration::ExternalVariable, (yyloc), parseInfo);
+ }
+ else if((yyvsp[(8) - (9)].expr))
+ {
+ /* Ok, the xsl:param got a default value, we make it
+ * available as a regular variable declaration. */
+ // TODO turn into checked
+ pushVariable((yyvsp[(5) - (9)].qName), (yyvsp[(6) - (9)].sequenceType), (yyvsp[(8) - (9)].expr), VariableDeclaration::GlobalVariable, (yyloc), 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(), (yyvsp[(5) - (9)].qName))),
+ parseInfo->isXSLT() ? ReportContext::XTDE0050 : ReportContext::XPDY0002,
+ fromYYLTYPE((yyloc), parseInfo));
+ }
+ }
+ }
+ }
+ break;
+
+ case 73:
+/* Line 1269 of yacc.c. */
+#line 2022 "querytransformparser.ypp"
+ {
+ (yyval.expr).reset();
+ }
+ break;
+
+ case 74:
+/* Line 1269 of yacc.c. */
+#line 2026 "querytransformparser.ypp"
+ {
+ (yyval.expr) = (yyvsp[(2) - (2)].expr);
+ }
+ break;
+
+ case 75:
+/* Line 1269 of yacc.c. */
+#line 2031 "querytransformparser.ypp"
+ {
+ (yyval.expr).reset();
+ }
+ break;
+
+ case 76:
+/* Line 1269 of yacc.c. */
+#line 2035 "querytransformparser.ypp"
+ {
+ (yyval.expr) = (yyvsp[(2) - (2)].expr);
+ }
+ break;
+
+ case 77:
+/* Line 1269 of yacc.c. */
+#line 2040 "querytransformparser.ypp"
+ {
+ if(parseInfo->hasDeclaration(ParserContext::ConstructionDecl))
+ {
+ parseInfo->staticContext->error(prologMessage("declare ordering"),
+ ReportContext::XQST0067, fromYYLTYPE((yyloc), parseInfo));
+ }
+ else
+ {
+ parseInfo->registerDeclaration(ParserContext::ConstructionDecl);
+ parseInfo->staticContext->setConstructionMode((yyvsp[(3) - (4)].enums.constructionMode));
+ }
+ }
+ break;
+
+ case 78:
+/* Line 1269 of yacc.c. */
+#line 2054 "querytransformparser.ypp"
+ {
+ (yyval.enums.constructionMode) = StaticContext::CMStrip;
+ }
+ break;
+
+ case 79:
+/* Line 1269 of yacc.c. */
+#line 2058 "querytransformparser.ypp"
+ {
+ (yyval.enums.constructionMode) = StaticContext::CMPreserve;
+ }
+ break;
+
+ case 80:
+/* Line 1269 of yacc.c. */
+#line 2063 "querytransformparser.ypp"
+ {
+ (yyval.enums.slot) = parseInfo->currentExpressionSlot() - (yyvsp[(6) - (7)].functionArguments).count();
+ }
+ break;
+
+ case 81:
+/* Line 1269 of yacc.c. */
+#line 2067 "querytransformparser.ypp"
+ {
+ if(!(yyvsp[(3) - (11)].enums.Bool))
+ disallowedConstruct(parseInfo, (yyloc), (yyvsp[(3) - (11)].enums.Bool));
+
+ /* If FunctionBody is null, it is 'external', otherwise the value is the body. */
+ const QXmlName::NamespaceCode ns((yyvsp[(4) - (11)].qName).namespaceURI());
+
+ if(parseInfo->isXSLT() && !(yyvsp[(4) - (11)].qName).hasPrefix())
+ {
+ parseInfo->staticContext->error(QtXmlPatterns::tr("A stylesheet function must have a prefixed name."),
+ ReportContext::XTSE0740,
+ fromYYLTYPE((yyloc), parseInfo));
+ }
+
+ if((yyvsp[(10) - (11)].expr)) /* 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((yyloc), 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((yyloc), 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((yyloc), parseInfo));
+ }
+ else
+ {
+ /* Apply function conversion such that the body matches the declared
+ * return type. */
+ const Expression::Ptr checked(TypeChecker::applyFunctionConversion((yyvsp[(10) - (11)].expr), (yyvsp[(9) - (11)].sequenceType),
+ parseInfo->staticContext,
+ ReportContext::XPTY0004,
+ TypeChecker::Options(TypeChecker::AutomaticallyConvert |
+ TypeChecker::CheckFocus |
+ TypeChecker::GeneratePromotion)));
+
+ const int argCount = (yyvsp[(6) - (11)].functionArguments).count();
+ const FunctionSignature::Ptr sign(new FunctionSignature((yyvsp[(4) - (11)].qName) /* name */,
+ argCount /* minArgs */,
+ argCount /* maxArgs */,
+ (yyvsp[(9) - (11)].sequenceType) /* returnType */));
+ sign->setArguments((yyvsp[(6) - (11)].functionArguments));
+ 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((yyloc), parseInfo));
+ }
+ }
+
+ VariableDeclaration::List argDecls;
+
+ for(int i = 0; i < argCount; ++i)
+ argDecls.append(parseInfo->variables.at(i));
+
+ if((yyvsp[(8) - (11)].enums.slot) > -1)
+ {
+ /* We have allocated slots, so now push them out of scope. */
+ parseInfo->finalizePushedVariable(argCount);
+ }
+
+ parseInfo->userFunctions.append(UserFunction::Ptr(new UserFunction(sign, checked, (yyvsp[(8) - (11)].enums.slot), 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((yyloc), parseInfo));
+ }
+ }
+ break;
+
+ case 82:
+/* Line 1269 of yacc.c. */
+#line 2171 "querytransformparser.ypp"
+ {
+ (yyval.functionArguments) = FunctionArgument::List();
+ }
+ break;
+
+ case 83:
+/* Line 1269 of yacc.c. */
+#line 2175 "querytransformparser.ypp"
+ {
+ FunctionArgument::List l;
+ l.append((yyvsp[(1) - (1)].functionArgument));
+ (yyval.functionArguments) = l;
+ }
+ break;
+
+ case 84:
+/* Line 1269 of yacc.c. */
+#line 2181 "querytransformparser.ypp"
+ {
+ FunctionArgument::List::const_iterator it((yyvsp[(1) - (3)].functionArguments).constBegin());
+ const FunctionArgument::List::const_iterator end((yyvsp[(1) - (3)].functionArguments).constEnd());
+
+ for(; it != end; ++it)
+ {
+ if((*it)->name() == (yyvsp[(3) - (3)].functionArgument)->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(), (yyvsp[(3) - (3)].functionArgument)->name())),
+ ReportContext::XQST0039, fromYYLTYPE((yyloc), parseInfo));
+ }
+ }
+
+ (yyvsp[(1) - (3)].functionArguments).append((yyvsp[(3) - (3)].functionArgument));
+ (yyval.functionArguments) = (yyvsp[(1) - (3)].functionArguments);
+ }
+ break;
+
+ case 85:
+/* Line 1269 of yacc.c. */
+#line 2202 "querytransformparser.ypp"
+ {
+ pushVariable((yyvsp[(2) - (3)].qName), (yyvsp[(3) - (3)].sequenceType), Expression::Ptr(), VariableDeclaration::FunctionArgument, (yyloc), parseInfo);
+ (yyval.functionArgument) = FunctionArgument::Ptr(new FunctionArgument((yyvsp[(2) - (3)].qName), (yyvsp[(3) - (3)].sequenceType)));
+ }
+ break;
+
+ case 86:
+/* Line 1269 of yacc.c. */
+#line 2208 "querytransformparser.ypp"
+ {
+ (yyval.expr).reset();
+ }
+ break;
+
+ case 88:
+/* Line 1269 of yacc.c. */
+#line 2214 "querytransformparser.ypp"
+ {
+ (yyval.expr) = (yyvsp[(2) - (3)].expr);
+ }
+ break;
+
+ case 91:
+/* Line 1269 of yacc.c. */
+#line 2230 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new CombineNodes((yyvsp[(1) - (3)].expr), CombineNodes::Union, (yyvsp[(3) - (3)].expr)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 93:
+/* Line 1269 of yacc.c. */
+#line 2236 "querytransformparser.ypp"
+ {
+ /* 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." */
+ (yyval.expr) = create(new AxisStep(QXmlNodeModelIndex::AxisSelf, BuiltinTypes::document), (yyloc), parseInfo);
+ }
+ break;
+
+ case 94:
+/* Line 1269 of yacc.c. */
+#line 2245 "querytransformparser.ypp"
+ {
+ /* /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((yyvsp[(2) - (2)].expr));
+
+ 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))
+ {
+ (yyval.expr) = create(GenericPredicate::create((yyvsp[(2) - (2)].expr), create(new AxisStep(QXmlNodeModelIndex::AxisParent, BuiltinTypes::document), (yyloc), parseInfo),
+ parseInfo->staticContext, fromYYLTYPE((yylsp[(1) - (2)]), parseInfo)), (yylsp[(1) - (2)]), 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), (yyloc), parseInfo),
+ parseInfo->staticContext, fromYYLTYPE((yylsp[(1) - (2)]), parseInfo)), (yylsp[(1) - (2)]), parseInfo));
+
+ target->setOperands(newOps);
+ (yyval.expr) = (yyvsp[(2) - (2)].expr);
+ }
+ }
+ break;
+
+ case 95:
+/* Line 1269 of yacc.c. */
+#line 2315 "querytransformparser.ypp"
+ {
+ /* //axis::node-test
+ * =>
+ * axis::node-test[parent::node()]
+ *
+ * Spec says: "//para matches any para element that has a parent node."
+ */
+ (yyval.expr) = create(GenericPredicate::create((yyvsp[(2) - (2)].expr), create(new AxisStep(QXmlNodeModelIndex::AxisParent, BuiltinTypes::node), (yyloc), parseInfo),
+ parseInfo->staticContext, fromYYLTYPE((yylsp[(1) - (2)]), parseInfo)), (yylsp[(1) - (2)]), parseInfo);
+ }
+ break;
+
+ case 97:
+/* Line 1269 of yacc.c. */
+#line 2327 "querytransformparser.ypp"
+ {
+ createIdPatternPath((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), QXmlNodeModelIndex::AxisParent, (yylsp[(2) - (3)]), parseInfo);
+ }
+ break;
+
+ case 98:
+/* Line 1269 of yacc.c. */
+#line 2331 "querytransformparser.ypp"
+ {
+ createIdPatternPath((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), QXmlNodeModelIndex::AxisAncestor, (yylsp[(2) - (3)]), parseInfo);
+ }
+ break;
+
+ case 99:
+/* Line 1269 of yacc.c. */
+#line 2336 "querytransformparser.ypp"
+ {
+ const Expression::List ands((yyvsp[(1) - (1)].expr)->operands());
+ const FunctionSignature::Ptr signature((yyvsp[(1) - (1)].expr)->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((yyloc), 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((yyloc), 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((yyloc), 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((yyloc), 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((yyloc), parseInfo));
+ }
+
+ (yyval.expr) = (yyvsp[(1) - (1)].expr);
+ }
+ break;
+
+ case 101:
+/* Line 1269 of yacc.c. */
+#line 2406 "querytransformparser.ypp"
+ {
+ (yyval.expr) = createPatternPath((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), QXmlNodeModelIndex::AxisParent, (yylsp[(2) - (3)]), parseInfo);
+ }
+ break;
+
+ case 102:
+/* Line 1269 of yacc.c. */
+#line 2410 "querytransformparser.ypp"
+ {
+ (yyval.expr) = createPatternPath((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), QXmlNodeModelIndex::AxisAncestor, (yylsp[(2) - (3)]), parseInfo);
+ }
+ break;
+
+ case 103:
+/* Line 1269 of yacc.c. */
+#line 2415 "querytransformparser.ypp"
+ {
+ const Expression::Ptr expr(findAxisStep((yyvsp[(1) - (1)].expr)));
+
+ 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((yyloc), parseInfo));
+ }
+
+ (yyval.expr) = (yyvsp[(1) - (1)].expr);
+ }
+ break;
+
+ case 105:
+/* Line 1269 of yacc.c. */
+#line 2460 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new ExpressionSequence((yyvsp[(1) - (1)].expressionList)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 106:
+/* Line 1269 of yacc.c. */
+#line 2465 "querytransformparser.ypp"
+ {
+ Expression::List l;
+ l.append((yyvsp[(1) - (3)].expr));
+ l.append((yyvsp[(3) - (3)].expr));
+ (yyval.expressionList) = l;
+ }
+ break;
+
+ case 107:
+/* Line 1269 of yacc.c. */
+#line 2472 "querytransformparser.ypp"
+ {
+ (yyvsp[(1) - (3)].expressionList).append((yyvsp[(3) - (3)].expr));
+ (yyval.expressionList) = (yyvsp[(1) - (3)].expressionList);
+ }
+ break;
+
+ case 113:
+/* Line 1269 of yacc.c. */
+#line 2483 "querytransformparser.ypp"
+ {
+ (yyval.expr) = createDirAttributeValue((yyvsp[(3) - (4)].expressionList), parseInfo, (yyloc));
+ }
+ break;
+
+ case 114:
+/* Line 1269 of yacc.c. */
+#line 2488 "querytransformparser.ypp"
+ {
+ QVector<QXmlName> result;
+ result.append(QXmlName(StandardNamespaces::InternalXSLT, StandardLocalNames::Default));
+ (yyval.qNameVector) = result;
+ }
+ break;
+
+ case 115:
+/* Line 1269 of yacc.c. */
+#line 2494 "querytransformparser.ypp"
+ {
+ (yyval.qNameVector) = (yyvsp[(2) - (2)].qNameVector);
+ }
+ break;
+
+ case 116:
+/* Line 1269 of yacc.c. */
+#line 2499 "querytransformparser.ypp"
+ {
+ (yyval.qName) = QXmlName(StandardNamespaces::InternalXSLT, StandardLocalNames::Default);
+ }
+ break;
+
+ case 117:
+/* Line 1269 of yacc.c. */
+#line 2503 "querytransformparser.ypp"
+ {
+ (yyval.qName) = (yyvsp[(2) - (2)].qName);
+ }
+ break;
+
+ case 118:
+/* Line 1269 of yacc.c. */
+#line 2508 "querytransformparser.ypp"
+ {
+ QVector<QXmlName> result;
+ result.append((yyvsp[(1) - (1)].qName));
+ (yyval.qNameVector) = result;
+ }
+ break;
+
+ case 119:
+/* Line 1269 of yacc.c. */
+#line 2514 "querytransformparser.ypp"
+ {
+ (yyvsp[(1) - (3)].qNameVector).append((yyvsp[(3) - (3)].qName));
+ (yyval.qNameVector) = (yyvsp[(1) - (3)].qNameVector);
+ }
+ break;
+
+ case 120:
+/* Line 1269 of yacc.c. */
+#line 2520 "querytransformparser.ypp"
+ {
+ (yyval.qName) = (yyvsp[(1) - (1)].qName);
+ }
+ break;
+
+ case 121:
+/* Line 1269 of yacc.c. */
+#line 2524 "querytransformparser.ypp"
+ {
+ if((yyvsp[(1) - (1)].sval) == QLatin1String("#current"))
+ (yyval.qName) = QXmlName(StandardNamespaces::InternalXSLT, StandardLocalNames::current);
+ else if((yyvsp[(1) - (1)].sval) == QLatin1String("#default"))
+ (yyval.qName) = QXmlName(StandardNamespaces::InternalXSLT, StandardLocalNames::Default);
+ else if((yyvsp[(1) - (1)].sval) == QLatin1String("#all"))
+ (yyval.qName) = QXmlName(StandardNamespaces::InternalXSLT, StandardLocalNames::all);
+ else
+ {
+ const ReflectYYLTYPE ryy((yyloc), parseInfo);
+
+ if(!QXmlUtils::isNCName((yyvsp[(1) - (1)].sval)))
+ {
+ parseInfo->staticContext->error(QtXmlPatterns::tr("%1 is an invalid template mode name.")
+ .arg(formatKeyword((yyvsp[(1) - (1)].sval))),
+ ReportContext::XTSE0550,
+ fromYYLTYPE((yyloc), parseInfo));
+ }
+
+ (yyval.qName) = parseInfo->staticContext->namePool()->allocateQName(StandardNamespaces::empty, (yyvsp[(1) - (1)].sval));
+ }
+ }
+ break;
+
+ case 124:
+/* Line 1269 of yacc.c. */
+#line 2553 "querytransformparser.ypp"
+ {
+ /* We're pushing the range variable here, not the positional. */
+ (yyval.expr) = pushVariable((yyvsp[(3) - (7)].qName), quantificationType((yyvsp[(4) - (7)].sequenceType)), (yyvsp[(7) - (7)].expr), VariableDeclaration::RangeVariable, (yyloc), parseInfo);
+ }
+ break;
+
+ case 125:
+/* Line 1269 of yacc.c. */
+#line 2557 "querytransformparser.ypp"
+ {
+ /* It is ok this appears after PositionalVar, because currentRangeSlot()
+ * uses a different "channel" than currentPositionSlot(), so they can't trash
+ * each other. */
+ (yyval.enums.slot) = parseInfo->staticContext->currentRangeSlot();
+ }
+ break;
+
+ case 126:
+/* Line 1269 of yacc.c. */
+#line 2564 "querytransformparser.ypp"
+ {
+ Q_ASSERT((yyvsp[(7) - (10)].expr));
+ Q_ASSERT((yyvsp[(10) - (10)].expr));
+
+ /* We want the next last pushed variable, since we push the range variable after the
+ * positional variable. */
+ if((yyvsp[(5) - (10)].enums.slot) != -1 && parseInfo->variables.at(parseInfo->variables.count() -2)->name == (yyvsp[(3) - (10)].qName))
+ {
+ /* 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(), (yyvsp[(3) - (10)].qName))),
+ ReportContext::XQST0089,
+ fromYYLTYPE((yyloc), parseInfo));
+
+ }
+
+ const Expression::Ptr retBody(create(new ForClause((yyvsp[(9) - (10)].enums.slot), (yyvsp[(8) - (10)].expr), (yyvsp[(10) - (10)].expr), (yyvsp[(5) - (10)].enums.slot)), (yyloc), parseInfo));
+ ReturnOrderBy *const rob = locateReturnClause((yyvsp[(10) - (10)].expr));
+
+ if(rob)
+ (yyval.expr) = create(new OrderBy(rob->stability(), rob->orderSpecs(), retBody, rob), (yyloc), parseInfo);
+ else
+ (yyval.expr) = retBody;
+
+ parseInfo->finalizePushedVariable();
+
+ if((yyvsp[(5) - (10)].enums.slot) != -1) /* We also have a positional variable to remove from the scope. */
+ parseInfo->finalizePushedVariable();
+ }
+ break;
+
+ case 127:
+/* Line 1269 of yacc.c. */
+#line 2598 "querytransformparser.ypp"
+ {
+ pushVariable((yyvsp[(3) - (7)].qName), quantificationType((yyvsp[(4) - (7)].sequenceType)), (yyvsp[(7) - (7)].expr), VariableDeclaration::RangeVariable, (yyloc), parseInfo);
+ }
+ break;
+
+ case 128:
+/* Line 1269 of yacc.c. */
+#line 2601 "querytransformparser.ypp"
+ {
+ /* It is ok this appears after PositionalVar, because currentRangeSlot()
+ * uses a different "channel" than currentPositionSlot(), so they can't trash
+ * each other. */
+ (yyval.enums.slot) = parseInfo->staticContext->currentRangeSlot();
+ }
+ break;
+
+ case 129:
+/* Line 1269 of yacc.c. */
+#line 2608 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new ForClause((yyvsp[(9) - (10)].enums.slot), (yyvsp[(7) - (10)].expr), (yyvsp[(10) - (10)].expr), (yyvsp[(5) - (10)].enums.slot)), (yyloc), parseInfo);
+
+ parseInfo->finalizePushedVariable();
+
+ if((yyvsp[(5) - (10)].enums.slot) != -1) /* We also have a positional variable to remove from the scope. */
+ parseInfo->finalizePushedVariable();
+ }
+ break;
+
+ case 133:
+/* Line 1269 of yacc.c. */
+#line 2622 "querytransformparser.ypp"
+ {
+ (yyval.enums.slot) = -1;
+ }
+ break;
+
+ case 134:
+/* Line 1269 of yacc.c. */
+#line 2627 "querytransformparser.ypp"
+ {
+ pushVariable((yyvsp[(3) - (3)].qName), CommonSequenceTypes::ExactlyOneInteger, Expression::Ptr(),
+ VariableDeclaration::PositionalVariable, (yyloc), parseInfo);
+ (yyval.enums.slot) = parseInfo->currentPositionSlot();
+ }
+ break;
+
+ case 135:
+/* Line 1269 of yacc.c. */
+#line 2634 "querytransformparser.ypp"
+ {
+ (yyval.expr) = pushVariable((yyvsp[(4) - (7)].qName), quantificationType((yyvsp[(5) - (7)].sequenceType)), (yyvsp[(7) - (7)].expr), VariableDeclaration::ExpressionVariable, (yyloc), parseInfo);
+ }
+ break;
+
+ case 136:
+/* Line 1269 of yacc.c. */
+#line 2638 "querytransformparser.ypp"
+ {
+ disallowedConstruct(parseInfo, (yyloc), (yyvsp[(2) - (9)].enums.Bool));
+
+ Q_ASSERT(parseInfo->variables.top()->name == (yyvsp[(4) - (9)].qName));
+ (yyval.expr) = create(new LetClause((yyvsp[(8) - (9)].expr), (yyvsp[(9) - (9)].expr), parseInfo->variables.top()), (yyloc), parseInfo);
+ parseInfo->finalizePushedVariable();
+ }
+ break;
+
+ case 137:
+/* Line 1269 of yacc.c. */
+#line 2647 "querytransformparser.ypp"
+ { (yyval.expr) = pushVariable((yyvsp[(3) - (6)].qName), quantificationType((yyvsp[(4) - (6)].sequenceType)), (yyvsp[(6) - (6)].expr), VariableDeclaration::ExpressionVariable, (yyloc), parseInfo);}
+ break;
+
+ case 138:
+/* Line 1269 of yacc.c. */
+#line 2649 "querytransformparser.ypp"
+ {
+ Q_ASSERT(parseInfo->variables.top()->name == (yyvsp[(3) - (8)].qName));
+ (yyval.expr) = create(new LetClause((yyvsp[(7) - (8)].expr), (yyvsp[(8) - (8)].expr), parseInfo->variables.top()), (yyloc), parseInfo);
+ parseInfo->finalizePushedVariable();
+ }
+ break;
+
+ case 142:
+/* Line 1269 of yacc.c. */
+#line 2660 "querytransformparser.ypp"
+ {
+ if((yyvsp[(1) - (3)].orderSpecs).isEmpty())
+ (yyval.expr) = (yyvsp[(3) - (3)].expr);
+ else
+ (yyval.expr) = createReturnOrderBy((yyvsp[(1) - (3)].orderSpecs), (yyvsp[(3) - (3)].expr), parseInfo->orderStability.pop(), (yyloc), parseInfo);
+ }
+ break;
+
+ case 143:
+/* Line 1269 of yacc.c. */
+#line 2668 "querytransformparser.ypp"
+ {
+ if((yyvsp[(3) - (5)].orderSpecs).isEmpty())
+ (yyval.expr) = create(new IfThenClause((yyvsp[(2) - (5)].expr), (yyvsp[(5) - (5)].expr), create(new EmptySequence, (yyloc), parseInfo)), (yyloc), parseInfo);
+ else
+ (yyval.expr) = create(new IfThenClause((yyvsp[(2) - (5)].expr), createReturnOrderBy((yyvsp[(3) - (5)].orderSpecs), (yyvsp[(5) - (5)].expr), parseInfo->orderStability.pop(), (yyloc), parseInfo),
+ create(new EmptySequence, (yyloc), parseInfo)),
+ (yyloc), parseInfo);
+ }
+ break;
+
+ case 144:
+/* Line 1269 of yacc.c. */
+#line 2678 "querytransformparser.ypp"
+ {
+ (yyval.orderSpecs) = OrderSpecTransfer::List();
+ }
+ break;
+
+ case 146:
+/* Line 1269 of yacc.c. */
+#line 2684 "querytransformparser.ypp"
+ {
+ (yyval.orderSpecs) = (yyvsp[(2) - (2)].orderSpecs);
+ }
+ break;
+
+ case 147:
+/* Line 1269 of yacc.c. */
+#line 2689 "querytransformparser.ypp"
+ {
+ OrderSpecTransfer::List list;
+ list += (yyvsp[(1) - (3)].orderSpecs);
+ list.append((yyvsp[(3) - (3)].orderSpec));
+ (yyval.orderSpecs) = list;
+ }
+ break;
+
+ case 148:
+/* Line 1269 of yacc.c. */
+#line 2696 "querytransformparser.ypp"
+ {
+ OrderSpecTransfer::List list;
+ list.append((yyvsp[(1) - (1)].orderSpec));
+ (yyval.orderSpecs) = list;
+ }
+ break;
+
+ case 149:
+/* Line 1269 of yacc.c. */
+#line 2703 "querytransformparser.ypp"
+ {
+ (yyval.orderSpec) = OrderSpecTransfer((yyvsp[(1) - (4)].expr), OrderBy::OrderSpec((yyvsp[(2) - (4)].enums.sortDirection), (yyvsp[(3) - (4)].enums.orderingEmptySequence)));
+ }
+ break;
+
+ case 150:
+/* Line 1269 of yacc.c. */
+#line 2708 "querytransformparser.ypp"
+ {
+ /* 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.
+ */
+ (yyval.enums.sortDirection) = OrderBy::OrderSpec::Ascending;
+ }
+ break;
+
+ case 151:
+/* Line 1269 of yacc.c. */
+#line 2729 "querytransformparser.ypp"
+ {
+ (yyval.enums.sortDirection) = OrderBy::OrderSpec::Ascending;
+ }
+ break;
+
+ case 152:
+/* Line 1269 of yacc.c. */
+#line 2734 "querytransformparser.ypp"
+ {
+ (yyval.enums.sortDirection) = OrderBy::OrderSpec::Descending;
+ }
+ break;
+
+ case 153:
+/* Line 1269 of yacc.c. */
+#line 2739 "querytransformparser.ypp"
+ {
+ (yyval.enums.orderingEmptySequence) = parseInfo->staticContext->orderingEmptySequence();
+ }
+ break;
+
+ case 156:
+/* Line 1269 of yacc.c. */
+#line 2746 "querytransformparser.ypp"
+ {
+ if(parseInfo->isXSLT())
+ resolveAndCheckCollation<ReportContext::XTDE1035>((yyvsp[(2) - (2)].sval), parseInfo, (yyloc));
+ else
+ resolveAndCheckCollation<ReportContext::XQST0076>((yyvsp[(2) - (2)].sval), parseInfo, (yyloc));
+ }
+ break;
+
+ case 157:
+/* Line 1269 of yacc.c. */
+#line 2753 "querytransformparser.ypp"
+ {
+ /* We do nothing. We don't use collations, and we have this non-terminal
+ * in order to accept expressions. */
+ }
+ break;
+
+ case 158:
+/* Line 1269 of yacc.c. */
+#line 2759 "querytransformparser.ypp"
+ {
+ parseInfo->orderStability.push(OrderBy::StableOrder);
+ }
+ break;
+
+ case 159:
+/* Line 1269 of yacc.c. */
+#line 2763 "querytransformparser.ypp"
+ {
+ parseInfo->orderStability.push(OrderBy::UnstableOrder);
+ }
+ break;
+
+ case 162:
+/* Line 1269 of yacc.c. */
+#line 2771 "querytransformparser.ypp"
+ {
+ pushVariable((yyvsp[(3) - (6)].qName), quantificationType((yyvsp[(4) - (6)].sequenceType)), (yyvsp[(6) - (6)].expr),
+ VariableDeclaration::RangeVariable, (yyloc), parseInfo);
+ }
+ break;
+
+ case 163:
+/* Line 1269 of yacc.c. */
+#line 2775 "querytransformparser.ypp"
+ {(yyval.enums.slot) = parseInfo->staticContext->currentRangeSlot();}
+ break;
+
+ case 164:
+/* Line 1269 of yacc.c. */
+#line 2777 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new QuantifiedExpression((yyvsp[(8) - (9)].enums.slot),
+ QuantifiedExpression::Some, (yyvsp[(6) - (9)].expr), (yyvsp[(9) - (9)].expr)), (yyloc), parseInfo);
+ parseInfo->finalizePushedVariable();
+ }
+ break;
+
+ case 165:
+/* Line 1269 of yacc.c. */
+#line 2784 "querytransformparser.ypp"
+ {
+ (yyval.expr) = pushVariable((yyvsp[(3) - (6)].qName), quantificationType((yyvsp[(4) - (6)].sequenceType)), (yyvsp[(6) - (6)].expr),
+ VariableDeclaration::RangeVariable, (yyloc), parseInfo);
+ }
+ break;
+
+ case 166:
+/* Line 1269 of yacc.c. */
+#line 2788 "querytransformparser.ypp"
+ {(yyval.enums.slot) = parseInfo->staticContext->currentRangeSlot();}
+ break;
+
+ case 167:
+/* Line 1269 of yacc.c. */
+#line 2790 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new QuantifiedExpression((yyvsp[(8) - (9)].enums.slot),
+ QuantifiedExpression::Some, (yyvsp[(7) - (9)].expr), (yyvsp[(9) - (9)].expr)), (yyloc), parseInfo);
+ parseInfo->finalizePushedVariable();
+ }
+ break;
+
+ case 169:
+/* Line 1269 of yacc.c. */
+#line 2799 "querytransformparser.ypp"
+ {
+ pushVariable((yyvsp[(3) - (6)].qName), quantificationType((yyvsp[(4) - (6)].sequenceType)), (yyvsp[(6) - (6)].expr),
+ VariableDeclaration::RangeVariable, (yyloc), parseInfo);
+ }
+ break;
+
+ case 170:
+/* Line 1269 of yacc.c. */
+#line 2803 "querytransformparser.ypp"
+ {(yyval.enums.slot) = parseInfo->staticContext->currentRangeSlot();}
+ break;
+
+ case 171:
+/* Line 1269 of yacc.c. */
+#line 2805 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new QuantifiedExpression((yyvsp[(8) - (9)].enums.slot),
+ QuantifiedExpression::Every, (yyvsp[(6) - (9)].expr), (yyvsp[(9) - (9)].expr)), (yyloc), parseInfo);
+ parseInfo->finalizePushedVariable();
+ }
+ break;
+
+ case 172:
+/* Line 1269 of yacc.c. */
+#line 2812 "querytransformparser.ypp"
+ {
+ (yyval.expr) = pushVariable((yyvsp[(3) - (6)].qName), quantificationType((yyvsp[(4) - (6)].sequenceType)), (yyvsp[(6) - (6)].expr),
+ VariableDeclaration::RangeVariable, (yyloc), parseInfo);
+ }
+ break;
+
+ case 173:
+/* Line 1269 of yacc.c. */
+#line 2816 "querytransformparser.ypp"
+ {(yyval.enums.slot) = parseInfo->staticContext->currentRangeSlot();}
+ break;
+
+ case 174:
+/* Line 1269 of yacc.c. */
+#line 2818 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new QuantifiedExpression((yyvsp[(8) - (9)].enums.slot),
+ QuantifiedExpression::Every, (yyvsp[(7) - (9)].expr), (yyvsp[(9) - (9)].expr)), (yyloc), parseInfo);
+ parseInfo->finalizePushedVariable();
+ }
+ break;
+
+ case 176:
+/* Line 1269 of yacc.c. */
+#line 2827 "querytransformparser.ypp"
+ {
+ (yyval.expr) = (yyvsp[(2) - (2)].expr);
+ }
+ break;
+
+ case 177:
+/* Line 1269 of yacc.c. */
+#line 2854 "querytransformparser.ypp"
+ {
+ parseInfo->typeswitchSource.push((yyvsp[(3) - (4)].expr));
+ }
+ break;
+
+ case 178:
+/* Line 1269 of yacc.c. */
+#line 2858 "querytransformparser.ypp"
+ {
+ disallowedConstruct(parseInfo, (yyloc));
+ parseInfo->typeswitchSource.pop();
+ (yyval.expr) = (yyvsp[(6) - (6)].expr);
+ }
+ break;
+
+ case 179:
+/* Line 1269 of yacc.c. */
+#line 2865 "querytransformparser.ypp"
+ {
+ if(!(yyvsp[(2) - (3)].qName).isNull())
+ {
+ pushVariable((yyvsp[(2) - (3)].qName), (yyvsp[(3) - (3)].sequenceType), parseInfo->typeswitchSource.top(),
+ VariableDeclaration::ExpressionVariable, (yyloc), parseInfo, false);
+ }
+ }
+ break;
+
+ case 180:
+/* Line 1269 of yacc.c. */
+#line 2873 "querytransformparser.ypp"
+ {
+ /* The variable shouldn't be in-scope for other case branches. */
+ if(!(yyvsp[(2) - (6)].qName).isNull())
+ parseInfo->finalizePushedVariable();
+ }
+ break;
+
+ case 181:
+/* Line 1269 of yacc.c. */
+#line 2879 "querytransformparser.ypp"
+ {
+ const Expression::Ptr instanceOf(create(new InstanceOf(parseInfo->typeswitchSource.top(), (yyvsp[(3) - (8)].sequenceType)), (yyloc), parseInfo));
+ (yyval.expr) = create(new IfThenClause(instanceOf, (yyvsp[(6) - (8)].expr), (yyvsp[(8) - (8)].expr)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 184:
+/* Line 1269 of yacc.c. */
+#line 2888 "querytransformparser.ypp"
+ {
+ (yyval.qName) = QXmlName();
+ }
+ break;
+
+ case 185:
+/* Line 1269 of yacc.c. */
+#line 2893 "querytransformparser.ypp"
+ {
+ (yyval.qName) = (yyvsp[(2) - (3)].qName);
+ }
+ break;
+
+ case 186:
+/* Line 1269 of yacc.c. */
+#line 2898 "querytransformparser.ypp"
+ {
+ (yyval.expr) = (yyvsp[(3) - (3)].expr);
+ }
+ break;
+
+ case 187:
+/* Line 1269 of yacc.c. */
+#line 2902 "querytransformparser.ypp"
+ {
+ if(!(yyvsp[(3) - (3)].qName).isNull())
+ {
+ pushVariable((yyvsp[(3) - (3)].qName), parseInfo->typeswitchSource.top()->staticType(),
+ parseInfo->typeswitchSource.top(),
+ VariableDeclaration::ExpressionVariable, (yyloc), parseInfo, false);
+ }
+ }
+ break;
+
+ case 188:
+/* Line 1269 of yacc.c. */
+#line 2911 "querytransformparser.ypp"
+ {
+ if(!(yyvsp[(3) - (6)].qName).isNull())
+ parseInfo->finalizePushedVariable();
+ (yyval.expr) = (yyvsp[(6) - (6)].expr);
+ }
+ break;
+
+ case 189:
+/* Line 1269 of yacc.c. */
+#line 2918 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new IfThenClause((yyvsp[(3) - (8)].expr), (yyvsp[(6) - (8)].expr), (yyvsp[(8) - (8)].expr)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 191:
+/* Line 1269 of yacc.c. */
+#line 2924 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new OrExpression((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 193:
+/* Line 1269 of yacc.c. */
+#line 2930 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new AndExpression((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 199:
+/* Line 1269 of yacc.c. */
+#line 2941 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new RangeExpression((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 201:
+/* Line 1269 of yacc.c. */
+#line 2947 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new ArithmeticExpression((yyvsp[(1) - (3)].expr), (yyvsp[(2) - (3)].enums.mathOperator), (yyvsp[(3) - (3)].expr)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 202:
+/* Line 1269 of yacc.c. */
+#line 2951 "querytransformparser.ypp"
+ {(yyval.enums.mathOperator) = AtomicMathematician::Add;}
+ break;
+
+ case 203:
+/* Line 1269 of yacc.c. */
+#line 2952 "querytransformparser.ypp"
+ {(yyval.enums.mathOperator) = AtomicMathematician::Substract;}
+ break;
+
+ case 205:
+/* Line 1269 of yacc.c. */
+#line 2956 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new ArithmeticExpression((yyvsp[(1) - (3)].expr), (yyvsp[(2) - (3)].enums.mathOperator), (yyvsp[(3) - (3)].expr)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 206:
+/* Line 1269 of yacc.c. */
+#line 2960 "querytransformparser.ypp"
+ {(yyval.enums.mathOperator) = AtomicMathematician::Multiply;}
+ break;
+
+ case 207:
+/* Line 1269 of yacc.c. */
+#line 2961 "querytransformparser.ypp"
+ {(yyval.enums.mathOperator) = AtomicMathematician::Div;}
+ break;
+
+ case 208:
+/* Line 1269 of yacc.c. */
+#line 2962 "querytransformparser.ypp"
+ {(yyval.enums.mathOperator) = AtomicMathematician::IDiv;}
+ break;
+
+ case 209:
+/* Line 1269 of yacc.c. */
+#line 2963 "querytransformparser.ypp"
+ {(yyval.enums.mathOperator) = AtomicMathematician::Mod;}
+ break;
+
+ case 211:
+/* Line 1269 of yacc.c. */
+#line 2967 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new CombineNodes((yyvsp[(1) - (3)].expr), CombineNodes::Union, (yyvsp[(3) - (3)].expr)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 213:
+/* Line 1269 of yacc.c. */
+#line 2973 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new CombineNodes((yyvsp[(1) - (3)].expr), (yyvsp[(2) - (3)].enums.combinedNodeOp), (yyvsp[(3) - (3)].expr)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 216:
+/* Line 1269 of yacc.c. */
+#line 2981 "querytransformparser.ypp"
+ {
+ (yyval.enums.combinedNodeOp) = CombineNodes::Intersect;
+ }
+ break;
+
+ case 217:
+/* Line 1269 of yacc.c. */
+#line 2985 "querytransformparser.ypp"
+ {
+ (yyval.enums.combinedNodeOp) = CombineNodes::Except;
+ }
+ break;
+
+ case 219:
+/* Line 1269 of yacc.c. */
+#line 2991 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new InstanceOf((yyvsp[(1) - (4)].expr),
+ SequenceType::Ptr((yyvsp[(4) - (4)].sequenceType))), (yyloc), parseInfo);
+ }
+ break;
+
+ case 221:
+/* Line 1269 of yacc.c. */
+#line 2998 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new TreatAs((yyvsp[(1) - (4)].expr), (yyvsp[(4) - (4)].sequenceType)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 223:
+/* Line 1269 of yacc.c. */
+#line 3004 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new CastableAs((yyvsp[(1) - (4)].expr), (yyvsp[(4) - (4)].sequenceType)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 225:
+/* Line 1269 of yacc.c. */
+#line 3010 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new CastAs((yyvsp[(1) - (4)].expr), (yyvsp[(4) - (4)].sequenceType)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 227:
+/* Line 1269 of yacc.c. */
+#line 3016 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new UnaryExpression((yyvsp[(1) - (2)].enums.mathOperator), (yyvsp[(2) - (2)].expr), parseInfo->staticContext), (yyloc), parseInfo);
+ }
+ break;
+
+ case 228:
+/* Line 1269 of yacc.c. */
+#line 3021 "querytransformparser.ypp"
+ {
+ (yyval.enums.mathOperator) = AtomicMathematician::Add;
+ }
+ break;
+
+ case 229:
+/* Line 1269 of yacc.c. */
+#line 3025 "querytransformparser.ypp"
+ {
+ (yyval.enums.mathOperator) = AtomicMathematician::Substract;
+ }
+ break;
+
+ case 233:
+/* Line 1269 of yacc.c. */
+#line 3034 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new GeneralComparison((yyvsp[(1) - (3)].expr), (yyvsp[(2) - (3)].enums.valueOperator), (yyvsp[(3) - (3)].expr), parseInfo->isBackwardsCompat.top()), (yyloc), parseInfo);
+ }
+ break;
+
+ case 234:
+/* Line 1269 of yacc.c. */
+#line 3038 "querytransformparser.ypp"
+ {(yyval.enums.valueOperator) = AtomicComparator::OperatorEqual;}
+ break;
+
+ case 235:
+/* Line 1269 of yacc.c. */
+#line 3039 "querytransformparser.ypp"
+ {(yyval.enums.valueOperator) = AtomicComparator::OperatorNotEqual;}
+ break;
+
+ case 236:
+/* Line 1269 of yacc.c. */
+#line 3040 "querytransformparser.ypp"
+ {(yyval.enums.valueOperator) = AtomicComparator::OperatorGreaterOrEqual;}
+ break;
+
+ case 237:
+/* Line 1269 of yacc.c. */
+#line 3041 "querytransformparser.ypp"
+ {(yyval.enums.valueOperator) = AtomicComparator::OperatorGreaterThan;}
+ break;
+
+ case 238:
+/* Line 1269 of yacc.c. */
+#line 3042 "querytransformparser.ypp"
+ {(yyval.enums.valueOperator) = AtomicComparator::OperatorLessOrEqual;}
+ break;
+
+ case 239:
+/* Line 1269 of yacc.c. */
+#line 3043 "querytransformparser.ypp"
+ {(yyval.enums.valueOperator) = AtomicComparator::OperatorLessThan;}
+ break;
+
+ case 240:
+/* Line 1269 of yacc.c. */
+#line 3046 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new ValueComparison((yyvsp[(1) - (3)].expr), (yyvsp[(2) - (3)].enums.valueOperator), (yyvsp[(3) - (3)].expr)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 241:
+/* Line 1269 of yacc.c. */
+#line 3050 "querytransformparser.ypp"
+ {(yyval.enums.valueOperator) = AtomicComparator::OperatorEqual;}
+ break;
+
+ case 242:
+/* Line 1269 of yacc.c. */
+#line 3051 "querytransformparser.ypp"
+ {(yyval.enums.valueOperator) = AtomicComparator::OperatorNotEqual;}
+ break;
+
+ case 243:
+/* Line 1269 of yacc.c. */
+#line 3052 "querytransformparser.ypp"
+ {(yyval.enums.valueOperator) = AtomicComparator::OperatorGreaterOrEqual;}
+ break;
+
+ case 244:
+/* Line 1269 of yacc.c. */
+#line 3053 "querytransformparser.ypp"
+ {(yyval.enums.valueOperator) = AtomicComparator::OperatorGreaterThan;}
+ break;
+
+ case 245:
+/* Line 1269 of yacc.c. */
+#line 3054 "querytransformparser.ypp"
+ {(yyval.enums.valueOperator) = AtomicComparator::OperatorLessOrEqual;}
+ break;
+
+ case 246:
+/* Line 1269 of yacc.c. */
+#line 3055 "querytransformparser.ypp"
+ {(yyval.enums.valueOperator) = AtomicComparator::OperatorLessThan;}
+ break;
+
+ case 247:
+/* Line 1269 of yacc.c. */
+#line 3058 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new NodeComparison((yyvsp[(1) - (3)].expr), (yyvsp[(2) - (3)].enums.nodeOperator), (yyvsp[(3) - (3)].expr)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 248:
+/* Line 1269 of yacc.c. */
+#line 3062 "querytransformparser.ypp"
+ {(yyval.enums.nodeOperator) = QXmlNodeModelIndex::Is;}
+ break;
+
+ case 249:
+/* Line 1269 of yacc.c. */
+#line 3063 "querytransformparser.ypp"
+ {(yyval.enums.nodeOperator) = QXmlNodeModelIndex::Precedes;}
+ break;
+
+ case 250:
+/* Line 1269 of yacc.c. */
+#line 3064 "querytransformparser.ypp"
+ {(yyval.enums.nodeOperator) = QXmlNodeModelIndex::Follows;}
+ break;
+
+ case 251:
+/* Line 1269 of yacc.c. */
+#line 3067 "querytransformparser.ypp"
+ {
+ disallowedConstruct(parseInfo, (yyloc));
+ 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((yyloc), parseInfo));
+ /*
+ $$ = Validate::create($2, $1, parseInfo->staticContext);
+ */
+ }
+ break;
+
+ case 252:
+/* Line 1269 of yacc.c. */
+#line 3080 "querytransformparser.ypp"
+ {(yyval.enums.validationMode) = Validate::Strict;}
+ break;
+
+ case 253:
+/* Line 1269 of yacc.c. */
+#line 3081 "querytransformparser.ypp"
+ {(yyval.enums.validationMode) = Validate::Strict;}
+ break;
+
+ case 254:
+/* Line 1269 of yacc.c. */
+#line 3082 "querytransformparser.ypp"
+ {(yyval.enums.validationMode) = Validate::Lax;}
+ break;
+
+ case 255:
+/* Line 1269 of yacc.c. */
+#line 3085 "querytransformparser.ypp"
+ {
+ /* We don't support any pragmas, so we only do the
+ * necessary validation and use the fallback expression. */
+
+ if((yyvsp[(2) - (2)].expr))
+ (yyval.expr) = (yyvsp[(2) - (2)].expr);
+ else
+ {
+ parseInfo->staticContext->error(QtXmlPatterns::tr("None of the pragma expressions are supported. "
+ "Therefore, a fallback expression "
+ "must be present"),
+ ReportContext::XQST0079, fromYYLTYPE((yyloc), parseInfo));
+ }
+ }
+ break;
+
+ case 256:
+/* Line 1269 of yacc.c. */
+#line 3101 "querytransformparser.ypp"
+ {
+ (yyval.expr).reset();
+ }
+ break;
+
+ case 257:
+/* Line 1269 of yacc.c. */
+#line 3105 "querytransformparser.ypp"
+ {
+ (yyval.expr) = (yyvsp[(2) - (3)].expr);
+ }
+ break;
+
+ case 260:
+/* Line 1269 of yacc.c. */
+#line 3113 "querytransformparser.ypp"
+ {
+ disallowedConstruct(parseInfo, (yyloc));
+ }
+ break;
+
+ case 263:
+/* Line 1269 of yacc.c. */
+#line 3121 "querytransformparser.ypp"
+ {
+ /* This is "/step". That is, fn:root(self::node()) treat as document-node()/RelativePathExpr. */
+ (yyval.expr) = create(new Path(createRootExpression(parseInfo, (yyloc)), (yyvsp[(2) - (2)].expr)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 264:
+/* Line 1269 of yacc.c. */
+#line 3127 "querytransformparser.ypp"
+ {
+ (yyval.expr) = createSlashSlashPath(createRootExpression(parseInfo, (yyloc)), (yyvsp[(2) - (2)].expr), (yyloc), parseInfo);
+ }
+ break;
+
+ case 265:
+/* Line 1269 of yacc.c. */
+#line 3131 "querytransformparser.ypp"
+ {
+ /* This is "/". That is, fn:root(self::node()) treat as document-node(). */
+ (yyval.expr) = createRootExpression(parseInfo, (yyloc));
+ }
+ break;
+
+ case 268:
+/* Line 1269 of yacc.c. */
+#line 3141 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new Path((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), (yyvsp[(2) - (3)].enums.pathKind)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 269:
+/* Line 1269 of yacc.c. */
+#line 3145 "querytransformparser.ypp"
+ {
+ const Expression::Ptr orderBy(createReturnOrderBy((yyvsp[(4) - (7)].orderSpecs), (yyvsp[(6) - (7)].expr), parseInfo->orderStability.pop(), (yyloc), parseInfo));
+
+ ReturnOrderBy *const rob = orderBy->as<ReturnOrderBy>();
+ const Expression::Ptr path(create(new Path((yyvsp[(1) - (7)].expr), orderBy, (yyvsp[(2) - (7)].enums.pathKind)), (yyloc), parseInfo));
+
+ (yyval.expr) = create(new OrderBy(rob->stability(), rob->orderSpecs(), path, rob), (yyloc), parseInfo);
+ }
+ break;
+
+ case 270:
+/* Line 1269 of yacc.c. */
+#line 3154 "querytransformparser.ypp"
+ {
+ (yyval.expr) = createSlashSlashPath((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), (yyloc), parseInfo);
+ }
+ break;
+
+ case 271:
+/* Line 1269 of yacc.c. */
+#line 3159 "querytransformparser.ypp"
+ {
+ (yyval.expr) = NodeSortExpression::wrapAround((yyvsp[(1) - (1)].expr), parseInfo->staticContext);
+ }
+ break;
+
+ case 273:
+/* Line 1269 of yacc.c. */
+#line 3164 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new CurrentItemStore((yyvsp[(2) - (2)].expr)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 274:
+/* Line 1269 of yacc.c. */
+#line 3168 "querytransformparser.ypp"
+ {
+ const xsDouble version = (yyvsp[(1) - (1)].sval).toDouble();
+
+ parseInfo->isBackwardsCompat.push(version != 2);
+
+ (yyval.enums.Double) = version;
+ }
+ break;
+
+ case 275:
+/* Line 1269 of yacc.c. */
+#line 3176 "querytransformparser.ypp"
+ {
+ if((yyvsp[(2) - (3)].enums.Double) < 2)
+ (yyval.expr) = createCompatStore((yyvsp[(3) - (3)].expr), (yyloc), parseInfo);
+ else
+ (yyval.expr) = (yyvsp[(3) - (3)].expr);
+ }
+ break;
+
+ case 276:
+/* Line 1269 of yacc.c. */
+#line 3183 "querytransformparser.ypp"
+ {
+ Q_ASSERT(!(yyvsp[(2) - (5)].sval).isEmpty());
+ (yyval.expr) = create(new StaticBaseURIStore((yyvsp[(2) - (5)].sval), (yyvsp[(4) - (5)].expr)), (yyloc), parseInfo);
+}
+ break;
+
+ case 277:
+/* Line 1269 of yacc.c. */
+#line 3189 "querytransformparser.ypp"
+ {
+ parseInfo->resolvers.push(parseInfo->staticContext->namespaceBindings());
+ const NamespaceResolver::Ptr resolver(new DelegatingNamespaceResolver(parseInfo->staticContext->namespaceBindings()));
+ resolver->addBinding(QXmlName(parseInfo->staticContext->namePool()->allocateNamespace((yyvsp[(5) - (6)].sval)),
+ StandardLocalNames::empty,
+ parseInfo->staticContext->namePool()->allocatePrefix((yyvsp[(3) - (6)].sval))));
+ parseInfo->staticContext->setNamespaceBindings(resolver);
+ }
+ break;
+
+ case 278:
+/* Line 1269 of yacc.c. */
+#line 3199 "querytransformparser.ypp"
+ {
+ parseInfo->staticContext->setNamespaceBindings(parseInfo->resolvers.pop());
+ (yyval.expr) = (yyvsp[(8) - (9)].expr);
+ }
+ break;
+
+ case 279:
+/* Line 1269 of yacc.c. */
+#line 3204 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new CallTemplate((yyvsp[(2) - (5)].qName), parseInfo->templateWithParams), (yyloc), parseInfo);
+ parseInfo->templateWithParametersHandled();
+ parseInfo->templateCalls.append((yyval.expr));
+ }
+ break;
+
+ case 280:
+/* Line 1269 of yacc.c. */
+#line 3211 "querytransformparser.ypp"
+ {
+ parseInfo->startParsingWithParam();
+ }
+ break;
+
+ case 281:
+/* Line 1269 of yacc.c. */
+#line 3215 "querytransformparser.ypp"
+ {
+ parseInfo->endParsingWithParam();
+ }
+ break;
+
+ case 282:
+/* Line 1269 of yacc.c. */
+#line 3220 "querytransformparser.ypp"
+ {
+ }
+ break;
+
+ case 283:
+/* Line 1269 of yacc.c. */
+#line 3223 "querytransformparser.ypp"
+ {
+ }
+ break;
+
+ case 284:
+/* Line 1269 of yacc.c. */
+#line 3226 "querytransformparser.ypp"
+ {
+ }
+ break;
+
+ case 285:
+/* Line 1269 of yacc.c. */
+#line 3230 "querytransformparser.ypp"
+ {
+ }
+ break;
+
+ case 286:
+/* Line 1269 of yacc.c. */
+#line 3233 "querytransformparser.ypp"
+ {
+ }
+ break;
+
+ case 287:
+/* Line 1269 of yacc.c. */
+#line 3237 "querytransformparser.ypp"
+ {
+ /* 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(!(yyvsp[(4) - (5)].sequenceType)->is(CommonSequenceTypes::ZeroOrMoreItems))
+ type = (yyvsp[(4) - (5)].sequenceType);
+
+ Expression::Ptr expr;
+
+ /* The default value is an empty sequence. */
+ if(!(yyvsp[(5) - (5)].expr) && ((type && (yyvsp[(4) - (5)].sequenceType)->cardinality().allowsEmpty())
+ || isParsingWithParam))
+ expr = create(new EmptySequence, (yyloc), parseInfo);
+ else
+ expr = (yyvsp[(5) - (5)].expr);
+
+ /* We ensure we have some type, so CallTemplate, Template and friends
+ * are happy. */
+ if(!isParsingWithParam && !type)
+ type = CommonSequenceTypes::ZeroOrMoreItems;
+
+ if((yyvsp[(1) - (5)].enums.Bool))
+ /* TODO, handle tunnel parameters. */;
+ else
+ {
+ if((!isParsingWithParam && VariableDeclaration::contains(parseInfo->templateParameters, (yyvsp[(3) - (5)].qName))) ||
+ (isParsingWithParam && parseInfo->templateWithParams.contains((yyvsp[(3) - (5)].qName))))
+ {
+ parseInfo->staticContext->error(QtXmlPatterns::tr("Each name of a template parameter must be unique; %1 is duplicated.")
+ .arg(formatKeyword(parseInfo->staticContext->namePool(), (yyvsp[(3) - (5)].qName))),
+ isParsingWithParam ? ReportContext::XTSE0670 : ReportContext::XTSE0580, fromYYLTYPE((yyloc), parseInfo));
+ }
+ else
+ {
+ if(isParsingWithParam)
+ parseInfo->templateWithParams[(yyvsp[(3) - (5)].qName)] = WithParam::Ptr(new WithParam((yyvsp[(3) - (5)].qName), (yyvsp[(4) - (5)].sequenceType), expr));
+ else
+ {
+ Q_ASSERT(type);
+ pushVariable((yyvsp[(3) - (5)].qName), type, expr, VariableDeclaration::TemplateParameter, (yyloc), parseInfo);
+ parseInfo->templateParameters.append(parseInfo->variables.top());
+ }
+ }
+ }
+ }
+ break;
+
+ case 288:
+/* Line 1269 of yacc.c. */
+#line 3302 "querytransformparser.ypp"
+ {
+ (yyval.enums.Bool) = false;
+ }
+ break;
+
+ case 289:
+/* Line 1269 of yacc.c. */
+#line 3306 "querytransformparser.ypp"
+ {
+ (yyval.enums.Bool) = true;
+ }
+ break;
+
+ case 290:
+/* Line 1269 of yacc.c. */
+#line 3311 "querytransformparser.ypp"
+ {
+ (yyval.expr) = Expression::Ptr();
+ }
+ break;
+
+ case 291:
+/* Line 1269 of yacc.c. */
+#line 3315 "querytransformparser.ypp"
+ {
+ (yyval.expr) = (yyvsp[(2) - (2)].expr);
+ }
+ break;
+
+ case 292:
+/* Line 1269 of yacc.c. */
+#line 3324 "querytransformparser.ypp"
+ {
+ (yyval.enums.pathKind) = Path::RegularPath;
+ }
+ break;
+
+ case 293:
+/* Line 1269 of yacc.c. */
+#line 3328 "querytransformparser.ypp"
+ {
+ (yyval.enums.pathKind) = Path::XSLTForEach;
+ }
+ break;
+
+ case 294:
+/* Line 1269 of yacc.c. */
+#line 3332 "querytransformparser.ypp"
+ {
+ (yyval.enums.pathKind) = Path::ForApplyTemplate;
+ }
+ break;
+
+ case 296:
+/* Line 1269 of yacc.c. */
+#line 3338 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(GenericPredicate::create((yyvsp[(1) - (4)].expr), (yyvsp[(3) - (4)].expr), parseInfo->staticContext, fromYYLTYPE((yyloc), parseInfo)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 299:
+/* Line 1269 of yacc.c. */
+#line 3346 "querytransformparser.ypp"
+ {
+ if((yyvsp[(1) - (1)].enums.axis) == QXmlNodeModelIndex::AxisAttribute)
+ parseInfo->nodeTestSource = BuiltinTypes::attribute;
+ }
+ break;
+
+ case 300:
+/* Line 1269 of yacc.c. */
+#line 3351 "querytransformparser.ypp"
+ {
+ if((yyvsp[(3) - (3)].itemType))
+ {
+ /* A node test was explicitly specified. The un-abbreviated syntax was used. */
+ (yyval.expr) = create(new AxisStep((yyvsp[(1) - (3)].enums.axis), (yyvsp[(3) - (3)].itemType)), (yyloc), 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((yyvsp[(1) - (3)].enums.axis) == QXmlNodeModelIndex::AxisAttribute)
+ (yyval.expr) = create(new AxisStep(QXmlNodeModelIndex::AxisAttribute, BuiltinTypes::attribute), (yyloc), parseInfo);
+ else
+ (yyval.expr) = create(new AxisStep((yyvsp[(1) - (3)].enums.axis), BuiltinTypes::element), (yyloc), parseInfo);
+ }
+
+ parseInfo->restoreNodeTestSource();
+ }
+ break;
+
+ case 304:
+/* Line 1269 of yacc.c. */
+#line 3381 "querytransformparser.ypp"
+ {
+ if((yyvsp[(1) - (2)].enums.axis) == 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((yyloc), parseInfo));
+ }
+ else
+ (yyval.enums.axis) = (yyvsp[(1) - (2)].enums.axis);
+ }
+ break;
+
+ case 305:
+/* Line 1269 of yacc.c. */
+#line 3394 "querytransformparser.ypp"
+ {(yyval.enums.axis) = QXmlNodeModelIndex::AxisAncestorOrSelf ;}
+ break;
+
+ case 306:
+/* Line 1269 of yacc.c. */
+#line 3395 "querytransformparser.ypp"
+ {(yyval.enums.axis) = QXmlNodeModelIndex::AxisAncestor ;}
+ break;
+
+ case 307:
+/* Line 1269 of yacc.c. */
+#line 3396 "querytransformparser.ypp"
+ {(yyval.enums.axis) = QXmlNodeModelIndex::AxisAttribute ;}
+ break;
+
+ case 308:
+/* Line 1269 of yacc.c. */
+#line 3397 "querytransformparser.ypp"
+ {(yyval.enums.axis) = QXmlNodeModelIndex::AxisChild ;}
+ break;
+
+ case 309:
+/* Line 1269 of yacc.c. */
+#line 3398 "querytransformparser.ypp"
+ {(yyval.enums.axis) = QXmlNodeModelIndex::AxisDescendantOrSelf;}
+ break;
+
+ case 310:
+/* Line 1269 of yacc.c. */
+#line 3399 "querytransformparser.ypp"
+ {(yyval.enums.axis) = QXmlNodeModelIndex::AxisDescendant ;}
+ break;
+
+ case 311:
+/* Line 1269 of yacc.c. */
+#line 3400 "querytransformparser.ypp"
+ {(yyval.enums.axis) = QXmlNodeModelIndex::AxisFollowing ;}
+ break;
+
+ case 312:
+/* Line 1269 of yacc.c. */
+#line 3401 "querytransformparser.ypp"
+ {(yyval.enums.axis) = QXmlNodeModelIndex::AxisPreceding ;}
+ break;
+
+ case 313:
+/* Line 1269 of yacc.c. */
+#line 3402 "querytransformparser.ypp"
+ {(yyval.enums.axis) = QXmlNodeModelIndex::AxisFollowingSibling;}
+ break;
+
+ case 314:
+/* Line 1269 of yacc.c. */
+#line 3403 "querytransformparser.ypp"
+ {(yyval.enums.axis) = QXmlNodeModelIndex::AxisPrecedingSibling;}
+ break;
+
+ case 315:
+/* Line 1269 of yacc.c. */
+#line 3404 "querytransformparser.ypp"
+ {(yyval.enums.axis) = QXmlNodeModelIndex::AxisParent ;}
+ break;
+
+ case 316:
+/* Line 1269 of yacc.c. */
+#line 3405 "querytransformparser.ypp"
+ {(yyval.enums.axis) = QXmlNodeModelIndex::AxisSelf ;}
+ break;
+
+ case 317:
+/* Line 1269 of yacc.c. */
+#line 3408 "querytransformparser.ypp"
+ {
+ parseInfo->nodeTestSource = BuiltinTypes::attribute;
+ }
+ break;
+
+ case 318:
+/* Line 1269 of yacc.c. */
+#line 3412 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new AxisStep(QXmlNodeModelIndex::AxisAttribute, (yyvsp[(3) - (3)].itemType)), (yyloc), parseInfo);
+
+ parseInfo->restoreNodeTestSource();
+ }
+ break;
+
+ case 319:
+/* Line 1269 of yacc.c. */
+#line 3418 "querytransformparser.ypp"
+ {
+ ItemType::Ptr nodeTest;
+
+ if(parseInfo->isParsingPattern && *(yyvsp[(1) - (1)].itemType) == *BuiltinTypes::node)
+ nodeTest = BuiltinTypes::xsltNodeTest;
+ else
+ nodeTest = (yyvsp[(1) - (1)].itemType);
+
+ (yyval.expr) = create(new AxisStep(QXmlNodeModelIndex::AxisChild, nodeTest), (yyloc), parseInfo);
+ }
+ break;
+
+ case 320:
+/* Line 1269 of yacc.c. */
+#line 3429 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new AxisStep(QXmlNodeModelIndex::AxisAttribute, (yyvsp[(1) - (1)].itemType)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 322:
+/* Line 1269 of yacc.c. */
+#line 3436 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new AxisStep(QXmlNodeModelIndex::AxisParent, BuiltinTypes::node), (yyloc), parseInfo);
+ }
+ break;
+
+ case 325:
+/* Line 1269 of yacc.c. */
+#line 3444 "querytransformparser.ypp"
+ {
+ (yyval.itemType) = QNameTest::create(parseInfo->nodeTestSource, (yyvsp[(1) - (1)].qName));
+ }
+ break;
+
+ case 327:
+/* Line 1269 of yacc.c. */
+#line 3450 "querytransformparser.ypp"
+ {
+ (yyval.itemType) = parseInfo->nodeTestSource;
+ }
+ break;
+
+ case 328:
+/* Line 1269 of yacc.c. */
+#line 3454 "querytransformparser.ypp"
+ {
+ const NamePool::Ptr np(parseInfo->staticContext->namePool());
+ const ReflectYYLTYPE ryy((yyloc), parseInfo);
+
+ const QXmlName::NamespaceCode ns(QNameConstructor::namespaceForPrefix(np->allocatePrefix((yyvsp[(1) - (1)].sval)), parseInfo->staticContext, &ryy));
+
+ (yyval.itemType) = NamespaceNameTest::create(parseInfo->nodeTestSource, ns);
+ }
+ break;
+
+ case 329:
+/* Line 1269 of yacc.c. */
+#line 3463 "querytransformparser.ypp"
+ {
+ const QXmlName::LocalNameCode c = parseInfo->staticContext->namePool()->allocateLocalName((yyvsp[(1) - (1)].sval));
+ (yyval.itemType) = LocalNameTest::create(parseInfo->nodeTestSource, c);
+ }
+ break;
+
+ case 331:
+/* Line 1269 of yacc.c. */
+#line 3470 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(GenericPredicate::create((yyvsp[(1) - (4)].expr), (yyvsp[(3) - (4)].expr), parseInfo->staticContext, fromYYLTYPE((yylsp[(4) - (4)]), parseInfo)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 339:
+/* Line 1269 of yacc.c. */
+#line 3482 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new ApplyTemplate(parseInfo->modeFor((yyvsp[(2) - (5)].qName)),
+ parseInfo->templateWithParams,
+ parseInfo->modeFor(QXmlName(StandardNamespaces::InternalXSLT,
+ StandardLocalNames::Default))),
+ (yylsp[(1) - (5)]), parseInfo);
+ parseInfo->templateWithParametersHandled();
+ }
+ break;
+
+ case 341:
+/* Line 1269 of yacc.c. */
+#line 3493 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new Literal(AtomicString::fromValue((yyvsp[(1) - (1)].sval))), (yyloc), parseInfo);
+ }
+ break;
+
+ case 342:
+/* Line 1269 of yacc.c. */
+#line 3498 "querytransformparser.ypp"
+ {
+ (yyval.expr) = createNumericLiteral<Double>((yyvsp[(1) - (1)].sval), (yyloc), parseInfo);
+ }
+ break;
+
+ case 343:
+/* Line 1269 of yacc.c. */
+#line 3502 "querytransformparser.ypp"
+ {
+ (yyval.expr) = createNumericLiteral<Numeric>((yyvsp[(1) - (1)].sval), (yyloc), parseInfo);
+ }
+ break;
+
+ case 344:
+/* Line 1269 of yacc.c. */
+#line 3507 "querytransformparser.ypp"
+ {
+ (yyval.expr) = resolveVariable((yyvsp[(2) - (2)].qName), (yyloc), parseInfo, false);
+ }
+ break;
+
+ case 345:
+/* Line 1269 of yacc.c. */
+#line 3512 "querytransformparser.ypp"
+ {
+ /* See: http://www.w3.org/TR/xpath20/#id-variables */
+ (yyval.qName) = parseInfo->staticContext->namePool()->allocateQName(QString(), (yyvsp[(1) - (1)].sval));
+ }
+ break;
+
+ case 346:
+/* Line 1269 of yacc.c. */
+#line 3517 "querytransformparser.ypp"
+ {
+ (yyval.qName) = (yyvsp[(1) - (1)].qName);
+ }
+ break;
+
+ case 347:
+/* Line 1269 of yacc.c. */
+#line 3522 "querytransformparser.ypp"
+ {
+ (yyval.expr) = (yyvsp[(2) - (3)].expr);
+ }
+ break;
+
+ case 348:
+/* Line 1269 of yacc.c. */
+#line 3526 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new EmptySequence, (yyloc), parseInfo);
+ }
+ break;
+
+ case 349:
+/* Line 1269 of yacc.c. */
+#line 3531 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new ContextItem(), (yyloc), parseInfo);
+ }
+ break;
+
+ case 350:
+/* Line 1269 of yacc.c. */
+#line 3536 "querytransformparser.ypp"
+ {
+ (yyval.expr) = (yyvsp[(2) - (2)].expr);
+ }
+ break;
+
+ case 351:
+/* Line 1269 of yacc.c. */
+#line 3541 "querytransformparser.ypp"
+ {
+ if(XPathHelper::isReservedNamespace((yyvsp[(1) - (4)].qName).namespaceURI()) || (yyvsp[(1) - (4)].qName).namespaceURI() == StandardNamespaces::InternalXSLT)
+ { /* We got a call to a builtin function. */
+ const ReflectYYLTYPE ryy((yyloc), parseInfo);
+
+ const Expression::Ptr
+ func(parseInfo->staticContext->
+ functionSignatures()->createFunctionCall((yyvsp[(1) - (4)].qName), (yyvsp[(3) - (4)].expressionList), parseInfo->staticContext, &ryy));
+
+ if(func)
+ (yyval.expr) = create(func, (yyloc), parseInfo);
+ else
+ {
+ parseInfo->staticContext->error(QtXmlPatterns::tr("No function by name %1 is available.")
+ .arg(formatKeyword(parseInfo->staticContext->namePool(), (yyvsp[(1) - (4)].qName))),
+ ReportContext::XPST0017, fromYYLTYPE((yyloc), parseInfo));
+ }
+ }
+ else /* It's a call to a function created with 'declare function'.*/
+ {
+ (yyval.expr) = create(new UserFunctionCallsite((yyvsp[(1) - (4)].qName), (yyvsp[(3) - (4)].expressionList).count()), (yyloc), parseInfo);
+
+ (yyval.expr)->setOperands((yyvsp[(3) - (4)].expressionList));
+ parseInfo->userFunctionCallsites.append((yyval.expr));
+ }
+ }
+ break;
+
+ case 352:
+/* Line 1269 of yacc.c. */
+#line 3569 "querytransformparser.ypp"
+ {
+ (yyval.expressionList) = Expression::List();
+ }
+ break;
+
+ case 353:
+/* Line 1269 of yacc.c. */
+#line 3574 "querytransformparser.ypp"
+ {
+ Expression::List list;
+ list.append((yyvsp[(1) - (1)].expr));
+ (yyval.expressionList) = list;
+ }
+ break;
+
+ case 355:
+/* Line 1269 of yacc.c. */
+#line 3583 "querytransformparser.ypp"
+ {
+ disallowedConstruct(parseInfo, (yyloc));
+ }
+ break;
+
+ case 360:
+/* Line 1269 of yacc.c. */
+#line 3624 "querytransformparser.ypp"
+ {
+ (yyval.enums.tokenizerPosition) = parseInfo->tokenizer->commenceScanOnly();
+ parseInfo->scanOnlyStack.push(true);
+ }
+ break;
+
+ case 361:
+/* Line 1269 of yacc.c. */
+#line 3633 "querytransformparser.ypp"
+ {
+ ++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 = (yyvsp[(4) - (4)].attributeHolders).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((yyvsp[(4) - (4)].attributeHolders).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((yyvsp[(4) - (4)].attributeHolders).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((yyloc), parseInfo));
+ }
+ }
+ else if(!AnyURI::isValid(strNamespace))
+ {
+ parseInfo->staticContext->error(QtXmlPatterns::tr("%1 is an invalid namespace URI.").arg(formatURI(strNamespace)),
+ ReportContext::XQST0022, fromYYLTYPE((yyloc), 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((yyloc), 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((yyloc), 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((yyloc), 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((yyloc), 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), (yyloc), 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), (yyloc), parseInfo));
+ }
+
+ parseInfo->staticContext->setNamespaceBindings(resolver);
+ (yyval.expressionList) = constructors;
+
+ /* Resolve the name of the element, now that the namespace attributes are read. */
+ {
+ const ReflectYYLTYPE ryy((yyloc), parseInfo);
+
+ const QXmlName ele = QNameConstructor::expandQName<StaticContext::Ptr,
+ ReportContext::XPST0081,
+ ReportContext::XPST0081>((yyvsp[(2) - (4)].sval), parseInfo->staticContext, resolver, &ryy);
+ parseInfo->tagStack.push(ele);
+ }
+
+ parseInfo->tokenizer->resumeTokenizationFrom((yyvsp[(3) - (4)].enums.tokenizerPosition));
+ }
+ break;
+
+ case 362:
+/* Line 1269 of yacc.c. */
+#line 3779 "querytransformparser.ypp"
+ {
+ /* 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((yyvsp[(5) - (8)].expressionList));
+ const NamePool::Ptr namePool(parseInfo->staticContext->namePool());
+ const int len = (yyvsp[(7) - (8)].attributeHolders).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((yyvsp[(7) - (8)].attributeHolders).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 = (yyvsp[(7) - (8)].attributeHolders).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((yyloc), parseInfo));
+ }
+
+ }
+ else
+ {
+ const ReflectYYLTYPE ryy((yyloc), parseInfo);
+ const QXmlName att = QNameConstructor::expandQName<StaticContext::Ptr,
+ ReportContext::XPST0081,
+ ReportContext::XPST0081>((yyvsp[(7) - (8)].attributeHolders).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((yyloc), 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((yyvsp[(7) - (8)].attributeHolders).at(i).second, (yyvsp[(7) - (8)].attributeHolders).at(i).second), (yyloc), parseInfo));
+
+ Expression::List ops;
+ ops.append(wrapLiteral(toItem(QNameValue::fromValue(namePool, att)), parseInfo->staticContext, ctor.data()));
+ ops.append((yyvsp[(7) - (8)].attributeHolders).at(i).second);
+ ctor->setOperands(ops);
+
+ attributes.append(ctor);
+ }
+ }
+
+ Expression::Ptr contentOp;
+
+ if(attributes.isEmpty())
+ contentOp = (yyvsp[(8) - (8)].expr);
+ else
+ {
+ attributes.append((yyvsp[(8) - (8)].expr));
+ contentOp = create(new ExpressionSequence(attributes), (yyloc), parseInfo);
+ }
+
+ const Expression::Ptr name(create(new Literal(toItem(QNameValue::fromValue(parseInfo->staticContext->namePool(), parseInfo->tagStack.top()))), (yyloc), parseInfo));
+ (yyval.expr) = create(new ElementConstructor(name, contentOp, parseInfo->isXSLT()), (yyloc), 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;
+ }
+ break;
+
+ case 363:
+/* Line 1269 of yacc.c. */
+#line 3875 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new EmptySequence(), (yyloc), parseInfo);
+ }
+ break;
+
+ case 364:
+/* Line 1269 of yacc.c. */
+#line 3879 "querytransformparser.ypp"
+ {
+ if(!(yyvsp[(4) - (5)].qName).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((yyvsp[(4) - (5)].qName)))),
+ ReportContext::XPST0003, fromYYLTYPE((yyloc), parseInfo));
+ }
+
+ if((yyvsp[(2) - (5)].expressionList).isEmpty())
+ (yyval.expr) = create(new EmptySequence(), (yyloc), parseInfo);
+ else if((yyvsp[(2) - (5)].expressionList).size() == 1)
+ (yyval.expr) = (yyvsp[(2) - (5)].expressionList).first();
+ else
+ (yyval.expr) = create(new ExpressionSequence((yyvsp[(2) - (5)].expressionList)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 365:
+/* Line 1269 of yacc.c. */
+#line 3898 "querytransformparser.ypp"
+ {
+ (yyval.attributeHolders) = AttributeHolderVector();
+ }
+ break;
+
+ case 366:
+/* Line 1269 of yacc.c. */
+#line 3902 "querytransformparser.ypp"
+ {
+ (yyvsp[(1) - (2)].attributeHolders).append((yyvsp[(2) - (2)].attributeHolder));
+ (yyval.attributeHolders) = (yyvsp[(1) - (2)].attributeHolders);
+ }
+ break;
+
+ case 367:
+/* Line 1269 of yacc.c. */
+#line 3908 "querytransformparser.ypp"
+ {
+ (yyval.attributeHolder) = qMakePair((yyvsp[(1) - (3)].sval), (yyvsp[(3) - (3)].expr));
+ }
+ break;
+
+ case 368:
+/* Line 1269 of yacc.c. */
+#line 3913 "querytransformparser.ypp"
+ {
+ (yyval.expr) = createDirAttributeValue((yyvsp[(2) - (3)].expressionList), parseInfo, (yyloc));
+ }
+ break;
+
+ case 369:
+/* Line 1269 of yacc.c. */
+#line 3918 "querytransformparser.ypp"
+ {
+ (yyval.expr) = createDirAttributeValue((yyvsp[(2) - (3)].expressionList), parseInfo, (yyloc));
+ }
+ break;
+
+ case 370:
+/* Line 1269 of yacc.c. */
+#line 3923 "querytransformparser.ypp"
+ {
+ (yyval.expressionList) = Expression::List();
+ }
+ break;
+
+ case 371:
+/* Line 1269 of yacc.c. */
+#line 3927 "querytransformparser.ypp"
+ {
+ Expression::Ptr content((yyvsp[(1) - (2)].expr));
+
+ if(parseInfo->isBackwardsCompat.top())
+ content = create(GenericPredicate::createFirstItem(content), (yyloc), parseInfo);
+
+ (yyvsp[(2) - (2)].expressionList).prepend(createSimpleContent(content, (yyloc), parseInfo));
+ (yyval.expressionList) = (yyvsp[(2) - (2)].expressionList);
+ }
+ break;
+
+ case 372:
+/* Line 1269 of yacc.c. */
+#line 3937 "querytransformparser.ypp"
+ {
+ (yyvsp[(2) - (2)].expressionList).prepend(create(new Literal(AtomicString::fromValue((yyvsp[(1) - (2)].sval))), (yyloc), parseInfo));
+ (yyval.expressionList) = (yyvsp[(2) - (2)].expressionList);
+ }
+ break;
+
+ case 373:
+/* Line 1269 of yacc.c. */
+#line 3943 "querytransformparser.ypp"
+ {
+ (yyval.expressionList) = Expression::List();
+ parseInfo->isPreviousEnclosedExpr = false;
+ }
+ break;
+
+ case 374:
+/* Line 1269 of yacc.c. */
+#line 3948 "querytransformparser.ypp"
+ {
+ (yyvsp[(1) - (2)].expressionList).append((yyvsp[(2) - (2)].expr));
+ (yyval.expressionList) = (yyvsp[(1) - (2)].expressionList);
+ parseInfo->isPreviousEnclosedExpr = false;
+ }
+ break;
+
+ case 375:
+/* Line 1269 of yacc.c. */
+#line 3954 "querytransformparser.ypp"
+ {
+ if(parseInfo->staticContext->boundarySpacePolicy() == StaticContext::BSPStrip &&
+ XPathHelper::isWhitespaceOnly((yyvsp[(2) - (2)].sval)))
+ {
+ (yyval.expressionList) = (yyvsp[(1) - (2)].expressionList);
+ }
+ else
+ {
+ (yyvsp[(1) - (2)].expressionList).append(create(new TextNodeConstructor(create(new Literal(AtomicString::fromValue((yyvsp[(2) - (2)].sval))), (yyloc), parseInfo)), (yyloc), parseInfo));
+ (yyval.expressionList) = (yyvsp[(1) - (2)].expressionList);
+ parseInfo->isPreviousEnclosedExpr = false;
+ }
+ }
+ break;
+
+ case 376:
+/* Line 1269 of yacc.c. */
+#line 3968 "querytransformparser.ypp"
+ {
+ (yyvsp[(1) - (2)].expressionList).append(create(new TextNodeConstructor(create(new Literal(AtomicString::fromValue((yyvsp[(2) - (2)].sval))), (yyloc), parseInfo)), (yyloc), parseInfo));
+ (yyval.expressionList) = (yyvsp[(1) - (2)].expressionList);
+ parseInfo->isPreviousEnclosedExpr = false;
+ }
+ break;
+
+ case 377:
+/* Line 1269 of yacc.c. */
+#line 3974 "querytransformparser.ypp"
+ {
+ /* 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((yyvsp[(2) - (2)].expr)->staticType()->itemType()) &&
+ BuiltinTypes::xsAnyAtomicType->xdtTypeMatches((yyvsp[(1) - (2)].expressionList).last()->staticType()->itemType()))
+ (yyvsp[(1) - (2)].expressionList).append(create(new TextNodeConstructor(create(new Literal(AtomicString::fromValue(QString())), (yyloc), parseInfo)), (yyloc), parseInfo));
+ else
+ parseInfo->isPreviousEnclosedExpr = true;
+
+ (yyvsp[(1) - (2)].expressionList).append(createCopyOf((yyvsp[(2) - (2)].expr), parseInfo, (yyloc)));
+ (yyval.expressionList) = (yyvsp[(1) - (2)].expressionList);
+ }
+ break;
+
+ case 378:
+/* Line 1269 of yacc.c. */
+#line 3991 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new CommentConstructor(create(new Literal(AtomicString::fromValue((yyvsp[(2) - (2)].sval))), (yyloc), parseInfo)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 379:
+/* Line 1269 of yacc.c. */
+#line 3996 "querytransformparser.ypp"
+ {
+ const ReflectYYLTYPE ryy((yyloc), parseInfo);
+ NCNameConstructor::validateTargetName<StaticContext::Ptr,
+ ReportContext::XPST0003,
+ ReportContext::XPST0003>((yyvsp[(2) - (3)].sval),
+ parseInfo->staticContext, &ryy);
+
+ (yyval.expr) = create(new ProcessingInstructionConstructor(
+ create(new Literal(AtomicString::fromValue((yyvsp[(2) - (3)].sval))), (yyloc), parseInfo),
+ create(new Literal(AtomicString::fromValue((yyvsp[(3) - (3)].sval))), (yyloc), parseInfo)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 387:
+/* Line 1269 of yacc.c. */
+#line 4017 "querytransformparser.ypp"
+ {
+ disallowedConstruct(parseInfo, (yyloc), (yyvsp[(2) - (3)].enums.Bool));
+
+ (yyval.expr) = create(new DocumentConstructor((yyvsp[(3) - (3)].expr)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 388:
+/* Line 1269 of yacc.c. */
+#line 4024 "querytransformparser.ypp"
+ {
+ /* This value is incremented before the action below is executed. */
+ ++parseInfo->elementConstructorDepth;
+ }
+ break;
+
+ case 389:
+/* Line 1269 of yacc.c. */
+#line 4029 "querytransformparser.ypp"
+ {
+ Q_ASSERT(5);
+ disallowedConstruct(parseInfo, (yyloc), (yyvsp[(2) - (5)].enums.Bool));
+
+ Expression::Ptr effExpr;
+
+ if((yyvsp[(5) - (5)].expr))
+ effExpr = createCopyOf((yyvsp[(5) - (5)].expr), parseInfo, (yyloc));
+ else
+ effExpr = create(new EmptySequence(), (yyloc), 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), (yyloc), parseInfo));
+
+ exprList.append(effExpr);
+
+ effExpr = create(new ExpressionSequence(exprList), (yyloc), parseInfo);
+ }
+
+ --parseInfo->elementConstructorDepth;
+ (yyval.expr) = create(new ElementConstructor((yyvsp[(3) - (5)].expr), effExpr, parseInfo->isXSLT()), (yyloc), parseInfo);
+ }
+ break;
+
+ case 390:
+/* Line 1269 of yacc.c. */
+#line 4063 "querytransformparser.ypp"
+ {
+ (yyval.enums.Bool) = false;
+ }
+ break;
+
+ case 391:
+/* Line 1269 of yacc.c. */
+#line 4067 "querytransformparser.ypp"
+ {
+ (yyval.enums.Bool) = true;
+ }
+ break;
+
+ case 392:
+/* Line 1269 of yacc.c. */
+#line 4075 "querytransformparser.ypp"
+ {
+ disallowedConstruct(parseInfo, (yyloc), (yyvsp[(2) - (4)].enums.Bool));
+
+ const Expression::Ptr name(create(new AttributeNameValidator((yyvsp[(3) - (4)].expr)), (yyloc), parseInfo));
+
+ if((yyvsp[(4) - (4)].expr))
+ (yyval.expr) = create(new AttributeConstructor(name, createSimpleContent((yyvsp[(4) - (4)].expr), (yyloc), parseInfo)), (yyloc), parseInfo);
+ else
+ (yyval.expr) = create(new AttributeConstructor(name, create(new EmptySequence(), (yyloc), parseInfo)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 393:
+/* Line 1269 of yacc.c. */
+#line 4087 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new TextNodeConstructor(createSimpleContent((yyvsp[(3) - (3)].expr), (yyloc), parseInfo)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 394:
+/* Line 1269 of yacc.c. */
+#line 4092 "querytransformparser.ypp"
+ {
+ disallowedConstruct(parseInfo, (yyloc), (yyvsp[(2) - (3)].enums.Bool));
+
+ (yyval.expr) = create(new CommentConstructor(createSimpleContent((yyvsp[(3) - (3)].expr), (yyloc), parseInfo)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 395:
+/* Line 1269 of yacc.c. */
+#line 4099 "querytransformparser.ypp"
+ {
+ disallowedConstruct(parseInfo, (yyloc), (yyvsp[(2) - (3)].expr));
+
+ if((yyvsp[(3) - (3)].expr))
+ {
+ (yyval.expr) = create(new ProcessingInstructionConstructor((yyvsp[(2) - (3)].expr), createSimpleContent((yyvsp[(3) - (3)].expr), (yyloc), parseInfo)), (yyloc), parseInfo);
+ }
+ else
+ (yyval.expr) = create(new ProcessingInstructionConstructor((yyvsp[(2) - (3)].expr), create(new EmptySequence(), (yyloc), parseInfo)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 396:
+/* Line 1269 of yacc.c. */
+#line 4110 "querytransformparser.ypp"
+ {
+ parseInfo->nodeTestSource = BuiltinTypes::attribute;
+ }
+ break;
+
+ case 397:
+/* Line 1269 of yacc.c. */
+#line 4114 "querytransformparser.ypp"
+ {
+ parseInfo->restoreNodeTestSource();
+ }
+ break;
+
+ case 398:
+/* Line 1269 of yacc.c. */
+#line 4117 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new Literal(toItem(QNameValue::fromValue(parseInfo->staticContext->namePool(), (yyvsp[(2) - (3)].qName)))), (yyloc), parseInfo);
+ }
+ break;
+
+ case 400:
+/* Line 1269 of yacc.c. */
+#line 4123 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new Literal(toItem(QNameValue::fromValue(parseInfo->staticContext->namePool(), (yyvsp[(1) - (1)].qName)))), (yyloc), parseInfo);
+ }
+ break;
+
+ case 402:
+/* Line 1269 of yacc.c. */
+#line 4129 "querytransformparser.ypp"
+ {
+ if(BuiltinTypes::xsQName->xdtTypeMatches((yyvsp[(1) - (1)].expr)->staticType()->itemType()))
+ (yyval.expr) = (yyvsp[(1) - (1)].expr);
+ else
+ {
+ (yyval.expr) = create(new QNameConstructor((yyvsp[(1) - (1)].expr),
+ parseInfo->staticContext->namespaceBindings()),
+ (yyloc), parseInfo);
+ }
+ }
+ break;
+
+ case 403:
+/* Line 1269 of yacc.c. */
+#line 4144 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new NCNameConstructor(create(new Literal(AtomicString::fromValue((yyvsp[(1) - (1)].sval))), (yyloc), parseInfo)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 404:
+/* Line 1269 of yacc.c. */
+#line 4148 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new NCNameConstructor((yyvsp[(1) - (1)].expr)), (yyloc), parseInfo);
+ }
+ break;
+
+ case 405:
+/* Line 1269 of yacc.c. */
+#line 4157 "querytransformparser.ypp"
+ {
+ (yyval.expr) = create(new ComputedNamespaceConstructor((yyvsp[(2) - (3)].expr), (yyvsp[(3) - (3)].expr)), (yyloc), parseInfo);
+}
+ break;
+
+ case 406:
+/* Line 1269 of yacc.c. */
+#line 4162 "querytransformparser.ypp"
+ {
+ (yyval.sequenceType) = makeGenericSequenceType((yyvsp[(1) - (1)].itemType), Cardinality::exactlyOne());
+ }
+ break;
+
+ case 407:
+/* Line 1269 of yacc.c. */
+#line 4166 "querytransformparser.ypp"
+ {
+ (yyval.sequenceType) = makeGenericSequenceType((yyvsp[(1) - (2)].itemType), Cardinality::zeroOrOne());
+ }
+ break;
+
+ case 408:
+/* Line 1269 of yacc.c. */
+#line 4171 "querytransformparser.ypp"
+ {
+ (yyval.sequenceType) = CommonSequenceTypes::ZeroOrMoreItems;
+ }
+ break;
+
+ case 409:
+/* Line 1269 of yacc.c. */
+#line 4175 "querytransformparser.ypp"
+ {
+ (yyval.sequenceType) = (yyvsp[(2) - (2)].sequenceType);
+ }
+ break;
+
+ case 410:
+/* Line 1269 of yacc.c. */
+#line 4180 "querytransformparser.ypp"
+ {
+ (yyval.sequenceType) = makeGenericSequenceType((yyvsp[(1) - (2)].itemType), (yyvsp[(2) - (2)].cardinality));
+ }
+ break;
+
+ case 411:
+/* Line 1269 of yacc.c. */
+#line 4185 "querytransformparser.ypp"
+ {
+ (yyval.sequenceType) = CommonSequenceTypes::Empty;
+ }
+ break;
+
+ case 412:
+/* Line 1269 of yacc.c. */
+#line 4189 "querytransformparser.ypp"
+ {(yyval.cardinality) = Cardinality::exactlyOne();}
+ break;
+
+ case 413:
+/* Line 1269 of yacc.c. */
+#line 4190 "querytransformparser.ypp"
+ {(yyval.cardinality) = Cardinality::oneOrMore();}
+ break;
+
+ case 414:
+/* Line 1269 of yacc.c. */
+#line 4191 "querytransformparser.ypp"
+ {(yyval.cardinality) = Cardinality::zeroOrMore();}
+ break;
+
+ case 415:
+/* Line 1269 of yacc.c. */
+#line 4192 "querytransformparser.ypp"
+ {(yyval.cardinality) = Cardinality::zeroOrOne();}
+ break;
+
+ case 419:
+/* Line 1269 of yacc.c. */
+#line 4198 "querytransformparser.ypp"
+ {
+ (yyval.itemType) = BuiltinTypes::item;
+ }
+ break;
+
+ case 420:
+/* Line 1269 of yacc.c. */
+#line 4203 "querytransformparser.ypp"
+ {
+ const SchemaType::Ptr t(parseInfo->staticContext->schemaDefinitions()->createSchemaType((yyvsp[(1) - (1)].qName)));
+
+ if(!t)
+ {
+ parseInfo->staticContext->error(QtXmlPatterns::tr("The name %1 does not refer to any schema type.")
+ .arg(formatKeyword(parseInfo->staticContext->namePool(), (yyvsp[(1) - (1)].qName))), ReportContext::XPST0051, fromYYLTYPE((yyloc), parseInfo));
+ }
+ else if(BuiltinTypes::xsAnyAtomicType->wxsTypeMatches(t))
+ (yyval.itemType) = 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((yyloc), 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((yyloc), parseInfo));
+ }
+ }
+ }
+ break;
+
+ case 428:
+/* Line 1269 of yacc.c. */
+#line 4247 "querytransformparser.ypp"
+ {
+ (yyval.itemType) = BuiltinTypes::node;
+ }
+ break;
+
+ case 429:
+/* Line 1269 of yacc.c. */
+#line 4252 "querytransformparser.ypp"
+ {
+ (yyval.itemType) = BuiltinTypes::document;
+ }
+ break;
+
+ case 430:
+/* Line 1269 of yacc.c. */
+#line 4257 "querytransformparser.ypp"
+ {
+ // TODO support for document element testing
+ (yyval.itemType) = BuiltinTypes::document;
+ }
+ break;
+
+ case 433:
+/* Line 1269 of yacc.c. */
+#line 4266 "querytransformparser.ypp"
+ {
+ (yyval.itemType) = BuiltinTypes::text;
+ }
+ break;
+
+ case 434:
+/* Line 1269 of yacc.c. */
+#line 4271 "querytransformparser.ypp"
+ {
+ (yyval.itemType) = BuiltinTypes::comment;
+ }
+ break;
+
+ case 435:
+/* Line 1269 of yacc.c. */
+#line 4276 "querytransformparser.ypp"
+ {
+ (yyval.itemType) = BuiltinTypes::pi;
+ }
+ break;
+
+ case 436:
+/* Line 1269 of yacc.c. */
+#line 4281 "querytransformparser.ypp"
+ {
+ (yyval.itemType) = LocalNameTest::create(BuiltinTypes::pi, parseInfo->staticContext->namePool()->allocateLocalName((yyvsp[(3) - (4)].sval)));
+ }
+ break;
+
+ case 437:
+/* Line 1269 of yacc.c. */
+#line 4286 "querytransformparser.ypp"
+ {
+ if(QXmlUtils::isNCName((yyvsp[(3) - (4)].sval)))
+ {
+ (yyval.itemType) = LocalNameTest::create(BuiltinTypes::pi, parseInfo->staticContext->namePool()->allocateLocalName((yyvsp[(3) - (4)].sval)));
+ }
+ else
+ {
+ parseInfo->staticContext->error(QtXmlPatterns::tr("%1 is not a valid name for a "
+ "processing-instruction.")
+ .arg(formatKeyword((yyvsp[(3) - (4)].sval))),
+ ReportContext::XPTY0004,
+ fromYYLTYPE((yyloc), parseInfo));
+ }
+ }
+ break;
+
+ case 440:
+/* Line 1269 of yacc.c. */
+#line 4305 "querytransformparser.ypp"
+ {
+ (yyval.itemType) = BuiltinTypes::attribute;
+ }
+ break;
+
+ case 441:
+/* Line 1269 of yacc.c. */
+#line 4310 "querytransformparser.ypp"
+ {
+ (yyval.itemType) = BuiltinTypes::attribute;
+ }
+ break;
+
+ case 442:
+/* Line 1269 of yacc.c. */
+#line 4315 "querytransformparser.ypp"
+ {
+ (yyval.itemType) = QNameTest::create(BuiltinTypes::attribute, (yyvsp[(3) - (4)].qName));
+ }
+ break;
+
+ case 443:
+/* Line 1269 of yacc.c. */
+#line 4319 "querytransformparser.ypp"
+ {
+ const SchemaType::Ptr t(parseInfo->staticContext->schemaDefinitions()->createSchemaType((yyvsp[(5) - (6)].qName)));
+
+ if(t)
+ (yyval.itemType) = BuiltinTypes::attribute;
+ else
+ {
+ parseInfo->staticContext->error(unknownType().arg(formatKeyword(parseInfo->staticContext->namePool(), (yyvsp[(5) - (6)].qName))),
+ ReportContext::XPST0008, fromYYLTYPE((yyloc), parseInfo));
+ }
+ }
+ break;
+
+ case 444:
+/* Line 1269 of yacc.c. */
+#line 4331 "querytransformparser.ypp"
+ {
+ const SchemaType::Ptr t(parseInfo->staticContext->schemaDefinitions()->createSchemaType((yyvsp[(5) - (6)].qName)));
+
+ if(t)
+ (yyval.itemType) = BuiltinTypes::attribute;
+ else
+ {
+ parseInfo->staticContext->error(unknownType().arg(formatKeyword(parseInfo->staticContext->namePool(), (yyvsp[(5) - (6)].qName))),
+ ReportContext::XPST0008, fromYYLTYPE((yyloc), parseInfo));
+ }
+ }
+ break;
+
+ case 445:
+/* Line 1269 of yacc.c. */
+#line 4344 "querytransformparser.ypp"
+ {
+ 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(), (yyvsp[(3) - (4)].qName))),
+ ReportContext::XPST0008, fromYYLTYPE((yyloc), parseInfo));
+ (yyval.itemType).reset();
+ }
+ break;
+
+ case 446:
+/* Line 1269 of yacc.c. */
+#line 4354 "querytransformparser.ypp"
+ {
+ (yyval.itemType) = BuiltinTypes::element;
+ }
+ break;
+
+ case 447:
+/* Line 1269 of yacc.c. */
+#line 4359 "querytransformparser.ypp"
+ {
+ (yyval.itemType) = BuiltinTypes::element;
+ }
+ break;
+
+ case 448:
+/* Line 1269 of yacc.c. */
+#line 4364 "querytransformparser.ypp"
+ {
+ (yyval.itemType) = QNameTest::create(BuiltinTypes::element, (yyvsp[(3) - (4)].qName));
+ }
+ break;
+
+ case 449:
+/* Line 1269 of yacc.c. */
+#line 4369 "querytransformparser.ypp"
+ {
+ const SchemaType::Ptr t(parseInfo->staticContext->schemaDefinitions()->createSchemaType((yyvsp[(5) - (7)].qName)));
+
+ if(t)
+ (yyval.itemType) = BuiltinTypes::element;
+ else
+ {
+ parseInfo->staticContext->error(unknownType()
+ .arg(formatKeyword(parseInfo->staticContext->namePool(), (yyvsp[(5) - (7)].qName))),
+ ReportContext::XPST0008, fromYYLTYPE((yyloc), parseInfo));
+ }
+ }
+ break;
+
+ case 450:
+/* Line 1269 of yacc.c. */
+#line 4383 "querytransformparser.ypp"
+ {
+ const SchemaType::Ptr t(parseInfo->staticContext->schemaDefinitions()->createSchemaType((yyvsp[(5) - (7)].qName)));
+
+ if(t)
+ (yyval.itemType) = BuiltinTypes::element;
+ else
+ {
+ parseInfo->staticContext->error(QtXmlPatterns::tr("%1 is an unknown schema type.")
+ .arg(formatKeyword(parseInfo->staticContext->namePool(), (yyvsp[(5) - (7)].qName))),
+ ReportContext::XPST0008, fromYYLTYPE((yyloc), parseInfo));
+ }
+ }
+ break;
+
+ case 453:
+/* Line 1269 of yacc.c. */
+#line 4400 "querytransformparser.ypp"
+ {
+ 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(), (yyvsp[(3) - (4)].qName))),
+ ReportContext::XPST0008, fromYYLTYPE((yyloc), parseInfo));
+ (yyval.itemType).reset();
+ }
+ break;
+
+ case 455:
+/* Line 1269 of yacc.c. */
+#line 4412 "querytransformparser.ypp"
+ {
+ (yyval.qName) = parseInfo->staticContext->namePool()->allocateQName(StandardNamespaces::empty, (yyvsp[(1) - (1)].sval));
+ }
+ break;
+
+ case 457:
+/* Line 1269 of yacc.c. */
+#line 4424 "querytransformparser.ypp"
+ {
+ if(parseInfo->nodeTestSource == BuiltinTypes::element)
+ (yyval.qName) = parseInfo->staticContext->namePool()->allocateQName(parseInfo->staticContext->namespaceBindings()->lookupNamespaceURI(StandardPrefixes::empty), (yyvsp[(1) - (1)].sval));
+ else
+ (yyval.qName) = parseInfo->staticContext->namePool()->allocateQName(StandardNamespaces::empty, (yyvsp[(1) - (1)].sval));
+ }
+ break;
+
+ case 462:
+/* Line 1269 of yacc.c. */
+#line 4438 "querytransformparser.ypp"
+ {
+ (yyval.qName) = parseInfo->staticContext->namePool()->allocateQName(parseInfo->staticContext->defaultFunctionNamespace(), (yyvsp[(1) - (1)].sval));
+ }
+ break;
+
+ case 463:
+/* Line 1269 of yacc.c. */
+#line 4442 "querytransformparser.ypp"
+ {
+ (yyval.qName) = parseInfo->staticContext->namePool()->allocateQName(StandardNamespaces::InternalXSLT, (yyvsp[(2) - (2)].sval));
+ }
+ break;
+
+ case 466:
+/* Line 1269 of yacc.c. */
+#line 4450 "querytransformparser.ypp"
+ {
+ parseInfo->staticContext->error(QtXmlPatterns::tr("The name of an extension expression must be in "
+ "a namespace."),
+ ReportContext::XPST0081, fromYYLTYPE((yyloc), parseInfo));
+ }
+ break;
+
+ case 471:
+/* Line 1269 of yacc.c. */
+#line 4463 "querytransformparser.ypp"
+ {
+
+ const ReflectYYLTYPE ryy((yyloc), parseInfo);
+
+ (yyval.qName) = QNameConstructor::
+ expandQName<StaticContext::Ptr,
+ ReportContext::XPST0081,
+ ReportContext::XPST0081>((yyvsp[(1) - (1)].sval), parseInfo->staticContext,
+ parseInfo->staticContext->namespaceBindings(), &ryy);
+
+ }
+ break;
+
+ case 472:
+/* Line 1269 of yacc.c. */
+#line 4475 "querytransformparser.ypp"
+ {
+ (yyval.qName) = parseInfo->staticContext->namePool()->fromClarkName((yyvsp[(1) - (1)].sval));
+ }
+ break;
+
+
+/* Line 1269 of yacc.c. */
+#line 7643 "qquerytransformparser.cpp"
+ default: break;
+ }
+ YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
+
+ YYPOPSTACK (yylen);
+ yylen = 0;
+ YY_STACK_PRINT (yyss, yyssp);
+
+ *++yyvsp = yyval;
+ *++yylsp = yyloc;
+
+ /* Now `shift' the result of the reduction. Determine what state
+ that goes to, based on the state we popped back to and the rule
+ number reduced by. */
+
+ yyn = yyr1[yyn];
+
+ yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
+ if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+ yystate = yytable[yystate];
+ else
+ yystate = yydefgoto[yyn - YYNTOKENS];
+
+ goto yynewstate;
+
+
+/*------------------------------------.
+| yyerrlab -- here on detecting error |
+`------------------------------------*/
+yyerrlab:
+ /* If not already recovering from an error, report this error. */
+ if (!yyerrstatus)
+ {
+ ++yynerrs;
+#if ! YYERROR_VERBOSE
+ yyerror (&yylloc, parseInfo, YY_("syntax error"));
+#else
+ {
+ YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
+ if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
+ {
+ YYSIZE_T yyalloc = 2 * yysize;
+ if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
+ yyalloc = YYSTACK_ALLOC_MAXIMUM;
+ if (yymsg != yymsgbuf)
+ YYSTACK_FREE (yymsg);
+ yymsg = (char *) YYSTACK_ALLOC (yyalloc);
+ if (yymsg)
+ yymsg_alloc = yyalloc;
+ else
+ {
+ yymsg = yymsgbuf;
+ yymsg_alloc = sizeof yymsgbuf;
+ }
+ }
+
+ if (0 < yysize && yysize <= yymsg_alloc)
+ {
+ (void) yysyntax_error (yymsg, yystate, yychar);
+ yyerror (&yylloc, parseInfo, yymsg);
+ }
+ else
+ {
+ yyerror (&yylloc, parseInfo, YY_("syntax error"));
+ if (yysize != 0)
+ goto yyexhaustedlab;
+ }
+ }
+#endif
+ }
+
+ yyerror_range[0] = yylloc;
+
+ if (yyerrstatus == 3)
+ {
+ /* If just tried and failed to reuse lookahead token after an
+ error, discard it. */
+
+ if (yychar <= YYEOF)
+ {
+ /* Return failure if at end of input. */
+ if (yychar == YYEOF)
+ YYABORT;
+ }
+ else
+ {
+ yydestruct ("Error: discarding",
+ yytoken, &yylval, &yylloc, parseInfo);
+ yychar = YYEMPTY;
+ }
+ }
+
+ /* Else will try to reuse lookahead token after shifting the error
+ token. */
+ goto yyerrlab1;
+
+
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR. |
+`---------------------------------------------------*/
+yyerrorlab:
+
+ /* Pacify compilers like GCC when the user code never invokes
+ YYERROR and the label yyerrorlab therefore never appears in user
+ code. */
+ if (/*CONSTCOND*/ 0)
+ goto yyerrorlab;
+
+ yyerror_range[0] = yylsp[1-yylen];
+ /* Do not reclaim the symbols of the rule which action triggered
+ this YYERROR. */
+ YYPOPSTACK (yylen);
+ yylen = 0;
+ YY_STACK_PRINT (yyss, yyssp);
+ yystate = *yyssp;
+ goto yyerrlab1;
+
+
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR. |
+`-------------------------------------------------------------*/
+yyerrlab1:
+ yyerrstatus = 3; /* Each real token shifted decrements this. */
+
+ for (;;)
+ {
+ yyn = yypact[yystate];
+ if (yyn != YYPACT_NINF)
+ {
+ yyn += YYTERROR;
+ if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
+ {
+ yyn = yytable[yyn];
+ if (0 < yyn)
+ break;
+ }
+ }
+
+ /* Pop the current state because it cannot handle the error token. */
+ if (yyssp == yyss)
+ YYABORT;
+
+ yyerror_range[0] = *yylsp;
+ yydestruct ("Error: popping",
+ yystos[yystate], yyvsp, yylsp, parseInfo);
+ YYPOPSTACK (1);
+ yystate = *yyssp;
+ YY_STACK_PRINT (yyss, yyssp);
+ }
+
+ *++yyvsp = yylval;
+
+ yyerror_range[1] = yylloc;
+ /* Using YYLLOC is tempting, but would change the location of
+ the lookahead. YYLOC is available though. */
+ YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
+ *++yylsp = yyloc;
+
+ /* Shift the error token. */
+ YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
+
+ yystate = yyn;
+ goto yynewstate;
+
+
+/*-------------------------------------.
+| yyacceptlab -- YYACCEPT comes here. |
+`-------------------------------------*/
+yyacceptlab:
+ yyresult = 0;
+ goto yyreturn;
+
+/*-----------------------------------.
+| yyabortlab -- YYABORT comes here. |
+`-----------------------------------*/
+yyabortlab:
+ yyresult = 1;
+ goto yyreturn;
+
+#ifndef yyoverflow
+/*-------------------------------------------------.
+| yyexhaustedlab -- memory exhaustion comes here. |
+`-------------------------------------------------*/
+yyexhaustedlab:
+ yyerror (&yylloc, parseInfo, YY_("memory exhausted"));
+ yyresult = 2;
+ /* Fall through. */
+#endif
+
+yyreturn:
+ if (yychar != YYEMPTY)
+ yydestruct ("Cleanup: discarding lookahead",
+ yytoken, &yylval, &yylloc, parseInfo);
+ /* Do not reclaim the symbols of the rule which action triggered
+ this YYABORT or YYACCEPT. */
+ YYPOPSTACK (yylen);
+ YY_STACK_PRINT (yyss, yyssp);
+ while (yyssp != yyss)
+ {
+ yydestruct ("Cleanup: popping",
+ yystos[*yyssp], yyvsp, yylsp, parseInfo);
+ YYPOPSTACK (1);
+ }
+#ifndef yyoverflow
+ if (yyss != yyssa)
+ YYSTACK_FREE (yyss);
+#endif
+#if YYERROR_VERBOSE
+ if (yymsg != yymsgbuf)
+ YYSTACK_FREE (yymsg);
+#endif
+ /* Make sure YYID is used. */
+ return YYID (yyresult);
+}
+
+
+/* Line 1486 of yacc.c. */
+#line 4479 "querytransformparser.ypp"
+
+
+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
+
diff --git a/src/xmlpatterns/parser/qquerytransformparser_p.h b/src/xmlpatterns/parser/qquerytransformparser_p.h
new file mode 100644
index 0000000000..fcf8896d31
--- /dev/null
+++ b/src/xmlpatterns/parser/qquerytransformparser_p.h
@@ -0,0 +1,307 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@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.
+
+/* A Bison parser, made by GNU Bison 2.3a. */
+
+/* Skeleton interface for Bison's Yacc-like parsers in C
+
+ Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+ Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA. */
+
+/* As a special exception, you may create a larger work that contains
+ part or all of the Bison parser skeleton and distribute that work
+ under terms of your choice, so long as that work isn't itself a
+ parser generator using the skeleton or a modified version thereof
+ as a parser skeleton. Alternatively, if you modify or redistribute
+ the parser skeleton itself, you may (at your option) remove this
+ special exception, which will cause the skeleton and the resulting
+ Bison output files to be licensed under the GNU General Public
+ License without this special exception.
+
+ This special exception was added by the Free Software Foundation in
+ version 2.2 of Bison. */
+
+
+/* These tokens are defined to nothing on Windows because they're
+ * used in their documentation parser, for use in things like:
+ *
+ * int foo(IN char* name, OUT char* path);
+ *
+ * Hence this un-break fix. Note that this file was auto generated. */
+#ifdef IN
+# undef IN
+#endif
+#ifdef INSTANCE
+# undef INSTANCE
+#endif
+#ifdef STRICT
+# undef STRICT
+#endif
+#ifdef SELF
+# undef SELF
+#endif
+
+/* Tokens. */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+ /* Put the tokens into the symbol table, so that GDB and other debuggers
+ know about them. */
+ enum yytokentype {
+ END_OF_FILE = 0,
+ STRING_LITERAL = 258,
+ NON_BOUNDARY_WS = 259,
+ XPATH2_STRING_LITERAL = 260,
+ QNAME = 261,
+ NCNAME = 262,
+ CLARK_NAME = 263,
+ ANY_LOCAL_NAME = 264,
+ ANY_PREFIX = 265,
+ NUMBER = 266,
+ XPATH2_NUMBER = 267,
+ ANCESTOR = 268,
+ ANCESTOR_OR_SELF = 269,
+ AND = 270,
+ APOS = 271,
+ APPLY_TEMPLATE = 272,
+ AS = 273,
+ ASCENDING = 274,
+ ASSIGN = 275,
+ AT = 276,
+ AT_SIGN = 277,
+ ATTRIBUTE = 278,
+ AVT = 279,
+ BAR = 280,
+ BASEURI = 281,
+ BEGIN_END_TAG = 282,
+ BOUNDARY_SPACE = 283,
+ BY = 284,
+ CALL_TEMPLATE = 285,
+ CASE = 286,
+ CASTABLE = 287,
+ CAST = 288,
+ CHILD = 289,
+ COLLATION = 290,
+ COLONCOLON = 291,
+ COMMA = 292,
+ COMMENT = 293,
+ COMMENT_START = 294,
+ CONSTRUCTION = 295,
+ COPY_NAMESPACES = 296,
+ CURLY_LBRACE = 297,
+ CURLY_RBRACE = 298,
+ DECLARE = 299,
+ DEFAULT = 300,
+ DESCENDANT = 301,
+ DESCENDANT_OR_SELF = 302,
+ DESCENDING = 303,
+ DIV = 304,
+ DOCUMENT = 305,
+ DOCUMENT_NODE = 306,
+ DOLLAR = 307,
+ DOT = 308,
+ DOTDOT = 309,
+ ELEMENT = 310,
+ ELSE = 311,
+ EMPTY = 312,
+ EMPTY_SEQUENCE = 313,
+ ENCODING = 314,
+ END_SORT = 315,
+ EQ = 316,
+ ERROR = 317,
+ EVERY = 318,
+ EXCEPT = 319,
+ EXTERNAL = 320,
+ FOLLOWING = 321,
+ FOLLOWING_SIBLING = 322,
+ FOLLOWS = 323,
+ FOR_APPLY_TEMPLATE = 324,
+ FOR = 325,
+ FUNCTION = 326,
+ GE = 327,
+ G_EQ = 328,
+ G_GE = 329,
+ G_GT = 330,
+ G_LE = 331,
+ G_LT = 332,
+ G_NE = 333,
+ GREATEST = 334,
+ GT = 335,
+ IDIV = 336,
+ IF = 337,
+ IMPORT = 338,
+ INHERIT = 339,
+ IN = 340,
+ INSTANCE = 341,
+ INTERSECT = 342,
+ IS = 343,
+ ITEM = 344,
+ LAX = 345,
+ LBRACKET = 346,
+ LEAST = 347,
+ LE = 348,
+ LET = 349,
+ LPAREN = 350,
+ LT = 351,
+ MAP = 352,
+ MATCHES = 353,
+ MINUS = 354,
+ MODE = 355,
+ MOD = 356,
+ MODULE = 357,
+ NAME = 358,
+ NAMESPACE = 359,
+ NE = 360,
+ NODE = 361,
+ NO_INHERIT = 362,
+ NO_PRESERVE = 363,
+ OF = 364,
+ OPTION = 365,
+ ORDERED = 366,
+ ORDERING = 367,
+ ORDER = 368,
+ OR = 369,
+ PARENT = 370,
+ PI_START = 371,
+ PLUS = 372,
+ POSITION_SET = 373,
+ PRAGMA_END = 374,
+ PRAGMA_START = 375,
+ PRECEDES = 376,
+ PRECEDING = 377,
+ PRECEDING_SIBLING = 378,
+ PRESERVE = 379,
+ PRIORITY = 380,
+ PROCESSING_INSTRUCTION = 381,
+ QUESTION = 382,
+ QUICK_TAG_END = 383,
+ QUOTE = 384,
+ RBRACKET = 385,
+ RETURN = 386,
+ RPAREN = 387,
+ SATISFIES = 388,
+ SCHEMA_ATTRIBUTE = 389,
+ SCHEMA_ELEMENT = 390,
+ SCHEMA = 391,
+ SELF = 392,
+ SEMI_COLON = 393,
+ SLASH = 394,
+ SLASHSLASH = 395,
+ SOME = 396,
+ SORT = 397,
+ STABLE = 398,
+ STAR = 399,
+ STRICT = 400,
+ STRIP = 401,
+ SUCCESS = 402,
+ COMMENT_CONTENT = 403,
+ PI_CONTENT = 404,
+ PI_TARGET = 405,
+ XSLT_VERSION = 406,
+ TEMPLATE = 407,
+ TEXT = 408,
+ THEN = 409,
+ TO = 410,
+ TREAT = 411,
+ TUNNEL = 412,
+ TYPESWITCH = 413,
+ UNION = 414,
+ UNORDERED = 415,
+ VALIDATE = 416,
+ VARIABLE = 417,
+ VERSION = 418,
+ WHERE = 419,
+ XQUERY = 420,
+ INTERNAL = 421,
+ INTERNAL_NAME = 422,
+ CURRENT = 423
+ };
+#endif
+
+
+
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+
+# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+# define YYSTYPE_IS_DECLARED 1
+#endif
+
+
+
+#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
+typedef struct YYLTYPE
+{
+ int first_line;
+ int first_column;
+ int last_line;
+ int last_column;
+} YYLTYPE;
+# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
+# define YYLTYPE_IS_DECLARED 1
+# define YYLTYPE_IS_TRIVIAL 1
+#endif
+
+
+
diff --git a/src/xmlpatterns/parser/qtokenizer_p.h b/src/xmlpatterns/parser/qtokenizer_p.h
new file mode 100644
index 0000000000..eecd5b299f
--- /dev/null
+++ b/src/xmlpatterns/parser/qtokenizer_p.h
@@ -0,0 +1,216 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@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.
+
+#ifndef Patternist_Tokenizer_H
+#define Patternist_Tokenizer_H
+
+#include <QPair>
+#include <QSharedData>
+#include <QString>
+#include <QUrl>
+
+#include "qparsercontext_p.h"
+#include "qtokensource_p.h"
+
+/**
+ * @file
+ * @short Contains functions and classes used by the parser and tokenizer.
+ */
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+namespace QPatternist
+{
+ typedef QPair<QString, Expression::Ptr> AttributeHolder;
+ typedef QVector<AttributeHolder> AttributeHolderVector;
+
+ class OrderSpecTransfer
+ {
+ public:
+ typedef QList<OrderSpecTransfer> List;
+ inline OrderSpecTransfer()
+ {
+ }
+
+ inline OrderSpecTransfer(const Expression::Ptr &aExpr,
+ const OrderBy::OrderSpec aOrderSpec) : expression(aExpr),
+ orderSpec(aOrderSpec)
+ {
+ Q_ASSERT(expression);
+ }
+
+ Expression::Ptr expression;
+ OrderBy::OrderSpec orderSpec;
+ };
+
+ /**
+ * @short The value the parser, but not the tokenizers, uses for tokens and
+ * non-terminals.
+ *
+ * It is inefficient but ensures nothing leaks, by invoking C++
+ * destructors even in the cases the code throws exceptions. This might be
+ * able to be done in a more efficient way -- suggestions are welcome.
+ */
+ class TokenValue
+ {
+ public:
+ QString sval;
+
+ Expression::Ptr expr;
+ Expression::List expressionList;
+
+ Cardinality cardinality;
+ ItemType::Ptr itemType;
+ SequenceType::Ptr sequenceType;
+ FunctionArgument::List functionArguments;
+ FunctionArgument::Ptr functionArgument;
+ QVector<QXmlName> qNameVector;
+ QXmlName qName;
+ /**
+ * Holds enum values.
+ */
+ EnumUnion enums;
+
+ AttributeHolder attributeHolder;
+ AttributeHolderVector attributeHolders;
+ OrderSpecTransfer::List orderSpecs;
+ OrderSpecTransfer orderSpec;
+ };
+}
+
+QT_END_NAMESPACE
+
+/**
+ * Macro for the data type of semantic values; int by default.
+ * See section Data Types of Semantic Values.
+ */
+#define YYSTYPE QPatternist::TokenValue
+
+#include "qquerytransformparser_p.h" /* This inclusion must be after TokenValue. */
+
+QT_BEGIN_NAMESPACE
+
+namespace QPatternist
+{
+ /**
+ * @short Base class for all tokenizers.
+ *
+ * The main entry point is nextToken(), which ones calls to retrieve the stream
+ * of tokens this Tokenizer delivers.
+ *
+ * @see <a href="http://www.w3.org/TR/xquery-xpath-parsing/">Building a
+ * Tokenizer for XPath or XQuery</a>
+ * @author Frans Englich <fenglich@trolltech.com>
+ */
+ class Tokenizer : public TokenSource
+ {
+ public:
+ inline Tokenizer(const QUrl &queryU) : m_queryURI(queryU)
+ {
+ Q_ASSERT(queryU.isValid());
+ }
+
+ typedef QExplicitlySharedDataPointer<Tokenizer> Ptr;
+
+ /**
+ * Switches the Tokenizer to only do scanning, and returns complete
+ * strings for attribute value templates as opposed to the tokens for
+ * the contained expressions.
+ *
+ * The current position in the stream is returned. It can be used to
+ * later resume regular tokenization.
+ */
+ virtual int commenceScanOnly() = 0;
+
+ /**
+ * Resumes regular parsing from @p position. The tokenizer must be in
+ * the scan-only state, which the commenceScanOnly() call transists to.
+ *
+ * The tokenizer will return the token POSITION_SET once after this
+ * function has been called.
+ */
+ virtual void resumeTokenizationFrom(const int position) = 0;
+
+ /**
+ * @returns the URI of the resource being tokenized.
+ */
+ inline const QUrl &queryURI() const
+ {
+ return m_queryURI;
+ }
+
+ virtual void setParserContext(const ParserContext::Ptr &parseInfo) = 0;
+
+ protected:
+ /**
+ * Returns a string representation of @p token.
+ *
+ * This function is used for debugging purposes. The implementation of
+ * this function is in querytransformparser.ypp.
+ */
+ static QString tokenToString(const Token &token);
+
+ private:
+ Q_DISABLE_COPY(Tokenizer)
+ const QUrl m_queryURI;
+ };
+
+}
+
+#undef Patternist_DEBUG_PARSER // disable it for now
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/xmlpatterns/parser/qtokenlookup.cpp b/src/xmlpatterns/parser/qtokenlookup.cpp
new file mode 100644
index 0000000000..6e9c343612
--- /dev/null
+++ b/src/xmlpatterns/parser/qtokenlookup.cpp
@@ -0,0 +1,404 @@
+/* C++ code produced by gperf version 3.0.2 */
+/* Command-line: gperf TokenLookup.gperf */
+/* Computed positions: -k'1,3,$' */
+
+#if !((' ' == 32) && ('!' == 33) && ('"' == 34) && ('#' == 35) \
+ && ('%' == 37) && ('&' == 38) && ('\'' == 39) && ('(' == 40) \
+ && (')' == 41) && ('*' == 42) && ('+' == 43) && (',' == 44) \
+ && ('-' == 45) && ('.' == 46) && ('/' == 47) && ('0' == 48) \
+ && ('1' == 49) && ('2' == 50) && ('3' == 51) && ('4' == 52) \
+ && ('5' == 53) && ('6' == 54) && ('7' == 55) && ('8' == 56) \
+ && ('9' == 57) && (':' == 58) && (';' == 59) && ('<' == 60) \
+ && ('=' == 61) && ('>' == 62) && ('?' == 63) && ('A' == 65) \
+ && ('B' == 66) && ('C' == 67) && ('D' == 68) && ('E' == 69) \
+ && ('F' == 70) && ('G' == 71) && ('H' == 72) && ('I' == 73) \
+ && ('J' == 74) && ('K' == 75) && ('L' == 76) && ('M' == 77) \
+ && ('N' == 78) && ('O' == 79) && ('P' == 80) && ('Q' == 81) \
+ && ('R' == 82) && ('S' == 83) && ('T' == 84) && ('U' == 85) \
+ && ('V' == 86) && ('W' == 87) && ('X' == 88) && ('Y' == 89) \
+ && ('Z' == 90) && ('[' == 91) && ('\\' == 92) && (']' == 93) \
+ && ('^' == 94) && ('_' == 95) && ('a' == 97) && ('b' == 98) \
+ && ('c' == 99) && ('d' == 100) && ('e' == 101) && ('f' == 102) \
+ && ('g' == 103) && ('h' == 104) && ('i' == 105) && ('j' == 106) \
+ && ('k' == 107) && ('l' == 108) && ('m' == 109) && ('n' == 110) \
+ && ('o' == 111) && ('p' == 112) && ('q' == 113) && ('r' == 114) \
+ && ('s' == 115) && ('t' == 116) && ('u' == 117) && ('v' == 118) \
+ && ('w' == 119) && ('x' == 120) && ('y' == 121) && ('z' == 122) \
+ && ('{' == 123) && ('|' == 124) && ('}' == 125) && ('~' == 126))
+/* The character set is not based on ISO-646. */
+#error "gperf generated tables don't work with this execution character set. Please report a bug to <bug-gnu-gperf@gnu.org>."
+#endif
+
+#line 80 "TokenLookup.gperf"
+
+
+QT_BEGIN_NAMESPACE
+
+namespace QPatternist
+{
+
+#line 74 "TokenLookup.gperf"
+struct TokenMap
+{
+ const char *name;
+ const Tokenizer::TokenType token;
+}
+
+
+/* The strings below are in UTF-16 encoding. Subsequently, each ASCII
+ * character is stored as the ASCII character, followed by a null byte.
+ * Sorted alphabetically. */;
+/* maximum key range = 228, duplicates = 0 */
+
+class TokenLookup
+{
+private:
+ static inline unsigned int hash (const char *str, unsigned int len);
+public:
+ static const struct TokenMap *value (const char *str, unsigned int len);
+};
+
+inline unsigned int
+TokenLookup::hash (register const char *str, register unsigned int len)
+{
+ static const unsigned char asso_values[] =
+ {
+ 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
+ 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
+ 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
+ 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
+ 230, 230, 230, 230, 230, 25, 230, 230, 230, 230,
+ 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
+ 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
+ 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
+ 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
+ 230, 230, 230, 230, 230, 230, 230, 0, 2, 5,
+ 25, 0, 20, 20, 35, 85, 230, 230, 40, 110,
+ 25, 65, 80, 0, 60, 5, 10, 0, 55, 5,
+ 20, 0, 230, 230, 230, 230, 230, 230, 230, 230,
+ 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
+ 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
+ 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
+ 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
+ 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
+ 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
+ 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
+ 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
+ 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
+ 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
+ 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
+ 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
+ 230, 230, 230, 230, 230, 230
+ };
+ register int hval = len;
+
+ switch (hval)
+ {
+ default:
+ hval += asso_values[(unsigned char)str[2]];
+ /*FALLTHROUGH*/
+ case 2:
+ case 1:
+ hval += asso_values[(unsigned char)str[0]];
+ break;
+ }
+ return hval + asso_values[(unsigned char)str[len - 1]];
+}
+
+const struct TokenMap *
+TokenLookup::value (register const char *str, register unsigned int len)
+{
+ enum
+ {
+ TOTAL_KEYWORDS = 99,
+ MIN_WORD_LENGTH = 2,
+ MAX_WORD_LENGTH = 22,
+ MIN_HASH_VALUE = 2,
+ MAX_HASH_VALUE = 229
+ };
+
+ static const struct TokenMap wordlist[] =
+ {
+ {"",ERROR}, {"",ERROR},
+#line 125 "TokenLookup.gperf"
+ {"eq", EQ},
+ {"",ERROR},
+#line 103 "TokenLookup.gperf"
+ {"by", BY},
+#line 126 "TokenLookup.gperf"
+ {"every", EVERY},
+ {"",ERROR},
+#line 96 "TokenLookup.gperf"
+ {"as", AS},
+ {"",ERROR},
+#line 121 "TokenLookup.gperf"
+ {"else", ELSE},
+#line 190 "TokenLookup.gperf"
+ {"where", WHERE},
+#line 177 "TokenLookup.gperf"
+ {"stable", STABLE},
+#line 99 "TokenLookup.gperf"
+ {"at", AT},
+ {"",ERROR},
+#line 104 "TokenLookup.gperf"
+ {"case", CASE},
+ {"",ERROR},
+#line 102 "TokenLookup.gperf"
+ {"boundary-space", BOUNDARY_SPACE},
+#line 120 "TokenLookup.gperf"
+ {"element", ELEMENT},
+#line 105 "TokenLookup.gperf"
+ {"castable", CASTABLE},
+#line 100 "TokenLookup.gperf"
+ {"attribute", ATTRIBUTE},
+ {"",ERROR},
+#line 127 "TokenLookup.gperf"
+ {"except", EXCEPT},
+#line 134 "TokenLookup.gperf"
+ {"ge", GE},
+ {"",ERROR},
+#line 106 "TokenLookup.gperf"
+ {"cast", CAST},
+#line 183 "TokenLookup.gperf"
+ {"treat", TREAT},
+#line 191 "TokenLookup.gperf"
+ {"xquery", XQUERY},
+#line 154 "TokenLookup.gperf"
+ {"ne", NE},
+ {"",ERROR},
+#line 171 "TokenLookup.gperf"
+ {"satisfies", SATISFIES},
+ {"",ERROR}, {"",ERROR},
+#line 136 "TokenLookup.gperf"
+ {"gt", GT},
+#line 124 "TokenLookup.gperf"
+ {"encoding", ENCODING},
+#line 97 "TokenLookup.gperf"
+ {"ascending", ASCENDING},
+ {"",ERROR},
+#line 98 "TokenLookup.gperf"
+ {"assign", ASSIGN},
+#line 112 "TokenLookup.gperf"
+ {"declare", DECLARE},
+#line 135 "TokenLookup.gperf"
+ {"greatest", GREATEST},
+#line 181 "TokenLookup.gperf"
+ {"then", THEN},
+ {"",ERROR},
+#line 94 "TokenLookup.gperf"
+ {"ancestor-or-self", ANCESTOR_OR_SELF},
+#line 148 "TokenLookup.gperf"
+ {"le", LE},
+#line 119 "TokenLookup.gperf"
+ {"document-node", DOCUMENT_NODE},
+#line 180 "TokenLookup.gperf"
+ {"text", TEXT},
+ {"",ERROR},
+#line 174 "TokenLookup.gperf"
+ {"schema", SCHEMA},
+ {"",ERROR},
+#line 118 "TokenLookup.gperf"
+ {"document", DOCUMENT},
+ {"",ERROR},
+#line 114 "TokenLookup.gperf"
+ {"descendant", DESCENDANT},
+ {"",ERROR},
+#line 150 "TokenLookup.gperf"
+ {"lt", LT},
+#line 95 "TokenLookup.gperf"
+ {"and", AND},
+#line 155 "TokenLookup.gperf"
+ {"node", NODE},
+#line 147 "TokenLookup.gperf"
+ {"least", LEAST},
+#line 172 "TokenLookup.gperf"
+ {"schema-attribute", SCHEMA_ATTRIBUTE},
+ {"",ERROR},
+#line 128 "TokenLookup.gperf"
+ {"external", EXTERNAL},
+ {"",ERROR},
+#line 116 "TokenLookup.gperf"
+ {"descending", DESCENDING},
+#line 157 "TokenLookup.gperf"
+ {"no-preserve", NO_PRESERVE},
+#line 113 "TokenLookup.gperf"
+ {"default", DEFAULT},
+#line 149 "TokenLookup.gperf"
+ {"let", LET},
+#line 173 "TokenLookup.gperf"
+ {"schema-element", SCHEMA_ELEMENT},
+ {"",ERROR}, {"",ERROR},
+#line 110 "TokenLookup.gperf"
+ {"construction", CONSTRUCTION},
+#line 115 "TokenLookup.gperf"
+ {"descendant-or-self", DESCENDANT_OR_SELF},
+#line 175 "TokenLookup.gperf"
+ {"self", SELF},
+#line 156 "TokenLookup.gperf"
+ {"no-inherit", NO_INHERIT},
+ {"",ERROR},
+#line 131 "TokenLookup.gperf"
+ {"follows", FOLLOWS},
+#line 93 "TokenLookup.gperf"
+ {"ancestor", ANCESTOR},
+ {"",ERROR}, {"",ERROR}, {"",ERROR},
+#line 182 "TokenLookup.gperf"
+ {"to", TO},
+#line 133 "TokenLookup.gperf"
+ {"function", FUNCTION},
+#line 108 "TokenLookup.gperf"
+ {"collation", COLLATION},
+ {"",ERROR},
+#line 178 "TokenLookup.gperf"
+ {"strict", STRICT},
+ {"",ERROR},
+#line 146 "TokenLookup.gperf"
+ {"lax", LAX},
+ {"",ERROR},
+#line 122 "TokenLookup.gperf"
+ {"empty", EMPTY},
+ {"",ERROR},
+#line 158 "TokenLookup.gperf"
+ {"of", OF},
+#line 168 "TokenLookup.gperf"
+ {"preserve", PRESERVE},
+#line 129 "TokenLookup.gperf"
+ {"following", FOLLOWING},
+ {"",ERROR}, {"",ERROR},
+#line 144 "TokenLookup.gperf"
+ {"is", IS},
+#line 165 "TokenLookup.gperf"
+ {"precedes", PRECEDES},
+#line 123 "TokenLookup.gperf"
+ {"empty-sequence", EMPTY_SEQUENCE},
+ {"",ERROR}, {"",ERROR},
+#line 130 "TokenLookup.gperf"
+ {"following-sibling", FOLLOWING_SIBLING},
+#line 142 "TokenLookup.gperf"
+ {"instance", INSTANCE},
+#line 186 "TokenLookup.gperf"
+ {"unordered", UNORDERED},
+#line 101 "TokenLookup.gperf"
+ {"base-uri", BASEURI},
+#line 170 "TokenLookup.gperf"
+ {"return", RETURN},
+ {"",ERROR},
+#line 187 "TokenLookup.gperf"
+ {"validate", VALIDATE},
+ {"",ERROR},
+#line 111 "TokenLookup.gperf"
+ {"copy-namespaces", COPY_NAMESPACES},
+#line 159 "TokenLookup.gperf"
+ {"option", OPTION},
+#line 138 "TokenLookup.gperf"
+ {"if", IF},
+ {"",ERROR},
+#line 166 "TokenLookup.gperf"
+ {"preceding", PRECEDING},
+ {"",ERROR}, {"",ERROR},
+#line 141 "TokenLookup.gperf"
+ {"in", IN},
+ {"",ERROR},
+#line 143 "TokenLookup.gperf"
+ {"intersect", INTERSECT},
+#line 185 "TokenLookup.gperf"
+ {"union", UNION},
+ {"",ERROR},
+#line 167 "TokenLookup.gperf"
+ {"preceding-sibling", PRECEDING_SIBLING},
+#line 161 "TokenLookup.gperf"
+ {"ordering", ORDERING},
+#line 176 "TokenLookup.gperf"
+ {"some", SOME},
+#line 107 "TokenLookup.gperf"
+ {"child", CHILD},
+ {"",ERROR},
+#line 160 "TokenLookup.gperf"
+ {"ordered", ORDERED},
+#line 188 "TokenLookup.gperf"
+ {"variable", VARIABLE},
+ {"",ERROR}, {"",ERROR}, {"",ERROR},
+#line 163 "TokenLookup.gperf"
+ {"or", OR},
+ {"",ERROR}, {"",ERROR}, {"",ERROR}, {"",ERROR},
+#line 109 "TokenLookup.gperf"
+ {"comment", COMMENT},
+ {"",ERROR}, {"",ERROR},
+#line 184 "TokenLookup.gperf"
+ {"typeswitch", TYPESWITCH},
+ {"",ERROR},
+#line 140 "TokenLookup.gperf"
+ {"inherit", INHERIT},
+#line 117 "TokenLookup.gperf"
+ {"div", DIV},
+ {"",ERROR}, {"",ERROR},
+#line 152 "TokenLookup.gperf"
+ {"module", MODULE},
+ {"",ERROR},
+#line 132 "TokenLookup.gperf"
+ {"for", FOR},
+#line 153 "TokenLookup.gperf"
+ {"namespace", NAMESPACE},
+ {"",ERROR}, {"",ERROR},
+#line 189 "TokenLookup.gperf"
+ {"version", VERSION},
+ {"",ERROR}, {"",ERROR},
+#line 179 "TokenLookup.gperf"
+ {"strip", STRIP},
+ {"",ERROR}, {"",ERROR}, {"",ERROR}, {"",ERROR},
+#line 162 "TokenLookup.gperf"
+ {"order", ORDER},
+#line 164 "TokenLookup.gperf"
+ {"parent", PARENT},
+ {"",ERROR}, {"",ERROR}, {"",ERROR}, {"",ERROR},
+ {"",ERROR}, {"",ERROR},
+#line 151 "TokenLookup.gperf"
+ {"mod", MOD},
+ {"",ERROR}, {"",ERROR}, {"",ERROR}, {"",ERROR},
+ {"",ERROR}, {"",ERROR}, {"",ERROR}, {"",ERROR},
+ {"",ERROR}, {"",ERROR}, {"",ERROR}, {"",ERROR},
+ {"",ERROR}, {"",ERROR}, {"",ERROR}, {"",ERROR},
+ {"",ERROR},
+#line 139 "TokenLookup.gperf"
+ {"import", IMPORT},
+ {"",ERROR}, {"",ERROR}, {"",ERROR}, {"",ERROR},
+ {"",ERROR}, {"",ERROR}, {"",ERROR}, {"",ERROR},
+ {"",ERROR}, {"",ERROR},
+#line 169 "TokenLookup.gperf"
+ {"processing-instruction", PROCESSING_INSTRUCTION},
+ {"",ERROR}, {"",ERROR}, {"",ERROR}, {"",ERROR},
+ {"",ERROR}, {"",ERROR},
+#line 145 "TokenLookup.gperf"
+ {"item", ITEM},
+ {"",ERROR}, {"",ERROR}, {"",ERROR}, {"",ERROR},
+ {"",ERROR}, {"",ERROR}, {"",ERROR}, {"",ERROR},
+ {"",ERROR}, {"",ERROR}, {"",ERROR}, {"",ERROR},
+ {"",ERROR}, {"",ERROR}, {"",ERROR}, {"",ERROR},
+ {"",ERROR}, {"",ERROR}, {"",ERROR}, {"",ERROR},
+ {"",ERROR}, {"",ERROR}, {"",ERROR}, {"",ERROR},
+ {"",ERROR}, {"",ERROR}, {"",ERROR}, {"",ERROR},
+ {"",ERROR},
+#line 137 "TokenLookup.gperf"
+ {"idiv", IDIV}
+ };
+
+ if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
+ {
+ register int key = hash (str, len);
+
+ if (key <= MAX_HASH_VALUE && key >= 0)
+ {
+ register const char *s = wordlist[key].name;
+
+ if (*str == *s && !strcmp (str + 1, s + 1))
+ return &wordlist[key];
+ }
+ }
+ return 0;
+}
+#line 192 "TokenLookup.gperf"
+
+
+} /* Close the QPatternist namespace. */
+
+QT_END_NAMESPACE
diff --git a/src/xmlpatterns/parser/qtokenrevealer.cpp b/src/xmlpatterns/parser/qtokenrevealer.cpp
new file mode 100644
index 0000000000..15852d9f8e
--- /dev/null
+++ b/src/xmlpatterns/parser/qtokenrevealer.cpp
@@ -0,0 +1,111 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qtokenrevealer_p.h"
+
+QT_BEGIN_NAMESPACE
+
+using namespace QPatternist;
+
+TokenRevealer::TokenRevealer(const QUrl &uri,
+ const Tokenizer::Ptr &other) : Tokenizer(uri)
+ , m_tokenizer(other)
+{
+ Q_ASSERT(other);
+}
+
+TokenRevealer::~TokenRevealer()
+{
+ qDebug() << "Tokens Revealed:" << m_result;
+}
+
+void TokenRevealer::setParserContext(const ParserContext::Ptr &parseInfo)
+{
+ m_tokenizer->setParserContext(parseInfo);
+}
+
+Tokenizer::Token TokenRevealer::nextToken(YYLTYPE *const sourceLocator)
+{
+ const Token token(m_tokenizer->nextToken(sourceLocator));
+ const QString asString(tokenToString(token));
+ const TokenType type = token.type;
+
+ /* Indent. */
+ switch(type)
+ {
+ case CURLY_LBRACE:
+ {
+ m_result += QLatin1Char('\n') + m_indentationString + asString + QLatin1Char('\n');
+ m_indentationString.append(QLatin1String(" "));
+ m_result += m_indentationString;
+ break;
+ }
+ case CURLY_RBRACE:
+ {
+ m_indentationString.chop(4);
+ m_result += QLatin1Char('\n') + m_indentationString + asString;
+ break;
+ }
+ case SEMI_COLON:
+ /* Fallthrough. */
+ case COMMA:
+ {
+ m_result += asString + QLatin1Char('\n') + m_indentationString;
+ break;
+ }
+ default:
+ m_result += asString + QLatin1Char(' ');
+ }
+
+ return token;
+}
+
+int TokenRevealer::commenceScanOnly()
+{
+ return m_tokenizer->commenceScanOnly();
+}
+
+void TokenRevealer::resumeTokenizationFrom(const int position)
+{
+ m_tokenizer->resumeTokenizationFrom(position);
+}
+
+QT_END_NAMESPACE
diff --git a/src/xmlpatterns/parser/qtokenrevealer_p.h b/src/xmlpatterns/parser/qtokenrevealer_p.h
new file mode 100644
index 0000000000..a1530b0821
--- /dev/null
+++ b/src/xmlpatterns/parser/qtokenrevealer_p.h
@@ -0,0 +1,97 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@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.
+
+#ifndef Patternist_TokenRevealer_h
+#define Patternist_TokenRevealer_h
+
+#include <QSet>
+
+#include "qtokenizer_p.h"
+
+QT_BEGIN_HEADER
+QT_BEGIN_NAMESPACE
+
+namespace QPatternist
+{
+ /**
+ * @short Delegates another Tokenizer, and while doing so
+ * prints the tokens it delivers to @c stderr.
+ *
+ * Hence, this class is used solely for debugging.
+ *
+ * @since 4.5
+ */
+ class TokenRevealer : public Tokenizer
+ {
+ public:
+ TokenRevealer(const QUrl &uri,
+ const Tokenizer::Ptr &other);
+
+ virtual ~TokenRevealer();
+
+ virtual Token nextToken(YYLTYPE *const sourceLocator);
+ virtual int commenceScanOnly();
+ virtual void resumeTokenizationFrom(const int position);
+ virtual void setParserContext(const ParserContext::Ptr &parseInfo);
+
+ private:
+ const Tokenizer::Ptr m_tokenizer;
+ QString m_result;
+ QString m_indentationString;
+ };
+}
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
+
diff --git a/src/xmlpatterns/parser/qtokensource.cpp b/src/xmlpatterns/parser/qtokensource.cpp
new file mode 100644
index 0000000000..5393f12cee
--- /dev/null
+++ b/src/xmlpatterns/parser/qtokensource.cpp
@@ -0,0 +1,53 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qtokensource_p.h"
+
+QT_BEGIN_NAMESPACE
+
+using namespace QPatternist;
+
+TokenSource::~TokenSource()
+{
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/xmlpatterns/parser/qtokensource_p.h b/src/xmlpatterns/parser/qtokensource_p.h
new file mode 100644
index 0000000000..41b7be6442
--- /dev/null
+++ b/src/xmlpatterns/parser/qtokensource_p.h
@@ -0,0 +1,169 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@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.
+
+#ifndef Patternist_TokenSource_H
+#define Patternist_TokenSource_H
+
+#include "qatomiccomparator_p.h"
+#include "qatomicmathematician_p.h"
+#include "qcombinenodes_p.h"
+#include "qfunctionargument_p.h"
+#include "qitem_p.h"
+#include "qitemtype_p.h"
+#include "qorderby_p.h"
+#include "qpath_p.h"
+#include "qquerytransformparser_p.h"
+#include "qvalidate_p.h"
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+template<typename T> class QQueue;
+
+namespace QPatternist
+{
+ /**
+ * @short A union of all the enums the parser uses.
+ */
+ union EnumUnion
+ {
+ AtomicComparator::Operator valueOperator;
+ AtomicMathematician::Operator mathOperator;
+ CombineNodes::Operator combinedNodeOp;
+ QXmlNodeModelIndex::Axis axis;
+ QXmlNodeModelIndex::DocumentOrder nodeOperator;
+ StaticContext::BoundarySpacePolicy boundarySpacePolicy;
+ StaticContext::ConstructionMode constructionMode;
+ StaticContext::OrderingEmptySequence orderingEmptySequence;
+ StaticContext::OrderingMode orderingMode;
+ OrderBy::OrderSpec::Direction sortDirection;
+ Validate::Mode validationMode;
+ VariableSlotID slot;
+ int tokenizerPosition;
+ qint16 zeroer;
+ bool Bool;
+ xsDouble Double;
+ Path::Kind pathKind;
+ };
+
+ /**
+ * @short Base class for components that needs to return tokens.
+ *
+ * TokenSource represents a stream of Token instances. The end
+ * is reached when readNext() returns a Token constructed with
+ * END_OF_FILE.
+ *
+ * @see <a href="http://www.w3.org/TR/xquery-xpath-parsing/">Building a
+ * Tokenizer for XPath or XQuery</a>
+ * @author Frans Englich <fenglich@trolltech.com>
+ */
+ class TokenSource : public QSharedData
+ {
+ public:
+ /**
+ * typedef for the enum Bison generates that contains
+ * the token symbols.
+ */
+ typedef yytokentype TokenType;
+
+ /**
+ * Represents a token by carrying its name and value.
+ */
+ class Token
+ {
+ public:
+ /**
+ * Constructs an invalid Token. This default constructor
+ * is need in Qt's container classes.
+ */
+ inline Token() {}
+ inline Token(const TokenType t) : type(t) {}
+ inline Token(const TokenType t, const QString &val) : type(t), value(val) {}
+
+ bool hasError() const
+ {
+ return type == ERROR;
+ }
+
+ TokenType type;
+ QString value;
+ };
+
+ typedef QExplicitlySharedDataPointer<TokenSource> Ptr;
+ typedef QQueue<Ptr> Queue;
+
+ /**
+ * The C++ compiler cannot synthesize it when we use the
+ * Q_DISABLE_COPY() macro.
+ */
+ inline TokenSource()
+ {
+ }
+
+ virtual ~TokenSource();
+
+ /**
+ * @returns the next token.
+ */
+
+ virtual Token nextToken(YYLTYPE *const sourceLocator) = 0;
+
+ private:
+ Q_DISABLE_COPY(TokenSource)
+ };
+}
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/xmlpatterns/parser/querytransformparser.ypp b/src/xmlpatterns/parser/querytransformparser.ypp
new file mode 100644
index 0000000000..93974a48a7
--- /dev/null
+++ b/src/xmlpatterns/parser/querytransformparser.ypp
@@ -0,0 +1,4572 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@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) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@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);
+}
+
+/**
+ * @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, 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 which is
+ * unavailable in XPath.
+ *
+ * If @p isInternal is @c true, no error is raised. Otherwise, if the current
+ * language is not XQuery, an error is raised.
+ */
+static void disallowedConstruct(const ParserContext *const parseInfo,
+ const YYLTYPE &sourceLocator,
+ const bool isInternal = false)
+{
+ if(!isInternal && parseInfo->languageAccent != QXmlQuery::XQuery10)
+ {
+ parseInfo->staticContext->error(QtXmlPatterns::tr("A construct was encountered which only is allowed in XQuery."),
+ 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 by 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
+ {
+ disallowedConstruct(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
+ {
+ disallowedConstruct(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
+ {
+ disallowedConstruct(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 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
+ {
+ disallowedConstruct(parseInfo, @$);
+ }
+| BaseURIDecl
+| ConstructionDecl
+ {
+ disallowedConstruct(parseInfo, @$);
+ }
+| OrderingModeDecl
+ {
+ disallowedConstruct(parseInfo, @$);
+ }
+| EmptyOrderDecl
+ {
+ disallowedConstruct(parseInfo, @$);
+ }
+| CopyNamespacesDecl
+
+Import: SchemaImport /* [8] */
+| ModuleImport
+
+Separator: SEMI_COLON /* [9] */
+
+NamespaceDecl: DECLARE NAMESPACE NCNAME G_EQ URILiteral IsInternal Separator /* [10] */
+ {
+ if(!$6)
+ disallowedConstruct(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] */
+ {
+ disallowedConstruct(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] */
+ {
+ disallowedConstruct(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] */
+ {
+ disallowedConstruct(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)
+ disallowedConstruct(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] */
+ {
+ disallowedConstruct(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] */
+ {
+ $$ = 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] */
+ {
+ $$ = 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] */
+ {
+ disallowedConstruct(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] */
+ {
+ $$ = create(new IfThenClause($3, $6, $8), @$, parseInfo);
+ }
+
+OrExpr: AndExpr /* [46] */
+| OrExpr OR AndExpr
+ {
+ $$ = create(new OrExpression($1, $3), @$, parseInfo);
+ }
+
+AndExpr: ComparisonExpr /* [47] */
+| AndExpr AND ComparisonExpr
+ {
+ $$ = create(new AndExpression($1, $3), @$, parseInfo);
+ }
+
+ComparisonExpr: RangeExpr /* [48] */
+| ValueComp
+| GeneralComp
+| NodeComp
+
+RangeExpr: AdditiveExpr /* [49] */
+| AdditiveExpr TO AdditiveExpr
+ {
+ $$ = create(new RangeExpression($1, $3), @$, parseInfo);
+ }
+
+AdditiveExpr: MultiplicativeExpr /* [50] */
+| AdditiveExpr AdditiveOperator MultiplicativeExpr
+ {
+ $$ = create(new ArithmeticExpression($1, $2, $3), @$, parseInfo);
+ }
+
+AdditiveOperator: PLUS {$$ = AtomicMathematician::Add;} /* [X] */
+| MINUS {$$ = AtomicMathematician::Substract;}
+
+MultiplicativeExpr: UnionExpr /* [51] */
+| MultiplicativeExpr MultiplyOperator UnionExpr
+ {
+ $$ = 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
+ {
+ $$ = create(new CombineNodes($1, CombineNodes::Union, $3), @$, parseInfo);
+ }
+
+IntersectExceptExpr: InstanceOfExpr /* [53] */
+| IntersectExceptExpr IntersectOperator InstanceOfExpr
+ {
+ $$ = 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
+ {
+ $$ = create(new InstanceOf($1,
+ SequenceType::Ptr($4)), @$, parseInfo);
+ }
+
+TreatExpr: CastableExpr /* [55] */
+| CastableExpr TREAT AS SequenceType
+ {
+ $$ = create(new TreatAs($1, $4), @$, parseInfo);
+ }
+
+CastableExpr: CastExpr /* [56] */
+| CastExpr CASTABLE AS SingleType
+ {
+ $$ = create(new CastableAs($1, $4), @$, parseInfo);
+ }
+
+CastExpr: UnaryExpr /* [57] */
+| UnaryExpr CAST AS SingleType
+ {
+ $$ = create(new CastAs($1, $4), @$, parseInfo);
+ }
+
+UnaryExpr: ValueExpr /* [58] */
+| UnaryOperator UnaryExpr
+ {
+ $$ = 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] */
+ {
+ $$ = 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] */
+ {
+ disallowedConstruct(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] */
+ {
+ /* 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] */
+ {
+ disallowedConstruct(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] */
+{
+ Q_ASSERT(!$2.isEmpty());
+ $$ = create(new StaticBaseURIStore($2, $4), @$, parseInfo);
+}
+
+| DECLARE NAMESPACE NCNAME G_EQ STRING_LITERAL CURLY_LBRACE /* [X] */
+ {
+ 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;
+ }
+
+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] */
+ {
+ $$ = 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
+
+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
+ {
+ const QXmlName::LocalNameCode c = parseInfo->staticContext->namePool()->allocateLocalName($1);
+ $$ = LocalNameTest::create(parseInfo->nodeTestSource, c);
+ }
+
+FilterExpr: PrimaryExpr /* [81] */
+| FilterExpr LBRACKET Expr RBRACKET
+ {
+ $$ = 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] */
+ {
+ $$ = createNumericLiteral<Double>($1, @$, parseInfo);
+ }
+| NUMBER
+ {
+ $$ = createNumericLiteral<Numeric>($1, @$, parseInfo);
+ }
+
+VarRef: DOLLAR VarName /* [87] */
+ {
+ $$ = 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] */
+ {
+ $$ = $2;
+ }
+| LPAREN RPAREN
+ {
+ $$ = create(new EmptySequence, @$, parseInfo);
+ }
+
+ContextItemExpr: DOT /* [90] */
+ {
+ $$ = create(new ContextItem(), @$, parseInfo);
+ }
+
+OrderingExpr: OrderingMode EnclosedExpr /* [X] */
+ {
+ $$ = $2;
+ }
+
+FunctionCallExpr: FunctionName LPAREN FunctionArguments RPAREN /* [93] */
+ {
+ 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] */
+ {
+ disallowedConstruct(parseInfo, @$);
+ }
+| ComputedConstructor
+
+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] */
+ {
+ disallowedConstruct(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);
+ disallowedConstruct(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] */
+ {
+ disallowedConstruct(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] */
+ {
+ disallowedConstruct(parseInfo, @$, $2);
+
+ $$ = create(new CommentConstructor(createSimpleContent($3, @$, parseInfo)), @$, parseInfo);
+ }
+
+CompPIConstructor: PROCESSING_INSTRUCTION CompPIName EnclosedOptionalExpr /* [116] */
+ {
+ disallowedConstruct(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] */
+| XPATH2_STRING_LITERAL
+
+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
diff --git a/src/xmlpatterns/parser/qxquerytokenizer.cpp b/src/xmlpatterns/parser/qxquerytokenizer.cpp
new file mode 100644
index 0000000000..7e96f13f59
--- /dev/null
+++ b/src/xmlpatterns/parser/qxquerytokenizer.cpp
@@ -0,0 +1,2249 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QByteArray>
+
+#include "qquerytransformparser_p.h"
+
+#include "qxquerytokenizer_p.h"
+
+#include "qtokenlookup.cpp"
+
+QT_BEGIN_NAMESPACE
+
+namespace QPatternist
+{
+
+#define handleWhitespace() \
+{ \
+ const TokenType t = consumeWhitespace(); \
+ if(t != SUCCESS) \
+ return Token(t); \
+}
+
+XQueryTokenizer::XQueryTokenizer(const QString &query,
+ const QUrl &location,
+ const State startingState) : Tokenizer(location)
+ , m_data(query)
+ , m_length(query.length())
+ , m_state(startingState)
+ , m_pos(0)
+ , m_line(1)
+ , m_columnOffset(0)
+ , m_scanOnly(false)
+{
+ Q_ASSERT(location.isValid() || location.isEmpty());
+}
+
+const QChar XQueryTokenizer::current() const
+{
+ if(m_pos < m_length)
+ return m_data.at(m_pos);
+ else
+ return QChar();
+}
+
+char XQueryTokenizer::peekCurrent() const
+{
+ return current().toAscii();
+}
+
+int XQueryTokenizer::peekForColonColon() const
+{
+ /* Note, we don't modify m_pos in this function, so we need to do offset
+ * calculations. */
+ int pos = m_pos;
+
+ while(pos < m_length)
+ {
+ switch(m_data.at(pos).toAscii())
+ {
+ /* Fallthrough these four. */
+ case ' ':
+ case '\t':
+ case '\n':
+ case '\r':
+ break;
+ case ':':
+ {
+ if(peekAhead((pos - m_pos) + 1) == ':')
+ return pos - m_pos;
+ /* Fallthrough. */
+ }
+ default:
+ return -1;
+ }
+ ++pos;
+ }
+
+ return -1;
+}
+
+Tokenizer::Token XQueryTokenizer::tokenAndChangeState(const TokenType code,
+ const State s,
+ const int advance)
+{
+ Q_ASSERT(advance >= 0);
+ m_pos += advance;
+ setState(s);
+ return Token(code);
+}
+
+Tokenizer::Token XQueryTokenizer::tokenAndChangeState(const TokenType code,
+ const QString &value,
+ const State s)
+{
+ setState(s);
+ return Token(code, value);
+}
+
+Tokenizer::Token XQueryTokenizer::tokenAndAdvance(const TokenType code,
+ const int advance)
+{
+ Q_ASSERT(advance >= 0);
+ m_pos += advance;
+ return Token(code);
+}
+
+QString XQueryTokenizer::normalizeEOL(const QString &input,
+ const CharacterSkips &characterSkips)
+{
+ const int len = input.count();
+ QString result;
+
+ /* The likely hood is rather high it'll be the same content. */
+ result.reserve(len);
+
+ for(int i = 0; i < len; ++i)
+ {
+ const QChar &at = input.at(i);
+
+ if(characterSkips.contains(i))
+ {
+ result.append(at);
+ continue;
+ }
+ switch(input.at(i).unicode())
+ {
+ case '\r':
+ {
+ if(i + 1 < len && input.at(i + 1) == QLatin1Char('\n'))
+ ++i;
+
+ /* Else, fallthrough. */
+ }
+ case '\n':
+ {
+ result.append(QLatin1Char('\n'));
+ continue;
+ }
+ default:
+ {
+ result.append(at);
+ }
+ }
+ }
+
+ return result;
+}
+
+Tokenizer::TokenType XQueryTokenizer::consumeComment()
+{
+ /* Below, we return ERROR instead of END_OF_FILE such that the parser
+ * sees an invalid comment. */
+ while(m_pos < m_length)
+ {
+ switch(peekCurrent())
+ {
+ case ':':
+ {
+ ++m_pos; /* Consume ':' */
+ if(atEnd())
+ return ERROR;
+
+ if(peekCurrent() == ')')
+ {
+ ++m_pos; /* Consume ')' */
+ return SUCCESS; /* The comment closed nicely. */
+ }
+ continue; /* We don't want to increment m_pos twice. */
+ }
+ case '(':
+ { /* It looks like the start of a comment. */
+ ++m_pos;
+
+ if(atEnd())
+ return END_OF_FILE;
+ else if(peekCurrent() == ':')
+ {
+ /* And it is a nested comment -- parse it. */
+ const TokenType retval = consumeComment();
+ if(retval == SUCCESS)
+ continue; /* Continue with our "own" comment. */
+ else
+ return retval; /* Return the error in the nested comment. */
+ }
+ break;
+ }
+ case '\n':
+ /* Fallthrough. */
+ case '\r':
+ {
+ /* We want to count \r\n as a single line break. */
+ if(peekAhead() == '\n')
+ ++m_pos;
+
+ m_columnOffset = m_pos;
+ ++m_line;
+
+ break;
+ }
+ }
+ ++m_pos;
+ }
+
+ return ERROR; /* Error: we reached the end while inside a comment. */
+}
+
+bool XQueryTokenizer::consumeRawWhitespace()
+{
+ while(m_pos < m_length)
+ {
+ switch(peekCurrent())
+ {
+ case ' ':
+ case '\t':
+ break;
+ case '\n':
+ case '\r':
+ {
+ if(peekAhead() == '\n')
+ ++m_pos;
+
+ m_columnOffset = m_pos;
+ ++m_line;
+
+ break;
+ }
+ default:
+ return false;
+ }
+ ++m_pos;
+ }
+ return true;
+}
+
+Tokenizer::TokenType XQueryTokenizer::consumeWhitespace()
+{
+ while(m_pos < m_length)
+ {
+ switch(peekCurrent())
+ {
+ case ' ':
+ case '\t':
+ break;
+ case '\n':
+ case '\r':
+ {
+ /* We want to count \r\n as a single line break. */
+ if(peekAhead() == '\n')
+ ++m_pos;
+
+ m_columnOffset = m_pos;
+ ++m_line;
+
+ break;
+ }
+ case '(':
+ {
+ if(peekAhead() == ':')
+ {
+ m_pos += 2; /* Consume "(:" */
+
+ const TokenType comment = consumeComment();
+ if(comment == SUCCESS)
+ continue;
+ else
+ return comment;
+ }
+ }
+ default:
+ return SUCCESS;
+ }
+ ++m_pos;
+ }
+
+ return END_OF_FILE;
+}
+
+char XQueryTokenizer::peekAhead(const int length) const
+{
+ if(m_pos + length < m_length)
+ return m_data.at(m_pos + length).toAscii();
+ else
+ return 0;
+}
+
+Tokenizer::Token XQueryTokenizer::error()
+{
+ return Token(ERROR);
+}
+
+bool XQueryTokenizer::isDigit(const char ch)
+{
+ return ch >= '0' && ch <= '9';
+}
+
+/* Replace with function in QXmlUtils. Write test cases for this. */
+bool XQueryTokenizer::isNCNameStart(const QChar ch)
+{
+ if(ch == QLatin1Char('_'))
+ return true;
+
+ switch(ch.category())
+ {
+ case QChar::Letter_Lowercase:
+ case QChar::Letter_Uppercase:
+ case QChar::Letter_Other:
+ case QChar::Letter_Titlecase:
+ case QChar::Number_Letter:
+ return true;
+ default:
+ return false;
+ }
+}
+
+bool XQueryTokenizer::isNCNameBody(const QChar ch)
+{
+ switch(ch.unicode())
+ {
+ case '.':
+ case '_':
+ case '-':
+ return true;
+ }
+
+ switch(ch.category())
+ {
+ case QChar::Letter_Lowercase:
+ case QChar::Letter_Uppercase:
+ case QChar::Letter_Other:
+ case QChar::Letter_Titlecase:
+ case QChar::Number_Letter:
+ case QChar::Mark_SpacingCombining:
+ case QChar::Mark_Enclosing:
+ case QChar::Mark_NonSpacing:
+ case QChar::Letter_Modifier:
+ case QChar::Number_DecimalDigit:
+ return true;
+ default:
+ return false;
+ }
+}
+
+bool XQueryTokenizer::isPhraseKeyword(const TokenType code)
+{
+ switch(code)
+ {
+ /* Fallthrough all these. */
+ case CASTABLE:
+ case CAST:
+ case COPY_NAMESPACES:
+ case DECLARE:
+ case EMPTY:
+ case MODULE:
+ case IMPORT:
+ case INSTANCE:
+ case ORDER:
+ case ORDERING:
+ case XQUERY:
+ case STABLE:
+ case TREAT:
+ return true;
+ default:
+ return false;
+ }
+}
+
+bool XQueryTokenizer::isOperatorKeyword(const TokenType code)
+{
+ switch(code)
+ {
+ /* Fallthrough all these. */
+ case AS:
+ case ASCENDING:
+ case AT:
+ case CASE:
+ case CAST:
+ case CASTABLE:
+ case EQ:
+ case EXTERNAL:
+ case GE:
+ case G_EQ:
+ case G_GT:
+ case G_LT:
+ case G_NE:
+ case GT:
+ case IN:
+ case INHERIT:
+ case INSTANCE:
+ case IS:
+ case ITEM:
+ case LE:
+ case LT:
+ case NE:
+ case NO_INHERIT:
+ case NO_PRESERVE:
+ case OF:
+ case PRESERVE:
+ case RETURN:
+ case STABLE:
+ case TO:
+ case TREAT:
+ return true;
+ default:
+ return false;
+ };
+}
+
+bool XQueryTokenizer::isTypeToken(const TokenType t)
+{
+ switch(t)
+ {
+ /* Fallthrough all these. */
+ case ATTRIBUTE:
+ case COMMENT:
+ case DOCUMENT:
+ case DOCUMENT_NODE:
+ case ELEMENT:
+ case ITEM:
+ case NODE:
+ case PROCESSING_INSTRUCTION:
+ case SCHEMA_ATTRIBUTE:
+ case SCHEMA_ELEMENT:
+ case TEXT:
+ return true;
+ default:
+ return false;
+ }
+}
+
+Tokenizer::Token XQueryTokenizer::tokenizeNCNameOrQName()
+{
+ const int start = m_pos;
+
+ const Token t1 = tokenizeNCName();
+ if(t1.hasError())
+ return t1;
+
+ if(peekCurrent() != ':' || peekAhead() == '=')
+ return t1;
+
+ ++m_pos;
+
+ const Token t2 = tokenizeNCName();
+ if(t2.hasError())
+ return t2;
+ else
+ return Token(QNAME, m_data.mid(start, m_pos - start));
+}
+
+Tokenizer::Token XQueryTokenizer::tokenizeNumberLiteral()
+{
+ setState(Operator);
+ const int startPos = m_pos;
+ bool hasDot = false;
+ bool isXPath20 = false;
+
+ for(; m_pos < m_length; ++m_pos)
+ {
+ QChar ch(current());
+
+ char cell = ch.cell();
+
+ if(cell == 'e' || cell == 'E')
+ {
+ isXPath20 = true;
+ ++m_pos;
+ ch = current();
+
+ if(ch.row() != 0)
+ break;
+
+ cell = ch.cell();
+
+ if(cell == '+' || cell == '-')
+ continue;
+ }
+
+ if(isNCNameStart(ch))
+ return error();
+
+ if(cell < '0' || cell > '9')
+ {
+ if(cell == '.' && !hasDot)
+ hasDot = true;
+ else
+ break;
+ }
+ }
+
+ return Token(isXPath20 ? XPATH2_NUMBER : NUMBER, m_data.mid(startPos, m_pos - startPos));
+}
+
+QString XQueryTokenizer::tokenizeCharacterReference()
+{
+ Q_ASSERT(peekCurrent() == '&');
+
+ const int theEnd = m_data.indexOf(QLatin1Char(';'), m_pos + 1);
+
+ if(theEnd == -1) /* No ';' found, a syntax error. i18n. */
+ return QString();
+
+ QString content(m_data.mid(m_pos + 1, (theEnd - m_pos) - 1));
+ m_pos = theEnd;
+
+ const QChar charRef(charForReference(content));
+
+ if(!charRef.isNull())
+ return charRef;
+ else if(content.startsWith(QLatin1Char('#')))
+ {
+ int base;
+
+ /* It is only '#' or '#x'. */
+ if(content.length() < 2)
+ return QString();
+
+ /* We got a hex number if it starts with 'x', otherwise it's a decimal. */
+ if(content.at(1) == QLatin1Char('x'))
+ {
+ base = 16;
+ content = content.mid(2); /* Remove "#x". */
+ }
+ else
+ {
+ base = 10;
+ content = content.mid(1); /* Remove "#". */
+ }
+
+ bool conversionOK = false;
+ const int codepoint = content.toInt(&conversionOK, base);
+
+ if(conversionOK)
+ {
+ const QChar ch(codepoint);
+
+ if(ch.isNull())
+ {
+ /* We likely have something which require surrogate pairs. */
+ QString result;
+ result += QChar(QChar::highSurrogate(codepoint));
+ result += QChar(QChar::lowSurrogate(codepoint));
+ return result;
+ }
+ else
+ return ch;
+ }
+ else
+ return QString();
+ }
+ else
+ return QString();
+}
+
+int XQueryTokenizer::scanUntil(const char *const content)
+{
+ const int end = m_data.indexOf(QString::fromLatin1(content), m_pos);
+
+ if(end == -1)
+ return -1;
+ else
+ {
+ const int len = end - m_pos;
+ m_pos += len;
+ return len;
+ }
+}
+
+QChar XQueryTokenizer::charForReference(const QString &reference)
+{
+ if(m_charRefs.isEmpty())
+ {
+ /* Initialize. */
+ m_charRefs.reserve(5);
+ m_charRefs.insert(QLatin1String("lt"), QLatin1Char('<'));
+ m_charRefs.insert(QLatin1String("gt"), QLatin1Char('>'));
+ m_charRefs.insert(QLatin1String("amp"), QLatin1Char('&'));
+ m_charRefs.insert(QLatin1String("quot"), QLatin1Char('"'));
+ m_charRefs.insert(QLatin1String("apos"), QLatin1Char('\''));
+ }
+
+ return m_charRefs.value(reference);
+}
+
+Tokenizer::Token XQueryTokenizer::tokenizeStringLiteral()
+{
+ const QChar delimiter(current());
+ /* We cannot unfortunately just scan and then do mid(),
+ * since we can encounter character references. */
+ QString result;
+
+ /* This is more likely than QString's default allocation. */
+ result.reserve(8);
+
+ CharacterSkips skipEOLNormalization;
+
+ /* Advance over the initial quote character. */
+ ++m_pos;
+
+ for(; m_pos < m_length; ++m_pos)
+ {
+ const QChar c(current());
+
+ if(c == QLatin1Char('&'))
+ {
+ const QString charRef(tokenizeCharacterReference());
+
+ if(charRef.isNull())
+ return error();
+ else
+ {
+ skipEOLNormalization.insert(result.count());
+ result.append(charRef);
+ }
+
+ }
+ else if(c == delimiter)
+ {
+ /* Maybe the escaping mechanism is used. For instance, "s""s"
+ * has the value `s"s'. */
+ ++m_pos;
+
+ if(current() == delimiter) /* Double quote. */
+ result += delimiter;
+ else
+ return Token(STRING_LITERAL, normalizeEOL(result, skipEOLNormalization));
+ }
+ else
+ result += c;
+ }
+
+ return error();
+}
+
+Tokenizer::Token XQueryTokenizer::tokenizeNCName()
+{
+ const int startPos = m_pos;
+
+ if(m_pos < m_length && isNCNameStart(current()))
+ {
+ ++m_pos;
+
+ for(; m_pos < m_length; ++m_pos)
+ {
+ if(!isNCNameBody(current()))
+ break;
+ }
+
+ return Token(NCNAME, m_data.mid(startPos, m_pos - startPos));
+ }
+ else
+ return error();
+}
+
+bool XQueryTokenizer::aheadEquals(const char *const chs,
+ const int len,
+ const int offset) const
+{
+ Q_ASSERT(len > 0);
+ Q_ASSERT(qstrlen(chs) == uint(len));
+
+ if(m_pos + len >= m_length)
+ return false;
+
+ for(int i = offset; i < (len + offset); ++i)
+ {
+ if(m_data.at(m_pos + i).toAscii() != chs[i - offset])
+ return false;
+ }
+
+ return true;
+}
+
+const TokenMap *XQueryTokenizer::lookupKeyword(const QString &keyword)
+{
+ return TokenLookup::value(keyword.toAscii().constData(), keyword.length());
+}
+
+XQueryTokenizer::State XQueryTokenizer::state() const
+{
+ return m_state;
+}
+
+void XQueryTokenizer::setState(const State s)
+{
+ m_state = s;
+}
+
+void XQueryTokenizer::pushState(const State s)
+{
+ m_stateStack.push(s);
+}
+
+void XQueryTokenizer::pushState()
+{
+ m_stateStack.push(m_state);
+}
+
+void XQueryTokenizer::popState()
+{
+ /* QStack::pop() asserts if it's empty, so we need to check
+ * it, since we might receive unbalanced curlies. */
+ if(!m_stateStack.isEmpty())
+ m_state = m_stateStack.pop();
+}
+
+Tokenizer::Token XQueryTokenizer::nextToken()
+{
+ switch(state())
+ {
+ /* We want to skip or do special whitespace handling for these
+ * states. So fallthrough all of the following. */
+ case AposAttributeContent:
+ case Axis:
+ case ElementContent:
+ case EndTag:
+ case Pragma:
+ case PragmaContent:
+ case ProcessingInstructionName:
+ case QuotAttributeContent:
+ case StartTag:
+ case XMLComment:
+ break;
+ default:
+ handleWhitespace();
+ }
+
+ switch(state())
+ {
+ case XMLSpaceDecl:
+ /* Fallthrough. */
+ case NamespaceKeyword:
+ {
+ switch(peekCurrent())
+ {
+ case ',':
+ return tokenAndAdvance(COMMA);
+ case '"':
+ /* Fallthrough. */
+ case '\'':
+ {
+ setState(NamespaceDecl);
+ return tokenizeStringLiteral();
+ }
+ }
+
+ const Token id(tokenizeNCName());
+
+ if(id.type != NCNAME)
+ return id;
+
+ const TokenMap *const keyword = lookupKeyword(id.value);
+ if(keyword)
+ {
+ switch(keyword->token)
+ {
+ case INHERIT:
+ /* Fallthrough. */
+ case NO_INHERIT:
+ {
+ setState(Default);
+ break;
+ }
+ case NAMESPACE:
+ {
+ setState(NamespaceDecl);
+ break;
+ }
+ case ORDERED:
+ /* Fallthrough. */
+ case UNORDERED:
+ /* Fallthrough. */
+ case STRIP:
+ {
+ setState(Default);
+ break;
+ }
+ case PRESERVE:
+ {
+ if(state() != NamespaceKeyword)
+ setState(Default);
+ }
+ default:
+ break;
+ }
+
+ return Token(keyword->token);
+ }
+ else
+ return id;
+
+ Q_ASSERT(false);
+ }
+ case NamespaceDecl:
+ {
+ switch(peekCurrent())
+ {
+ case '=':
+ return tokenAndAdvance(G_EQ);
+ case ';':
+ return tokenAndChangeState(SEMI_COLON, Default);
+ case '\'':
+ /* Fallthrough. */
+ case '\"':
+ return tokenizeStringLiteral();
+ }
+
+ const Token nc(tokenizeNCName());
+
+ handleWhitespace();
+
+ const char pc = peekCurrent();
+ const TokenMap* const t = lookupKeyword(nc.value);
+
+ if(pc == '\'' || (pc == '"' && t))
+ return tokenAndChangeState(t->token, Default, 0);
+ else
+ return nc;
+
+ Q_ASSERT(false);
+ }
+ case Axis:
+ {
+ if(peekCurrent() == ':')
+ {
+ Q_ASSERT(peekAhead() == ':');
+ m_pos += 2;
+ setState(AfterAxisSeparator);
+ return Token(COLONCOLON);
+ }
+ /* Fallthrough. */
+ }
+ case AfterAxisSeparator:
+ /* Fallthrough. */
+ case Default:
+ /* State Operator and state Default have a lot of tokens in common except
+ * for minor differences. So we treat them the same way, and sprinkles logic
+ * here and there to handle the small differences. */
+ /* Fallthrough. */
+ case Operator:
+ {
+ switch(peekCurrent())
+ {
+ case '=':
+ return tokenAndChangeState(G_EQ, Default);
+ case '-':
+ return tokenAndChangeState(MINUS, Default);
+ case '+':
+ return tokenAndChangeState(PLUS, Default);
+ case '[':
+ return tokenAndChangeState(LBRACKET, Default);
+ case ']':
+ return tokenAndChangeState(RBRACKET, Operator);
+ case ',':
+ return tokenAndChangeState(COMMA, Default);
+ case ';':
+ return tokenAndChangeState(SEMI_COLON, Default);
+ case '$':
+ return tokenAndChangeState(DOLLAR, VarName);
+ case '|':
+ return tokenAndChangeState(BAR, Default);
+ case '?':
+ return tokenAndChangeState(QUESTION, Operator);
+ case ')':
+ return tokenAndChangeState(RPAREN, Operator);
+ case '@':
+ return tokenAndChangeState(AT_SIGN, Default);
+ /* Fallthrough all these. */
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case '0':
+ return tokenizeNumberLiteral();
+ case '.':
+ {
+ const char next = peekAhead();
+ if(next == '.')
+ return tokenAndChangeState(DOTDOT, Operator, 2);
+ /* .5 is allowed, as short form for 0.5:
+ * <tt>[142] DecimalLiteral ::= ("." Digits) | (Digits "." [0-9]*)</tt>
+ */
+ else if(isDigit(next))
+ return tokenizeNumberLiteral();
+ else
+ return tokenAndChangeState(DOT, Operator);
+ }
+ case '\'':
+ /* Fallthrough. */
+ case '"':
+ {
+ setState(Operator);
+ return tokenizeStringLiteral();
+
+ }
+ case '(':
+ {
+ if(peekAhead() == '#')
+ return tokenAndChangeState(PRAGMA_START, Pragma, 2);
+ else
+ return tokenAndChangeState(LPAREN, Default);
+ }
+ case '*':
+ {
+ if(peekAhead() == ':')
+ {
+ m_pos += 2; /* Consume *:. */
+ const Token nc = tokenizeNCName();
+
+ if(nc.hasError())
+ return error();
+ else
+ return tokenAndChangeState(ANY_PREFIX, nc.value, Operator);
+ }
+ else
+ return tokenAndChangeState(STAR, state() == Default ? Operator : Default);
+ }
+ case ':':
+ {
+ switch(peekAhead())
+ {
+ case '=':
+ return tokenAndChangeState(ASSIGN, Default, 2);
+ case ':':
+ return tokenAndChangeState(COLONCOLON, Default, 2);
+ default:
+ return error();
+ }
+ }
+ case '!':
+ {
+ if(peekAhead() == '=')
+ return tokenAndChangeState(G_NE, Default, 2);
+ else
+ return error();
+ }
+ case '<':
+ {
+ switch(peekAhead())
+ {
+ case '=':
+ return tokenAndChangeState(G_LE, Default, 2);
+ case '<':
+ return tokenAndChangeState(PRECEDES, Default, 2);
+ case '?':
+ {
+ pushState(Operator);
+ return tokenAndChangeState(PI_START, ProcessingInstructionName, 2);
+ }
+ case '!':
+ {
+ if(aheadEquals("!--", 3))
+ {
+ m_pos += 3; /* Consume "!--". */
+ pushState(Operator);
+ return tokenAndChangeState(COMMENT_START, XMLComment);
+ }
+ /* Fallthrough. It's a syntax error, and this is a good way to report it. */
+ }
+ default:
+ {
+ if((m_pos + 1) < m_length && isNCNameStart(m_data.at(m_pos + 1)))
+ {
+ /* We assume it's an element constructor. */
+ pushState(Operator);
+ }
+
+ return tokenAndChangeState(G_LT, state() == Operator ? Default : StartTag);
+ }
+ }
+ }
+ case '>':
+ {
+ switch(peekAhead())
+ {
+ case '=':
+ return tokenAndChangeState(G_GE, Default, 2);
+ case '>':
+ return tokenAndChangeState(FOLLOWS, Default, 2);
+ default:
+ return tokenAndChangeState(G_GT, Default);
+ }
+ }
+ case '/':
+ {
+ if(peekAhead() == '/')
+ return tokenAndChangeState(SLASHSLASH, Default, 2);
+ else
+ return tokenAndChangeState(SLASH, Default);
+ }
+ case '{':
+ {
+ pushState(Operator);
+ return tokenAndChangeState(CURLY_LBRACE, Default);
+ }
+ case '}':
+ {
+ popState();
+
+ return tokenAndAdvance(CURLY_RBRACE);
+ }
+ }
+
+ /* Ok. We're in state Default or Operator, and it wasn't a simple
+ * character. */
+
+ const Token id(tokenizeNCName());
+
+ if(id.type != NCNAME)
+ return id;
+
+ const TokenMap *const keyword = lookupKeyword(id.value);
+
+ if(state() == Operator)
+ {
+ if(keyword)
+ {
+ if(keyword->token == DEFAULT || keyword->token == ASCENDING || keyword->token == DESCENDING)
+ setState(Operator);
+ else if(keyword->token == RETURN)
+ setState(Default);
+ else if(isPhraseKeyword(keyword->token))
+ {
+ const TokenType ws = consumeWhitespace();
+ if(ws == ERROR)
+ return error();
+
+ const Token id2(tokenizeNCName());
+ const TokenMap *const keyword2 = lookupKeyword(id2.value);
+
+ if(keyword2)
+ {
+ if(keyword->token == TREAT && keyword2->token == AS)
+ setState(ItemType);
+ else if (keyword->token == CAST || (keyword->token == CASTABLE && keyword2->token == AS) || keyword2->token == BY)
+ setState(Default);
+
+ m_tokenStack.push(Token(keyword2->token));
+ }
+ else
+ m_tokenStack.push(id2);
+
+ return Token(keyword->token);
+ }
+ else
+ {
+ /* Such that we tokenize the second token in "empty greatest". */
+ if(keyword->token != EMPTY)
+ setState(Default);
+ }
+
+ if(keyword->token == AS || keyword->token == CASE)
+ setState(ItemType);
+
+ return Token(keyword->token);
+ }
+ else
+ return id;
+ }
+
+ Q_ASSERT(state() == Default || state() == Axis || state() == AfterAxisSeparator);
+
+ /*
+ * This is hard. Consider this:
+ *
+ * Valid: child ::nameTest
+ * Valid: child:: nameTest
+ * Syntax Error: child :localName
+ * Syntax Error: child: localName
+ *
+ * Consider "child ::name". Right now, we're here:
+ * ^
+ * We don't know whether "child" is a prefix and hence the whitespace is invalid,
+ * or whether it's an axis and hence skippable. */
+ {
+ const int wsLength = peekForColonColon();
+ /* We cannot call handleWhitespace() because it returns on
+ * END_OF_FILE, and we have parsed up keyword, and we need to
+ * deal with that.
+ *
+ * If we have a colon colon, which means the whitespace is
+ * allowed, we skip it. */
+ if(wsLength != -1)
+ m_pos += wsLength;
+ }
+
+ /* Handle name tests. */
+ if(peekCurrent() == ':')
+ {
+ switch(peekAhead())
+ {
+ case '=':
+ return id;
+ case '*':
+ {
+ m_pos += 2;
+ return tokenAndChangeState(ANY_LOCAL_NAME, id.value, Operator);
+ }
+ case ':':
+ {
+ /* We have an axis. */
+ setState(Axis);
+ return keyword ? Token(keyword->token) : id;
+ }
+ default:
+ {
+ /* It's a QName. */
+ ++m_pos; /* Consume the colon. */
+
+ const Token id2(tokenizeNCName());
+
+ if(id2.type != NCNAME)
+ {
+ --m_pos;
+ return id;
+ }
+
+ setState(Operator);
+ const int qNameLen = id.value.length() + id2.value.length() + 1;
+ return Token(QNAME, m_data.mid(m_pos - qNameLen, qNameLen));
+ }
+ }
+ }
+
+ if(!keyword || isOperatorKeyword(keyword->token))
+ {
+ setState(Operator);
+ return id;
+ }
+
+ const TokenType ws = consumeWhitespace();
+ if(ws == ERROR) // TODO this should test for success. Write test.
+ return Token(ERROR);
+
+ if(atEnd())
+ {
+ setState(Operator);
+ return id;
+ }
+
+ /* Let the if-body apply for constructors, and node type tests. */
+ if(isTypeToken(keyword->token) ||
+ keyword->token == TYPESWITCH ||
+ keyword->token == ORDERED ||
+ keyword->token == UNORDERED ||
+ keyword->token == IF)
+ {
+ switch(peekCurrent())
+ {
+ case '(':
+ {
+ // TODO See if we can remove DOCUMENT from isTypeToken.
+ if(isTypeToken(keyword->token) && keyword->token != DOCUMENT)
+ {
+ m_tokenStack.push(Token(LPAREN));
+ ++m_pos; /* Consume '('. */
+ pushState(Operator);
+
+ if(keyword->token == PROCESSING_INSTRUCTION)
+ setState(KindTestForPI);
+ else
+ setState(KindTest);
+
+ return Token(keyword->token);
+ }
+ else if(keyword->token == TYPESWITCH || keyword->token == IF)
+ return Token(keyword->token);
+ else /* It's a function call. */
+ return id;
+ }
+ case '{':
+ {
+ m_tokenStack.push(Token(CURLY_LBRACE));
+ ++m_pos; /* Consume '{'. */
+ pushState(Operator);
+ /* Stay in state Default. */
+ return Token(keyword->token);
+ }
+ default:
+ {
+ /* We have read in a token which is for instance
+ * "return", and now it can be an element
+ * test("element") a node kind test("element()"), or a
+ * computed element constructor("element name {...").
+ * We need to do a two-token lookahead here, because
+ * "element return" can be an element test followed by
+ * the return keyword, but it can also be an element
+ * constructor("element return {"). */
+ if(isNCNameStart(current()))
+ {
+ const int currentPos = m_pos;
+ const Token token2 = tokenizeNCNameOrQName();
+
+ if(token2.hasError())
+ return token2;
+
+ handleWhitespace();
+
+ if(peekCurrent() == '{')
+ {
+ /* An element constructor. */
+ m_tokenStack.push(token2);
+ return Token(keyword->token);
+ }
+
+ /* We jump back in the stream, we need to tokenize token2 according
+ * to the state. */
+ m_pos = currentPos;
+ setState(Operator);
+ return Token(NCNAME, QLatin1String(keyword->name));
+ }
+ }
+ }
+ }
+
+ if(peekCurrent() == '$')
+ {
+ setState(VarName);
+ return Token(keyword->token);
+ }
+
+ /* It's not a node type, it's not the typeswitch expression, but it is a function callsite. */
+ if(peekCurrent() == '(')
+ return id;
+ else if(peekCurrent() == '{' && keyword->token == VALIDATE)
+ return Token(keyword->token);
+
+ if(!isNCNameStart(current()))
+ {
+ setState(Operator);
+ return id;
+ }
+
+ const Token id2(tokenizeNCName());
+ const TokenMap *const keyword2 = lookupKeyword(id2.value);
+
+ if(!keyword2)
+ {
+ /* It's a syntax error. All cases of two subsequent ncnames are keywords(e.g, declarations). */
+ setState(Operator);
+ return id;
+ }
+
+ switch(keyword->token)
+ {
+ case DECLARE:
+ {
+ switch(keyword2->token)
+ {
+ case VARIABLE:
+ /* Fallthrough. */
+ case FUNCTION:
+ {
+ m_tokenStack.push(Token(keyword2->token));
+ setState(Default);
+ return Token(keyword->token);
+ }
+ case OPTION:
+ {
+ m_tokenStack.push(Token(keyword2->token));
+ setState(Default);
+ return Token(keyword->token);
+ }
+ case COPY_NAMESPACES:
+ /* Fallthrough. */
+ case ORDERING:
+ {
+ m_tokenStack.push(Token(keyword2->token));
+ setState(NamespaceKeyword);
+ return Token(keyword->token);
+ }
+ case CONSTRUCTION:
+ {
+ // TODO identical to CONSTRUCTION?
+ m_tokenStack.push(Token(keyword2->token));
+ setState(Operator);
+ return Token(keyword->token);
+ }
+ case NAMESPACE:
+ /* Fallthrough. */
+ case BASEURI:
+ {
+ m_tokenStack.push(Token(keyword2->token));
+ setState(NamespaceDecl);
+ return Token(keyword->token);
+ }
+ case BOUNDARY_SPACE:
+ {
+ m_tokenStack.push(Token(keyword2->token));
+ setState(XMLSpaceDecl);
+ return Token(keyword->token);
+ }
+ case DEFAULT:
+ {
+ m_tokenStack.push(Token(keyword2->token));
+
+ const TokenType ws2 = consumeWhitespace();
+ if(ws2 != SUCCESS)
+ {
+ m_tokenStack.prepend(Token(ws2));
+ return Token(keyword->token);
+ }
+
+ const Token id3(tokenizeNCName());
+
+ if(id3.type != NCNAME)
+ {
+ m_tokenStack.prepend(id3);
+ return Token(keyword->token);
+ }
+
+ const TokenMap *const keyword3 = lookupKeyword(id3.value);
+ if(!keyword3)
+ {
+ m_tokenStack.prepend(id3);
+ return Token(keyword->token);
+ }
+ else
+ {
+ m_tokenStack.prepend(Token(keyword3->token));
+
+ if(keyword3->token == ORDER)
+ setState(Operator);
+ else
+ setState(NamespaceDecl);
+ }
+
+ return Token(keyword->token);
+ }
+ default:
+ {
+ m_tokenStack.push(Token(keyword2->token));
+ setState(Default);
+ return id;
+ }
+ }
+ }
+ case XQUERY:
+ {
+ m_tokenStack.push(Token(keyword2->token));
+
+ if(keyword2->token == VERSION)
+ {
+ setState(NamespaceDecl);
+ return Token(keyword->token);
+ }
+ else
+ {
+ setState(Operator);
+ return id;
+ }
+ }
+ case IMPORT:
+ {
+ m_tokenStack.push(Token(keyword2->token));
+
+ switch(keyword2->token)
+ {
+ case SCHEMA:
+ /* Fallthrough. */
+ case MODULE:
+ {
+ setState(NamespaceKeyword);
+ return Token(keyword->token);
+ }
+ default:
+ {
+ setState(Operator);
+ return id;
+ }
+ }
+ }
+ case VALIDATE:
+ {
+ m_tokenStack.push(Token(keyword2->token));
+
+ switch(keyword2->token)
+ {
+ case LAX:
+ case STRICT:
+ {
+ pushState(Operator);
+ return Token(keyword->token);
+ }
+ default:
+ {
+ setState(Operator);
+ return id;
+ }
+ }
+ }
+ default:
+ {
+ m_tokenStack.push(Token(keyword2->token));
+ setState(Operator);
+ return id;
+ }
+ }
+
+ Q_ASSERT(false);
+
+ }
+ case VarName:
+ {
+ if(peekCurrent() == '$')
+ return tokenAndAdvance(DOLLAR);
+
+ setState(Operator);
+ return tokenizeNCNameOrQName();
+ Q_ASSERT(false);
+ }
+ case ItemType:
+ {
+ switch(peekCurrent())
+ {
+ case '(':
+ return tokenAndChangeState(LPAREN, KindTest);
+ case '$':
+ return tokenAndChangeState(DOLLAR, VarName);
+ }
+
+ const Token name(tokenizeNCNameOrQName());
+
+ if(name.hasError())
+ return error();
+
+ else if(name.type == QNAME)
+ {
+ setState(OccurrenceIndicator);
+ return name;
+ }
+ else
+ {
+ const TokenMap *const keyword = lookupKeyword(name.value);
+
+ if(keyword)
+ {
+ pushState(OccurrenceIndicator);
+ return Token(keyword->token);
+ }
+ else
+ {
+ setState(Default);
+ return name;
+ }
+ }
+ Q_ASSERT(false);
+ }
+ case KindTest:
+ {
+ switch(peekCurrent())
+ {
+ case ')':
+ {
+ popState();
+ return tokenAndAdvance(RPAREN);
+ }
+ case '(':
+ return tokenAndAdvance(LPAREN);
+ case ',':
+ return tokenAndAdvance(COMMA);
+ case '*':
+ return tokenAndAdvance(STAR);
+ case '?':
+ return tokenAndAdvance(QUESTION);
+ case '\'':
+ /* Fallthrough. */
+ case '"':
+ return tokenizeStringLiteral();
+ }
+
+ const Token nc(tokenizeNCNameOrQName());
+ if(nc.hasError())
+ return nc;
+
+ const TokenType ws = consumeWhitespace();
+ if(ws == ERROR)
+ return error();
+
+ if(peekCurrent() == '(')
+ {
+ const TokenMap *const keyword = lookupKeyword(nc.value);
+ if(keyword)
+ {
+ pushState(KindTest);
+ return Token(keyword->token);
+ }
+ else
+ return nc;
+ }
+ else
+ return nc;
+ Q_ASSERT(false);
+ }
+ case KindTestForPI:
+ {
+ switch(peekCurrent())
+ {
+ case ')':
+ {
+ popState();
+ return tokenAndAdvance(RPAREN);
+ }
+ case '\'':
+ /* Fallthrough. */
+ case '"':
+ return tokenizeStringLiteral();
+ default:
+ return tokenizeNCName();
+ }
+ Q_ASSERT(false);
+ }
+ case OccurrenceIndicator:
+ {
+ switch(peekCurrent())
+ {
+ case '?':
+ return tokenAndChangeState(QUESTION, Operator);
+ case '*':
+ return tokenAndChangeState(STAR, Operator);
+ case '+':
+ return tokenAndChangeState(PLUS, Operator);
+ default:
+ {
+ setState(Operator);
+ return nextToken();
+ }
+ }
+ Q_ASSERT(false);
+ }
+ case XQueryVersion:
+ {
+ switch(peekCurrent())
+ {
+ case '\'':
+ /* Fallthrough. */
+ case '"':
+ return tokenizeStringLiteral();
+ case ';':
+ return tokenAndChangeState(SEMI_COLON, Default);
+ }
+
+ const Token id(tokenizeNCName());
+
+ if(id.type != NCNAME)
+ return id;
+
+ const TokenMap *const keyword = lookupKeyword(id.value);
+ if(keyword)
+ return tokenAndChangeState(keyword->token, Default);
+ else
+ return id;
+ Q_ASSERT(false);
+ }
+ case StartTag:
+ {
+ if(peekAhead(-1) == '<')
+ {
+ if(current().isSpace())
+ return Token(ERROR);
+ }
+ else
+ {
+ if(consumeRawWhitespace())
+ return Token(END_OF_FILE);
+ }
+
+ switch(peekCurrent())
+ {
+ case '/':
+ {
+ if(peekAhead() == '>')
+ {
+ m_pos += 2;
+
+ if(m_scanOnly)
+ return Token(POSITION_SET);
+ else
+ {
+ popState();
+ return Token(QUICK_TAG_END);
+ }
+ }
+ else
+ return error();
+ }
+ case '>':
+ {
+ if(m_scanOnly)
+ return tokenAndChangeState(POSITION_SET, StartTag);
+ else
+ return tokenAndChangeState(G_GT, ElementContent);
+ }
+ case '=':
+ return tokenAndAdvance(G_EQ);
+ case '\'':
+ return tokenAndChangeState(APOS, AposAttributeContent);
+ case '"':
+ return tokenAndChangeState(QUOTE, QuotAttributeContent);
+ default:
+ return tokenizeNCNameOrQName();
+ }
+ Q_ASSERT(false);
+ }
+ case AposAttributeContent:
+ /* Fallthrough. */
+ case QuotAttributeContent:
+ {
+ const QChar sep(state() == AposAttributeContent ? QLatin1Char('\'') : QLatin1Char('"'));
+ QString result;
+ result.reserve(20);
+
+ if(m_scanOnly)
+ {
+ int stack = 0;
+ return attributeAsRaw(sep, stack, m_pos, true, result);
+ }
+
+ Q_ASSERT(!m_scanOnly);
+ while(true)
+ {
+ if(atEnd())
+ {
+ /* In the case that the XSL-T tokenizer invokes us with
+ * default state QuotAttributeContent, we need to be able
+ * to return a single string, in case that is all we have
+ * accumulated. */
+ if(result.isEmpty())
+ return Token(END_OF_FILE);
+ else
+ return Token(STRING_LITERAL, result);
+ }
+
+ const QChar curr(current());
+
+ if(curr == sep)
+ {
+ if(m_pos + 1 == m_length)
+ return Token(END_OF_FILE);
+
+ if(m_data.at(m_pos + 1) == sep)
+ {
+ /* The quoting mechanism was used. */
+ m_pos += 2;
+ result.append(sep);
+ continue;
+ }
+
+ const QChar next(m_data.at(m_pos + 1));
+ if(!next.isSpace() && next != QLatin1Char('/') && next != QLatin1Char('>'))
+ return Token(ERROR); // i18n Space must separate attributes
+ else if(result.isEmpty())
+ {
+ return tokenAndChangeState(state() == AposAttributeContent ? APOS : QUOTE,
+ StartTag, 1);
+ }
+ else
+ {
+ /* Don't consume the sep, but leave it so we next time return a token for it. */
+ return Token(STRING_LITERAL, result);
+ }
+
+ ++m_pos;
+ continue;
+ }
+ else if(curr == QLatin1Char('{'))
+ {
+ if(m_pos + 1 == m_length)
+ return Token(END_OF_FILE);
+ else if(peekAhead() == '{')
+ {
+ ++m_pos;
+ result.append(QLatin1Char('{'));
+ }
+ else
+ {
+ if(result.isEmpty())
+ {
+ /* The Attribute Value Template appeared directly in the attribute. */
+ pushState();
+ return tokenAndChangeState(CURLY_LBRACE, Default);
+ }
+ else
+ {
+ /* We don't advance, keep '{' as next token. */
+ return Token(STRING_LITERAL, result);
+ }
+ }
+ }
+ else if(curr == QLatin1Char('}'))
+ {
+ if(m_pos + 1 == m_length)
+ return Token(END_OF_FILE);
+ else if(peekAhead() == '}')
+ {
+ ++m_pos;
+ result.append(QLatin1Char('}'));
+ }
+ else
+ return Token(ERROR);
+ }
+ else if(curr == QLatin1Char('&'))
+ {
+ const QString ret(tokenizeCharacterReference());
+ if(ret.isNull())
+ return Token(ERROR);
+ else
+ result.append(ret);
+ }
+ else if(curr == QLatin1Char('<'))
+ return Token(STRING_LITERAL, result);
+ else
+ {
+ /* See Extensible Markup Language (XML) 1.0 (Fourth Edition),
+ * 3.3.3 Attribute-Value Normalization.
+ *
+ * However, it is complicated a bit by that AVN is defined on top of
+ * EOL normalization and we do those two in one go here. */
+ switch(curr.unicode())
+ {
+ case 0xD:
+ {
+ if(peekAhead() == '\n')
+ {
+ result.append(QLatin1Char(' '));
+ ++m_pos;
+ break;
+ }
+ }
+ case 0xA:
+ /* Fallthrough. */
+ case 0x9:
+ {
+ result.append(QLatin1Char(' '));
+ break;
+ }
+ default:
+ result.append(curr);
+ }
+ }
+
+ ++m_pos;
+ }
+ Q_ASSERT(false);
+ }
+ case ElementContent:
+ {
+ QString result;
+ result.reserve(20);
+
+ /* Whether the text node, result, may be whitespace only. Character references
+ * and CDATA sections disables that. */
+ bool mayBeWS = true;
+
+ CharacterSkips skipEOLNormalization;
+
+ while(true)
+ {
+ if(atEnd())
+ return Token(END_OF_FILE);
+
+ switch(peekCurrent())
+ {
+ case '<':
+ {
+ if(!result.isEmpty() && peekAhead(2) != '[')
+ {
+ /* We encountered the end, and it was not a CDATA section. */
+ /* We don't advance. Next time we'll handle the <... stuff. */
+ return Token(mayBeWS ? STRING_LITERAL : NON_BOUNDARY_WS, normalizeEOL(result, skipEOLNormalization));
+ }
+
+ ++m_pos;
+ if(atEnd())
+ return Token(END_OF_FILE);
+
+ const QChar ahead(current());
+ if(ahead.isSpace())
+ return error();
+ else if(ahead == QLatin1Char('/'))
+ {
+ if(m_pos + 1 == m_length)
+ return Token(END_OF_FILE);
+ else if(m_data.at(m_pos + 1).isSpace())
+ return error();
+ else
+ return tokenAndChangeState(BEGIN_END_TAG, EndTag);
+ }
+ else if(isNCNameStart(ahead))
+ {
+ pushState();
+ return tokenAndChangeState(G_LT, StartTag, 0);
+ }
+ else if(aheadEquals("!--", 3, 0))
+ {
+ pushState();
+ m_pos += 3;
+ return tokenAndChangeState(COMMENT_START, XMLComment, 0);
+ }
+ else if(aheadEquals("![CDATA[", 8, 0))
+ {
+ mayBeWS = false;
+ m_pos += 8;
+ const int start = m_pos;
+ const int len = scanUntil("]]>");
+
+ if(len == -1)
+ return Token(END_OF_FILE);
+
+ m_pos += 2; /* Consume "]]>". Note that m_pos is on '!'. */
+ result.append(m_data.mid(start, len));
+ break;
+ }
+ else if(ahead == QLatin1Char('?'))
+ {
+ pushState();
+ return tokenAndChangeState(PI_START, ProcessingInstructionName);
+ }
+ else
+ return Token(G_LT);
+ }
+ case '&':
+ {
+ const QString ret(tokenizeCharacterReference());
+ if(ret.isNull())
+ return Token(ERROR);
+ else
+ {
+ skipEOLNormalization.insert(result.count());
+ result.append(ret);
+ mayBeWS = false;
+ break;
+ }
+ }
+ case '{':
+ {
+ // TODO remove this check, also below.
+ if(m_pos + 1 == m_length)
+ return Token(END_OF_FILE);
+ else if(peekAhead() == '{')
+ {
+ ++m_pos;
+ result.append(QLatin1Char('{'));
+ }
+ else
+ {
+ if(result.isEmpty())
+ {
+ pushState();
+ return tokenAndChangeState(CURLY_LBRACE, Default);
+ }
+ else
+ {
+ /* We don't advance here. */
+ return Token(mayBeWS ? STRING_LITERAL : NON_BOUNDARY_WS, normalizeEOL(result, skipEOLNormalization));
+ }
+ }
+ break;
+ }
+ case '}':
+ {
+ if(m_pos + 1 == m_length)
+ return Token(END_OF_FILE);
+ else if(peekAhead() == '}')
+ {
+ ++m_pos;
+ result.append(QLatin1Char('}'));
+ }
+ else
+ {
+ /* This is a parse error, and the grammar won't be able
+ * to reduce this CURLY_RBRACE. */
+ return tokenAndChangeState(CURLY_RBRACE, Default);
+ }
+ break;
+ }
+ case '\n':
+ {
+ /* We want to translate \r\n into \n. */
+ if(peekAhead(-1) == '\r')
+ break;
+ /* else, fallthrough. */
+ }
+ case '\r':
+ {
+ result.append(QLatin1Char('\n'));
+ break;
+ }
+ default:
+ {
+ result.append(current());
+ break;
+ }
+ }
+ ++m_pos;
+ }
+ Q_ASSERT(false);
+ }
+ case ProcessingInstructionName:
+ {
+ const int start = m_pos;
+
+ while(true)
+ {
+ ++m_pos;
+ if(m_pos >= m_length)
+ return Token(END_OF_FILE);
+
+ const QChar next(current());
+ if(next.isSpace() || next == QLatin1Char('?'))
+ {
+ return tokenAndChangeState(PI_TARGET, m_data.mid(start, m_pos - start),
+ ProcessingInstructionContent);
+ }
+ }
+ Q_ASSERT(false);
+ }
+ case ProcessingInstructionContent:
+ {
+ /* Consume whitespace between the name and the content. */
+ if(consumeRawWhitespace())
+ return Token(END_OF_FILE);
+
+ const int start = m_pos;
+ const int len = scanUntil("?>");
+
+ if(len == -1)
+ return Token(END_OF_FILE);
+ else
+ {
+ m_pos += 2; /* Consume "?>" */
+ popState();
+ return Token(PI_CONTENT, normalizeEOL(m_data.mid(start, len), CharacterSkips()));
+ }
+ Q_ASSERT(false);
+ }
+ case EndTag:
+ {
+ if(consumeRawWhitespace())
+ return END_OF_FILE;
+
+ if(peekCurrent() == '>')
+ {
+ popState();
+ return tokenAndAdvance(G_GT);
+ }
+ else
+ return tokenizeNCNameOrQName();
+ Q_ASSERT(false);
+ }
+ case XMLComment:
+ {
+ const int start = m_pos;
+ const int len = scanUntil("--");
+
+ if(len == -1)
+ return END_OF_FILE;
+ else
+ {
+ m_pos += 2; /* Consume "--". */
+ popState();
+
+ if(peekCurrent() == '>')
+ {
+ ++m_pos;
+ return Token(COMMENT_CONTENT, normalizeEOL(m_data.mid(start, len), CharacterSkips()));
+ }
+ else
+ return error();
+ }
+ Q_ASSERT(false);
+ }
+ case Pragma:
+ {
+ /* Consume whitespace. */
+ if(consumeRawWhitespace())
+ return Token(END_OF_FILE);
+
+ setState(PragmaContent);
+ return tokenizeNCNameOrQName();
+ }
+ case PragmaContent:
+ {
+ QString result;
+ result.reserve(20);
+
+ const bool hasWS = m_pos < m_length && current().isSpace();
+
+ /* Consume all whitespace up to the pragma content(if any). */
+ if(consumeRawWhitespace())
+ return Token(END_OF_FILE);
+
+ if(peekCurrent() == '#' && peekAhead() == ')')
+ {
+ /* We reached the end, and there's no pragma content. */
+ return tokenAndChangeState(PRAGMA_END, Default, 2);
+ }
+ else if(!hasWS)
+ {
+ /* A separating space is required if there's pragma content. */
+ return error(); /* i18n */
+ }
+
+ const int start = m_pos;
+ const int len = scanUntil("#)");
+ if(len == -1)
+ return Token(END_OF_FILE);
+
+ return Token(STRING_LITERAL, m_data.mid(start, len));
+ Q_ASSERT(false);
+ }
+ }
+
+ Q_ASSERT(false);
+ return error();
+}
+
+Tokenizer::Token XQueryTokenizer::attributeAsRaw(const QChar sep,
+ int &sepStack,
+ const int startPos,
+ const bool aInLiteral,
+ QString &result)
+{
+ bool inLiteral = aInLiteral;
+ const char otherSep = (sep == QLatin1Char('"') ? '\'' : '"');
+
+ while(true)
+ {
+ if(atEnd())
+ return END_OF_FILE;
+
+ if(peekCurrent() == sep.unicode())
+ {
+ if(inLiteral)
+ inLiteral = false;
+ else
+ inLiteral = true;
+
+ if(peekAhead() == sep.unicode())
+ {
+ /* The quoting mechanism was used. */
+ result.append(current());
+ m_pos += 2;
+ continue;
+ }
+ else
+ {
+ /* Don't consume the separator, such that we
+ * return a token for it next time. */
+ if(m_pos == startPos)
+ {
+ ++m_pos;
+ setState(StartTag);
+ return Token(sep == QLatin1Char('"') ? QUOTE : APOS);
+ }
+
+
+ if(sepStack == 0)
+ {
+ return Token(STRING_LITERAL, result);
+ }
+ else
+ {
+ result.append(current());
+ ++m_pos;
+ continue;
+ }
+ }
+ }
+ else if(peekCurrent() == '&')
+ {
+ const QString ret(tokenizeCharacterReference());
+ if(ret.isNull())
+ return Token(ERROR);
+ else
+ {
+ result.append(ret);
+ ++m_pos;
+ continue;
+ }
+ }
+ else if(peekCurrent() == otherSep)
+ {
+ result.append(current());
+ ++m_pos;
+
+ if(peekCurrent() == otherSep)
+ ++m_pos;
+
+ if(inLiteral)
+ inLiteral = false;
+ else
+ inLiteral = true;
+
+ continue;
+ }
+ else if(peekCurrent() == '{')
+ {
+ result.append(current());
+
+ if(peekAhead() == '{')
+ {
+ m_pos += 2;
+ continue;
+ }
+ else
+ {
+ ++m_pos;
+ ++sepStack;
+ const Token t(attributeAsRaw(sep, sepStack, startPos, false, result));
+ if(t.type != SUCCESS)
+ return t;
+ }
+
+ }
+ else if(peekCurrent() == '}')
+ {
+ if(inLiteral && peekAhead() == '}')
+ {
+ result.append(current());
+ m_pos += 2;
+ continue;
+ }
+ else
+ {
+ ++m_pos;
+ --sepStack;
+ return Token(SUCCESS); /* The return value is arbitrary. */
+ }
+ }
+ else
+ {
+ result.append(current());
+ ++m_pos;
+ }
+ }
+}
+
+Tokenizer::Token XQueryTokenizer::nextToken(YYLTYPE *const sourceLocator)
+{
+ sourceLocator->first_line = m_line;
+ sourceLocator->first_column = m_pos - m_columnOffset + 1; /* Plus 1, since m_pos is 0-based. */
+
+ if(m_tokenStack.isEmpty())
+ return nextToken();
+ else
+ {
+ const Token retval(m_tokenStack.pop());
+
+ switch(retval.type)
+ {
+ case MODULE:
+ /* Fallthrough.*/
+ case SCHEMA:
+ /* Fallthrough.*/
+ case COPY_NAMESPACES:
+ {
+ setState(NamespaceKeyword);
+ break;
+ }
+ case VERSION:
+ {
+ setState(XQueryVersion);
+ break;
+ }
+ case AS:
+ /* Fallthrough. */
+ case OF:
+ {
+ setState(ItemType);
+ break;
+ }
+ default:
+ {
+ if(isOperatorKeyword(retval.type))
+ setState(Default);
+
+ break;
+ }
+ };
+
+ return retval;
+ }
+}
+
+int XQueryTokenizer::commenceScanOnly()
+{
+ m_scanOnly = true;
+ return m_pos;
+}
+
+void XQueryTokenizer::resumeTokenizationFrom(const int pos)
+{
+ m_scanOnly = false;
+ m_pos = pos;
+}
+
+void XQueryTokenizer::setParserContext(const ParserContext::Ptr &)
+{
+}
+
+#undef handleWhitespace
+
+} // namespace QPatternist
+
+QT_END_NAMESPACE
diff --git a/src/xmlpatterns/parser/qxquerytokenizer_p.h b/src/xmlpatterns/parser/qxquerytokenizer_p.h
new file mode 100644
index 0000000000..4ef7a5f80a
--- /dev/null
+++ b/src/xmlpatterns/parser/qxquerytokenizer_p.h
@@ -0,0 +1,332 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@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.
+#ifndef Patternist_XQueryTokenizer_H
+#define Patternist_XQueryTokenizer_H
+
+#include <QHash>
+#include <QSet>
+#include <QStack>
+#include <QString>
+#include <QUrl>
+
+#include "qtokenizer_p.h"
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+namespace QPatternist
+{
+ struct TokenMap;
+
+ /**
+ * @short A hand-written tokenizer which tokenizes XQuery 1.0 & XPath 2.0,
+ * and delivers tokens to the Bison generated parser.
+ *
+ * @author Frans Englich <fenglich@trolltech.com>
+ */
+ class XQueryTokenizer : public Tokenizer
+ {
+ public:
+ /**
+ * Tokenizer states. Organized alphabetically.
+ */
+ enum State
+ {
+ AfterAxisSeparator,
+ AposAttributeContent,
+ Axis,
+ Default,
+ ElementContent,
+ EndTag,
+ ItemType,
+ KindTest,
+ KindTestForPI,
+ NamespaceDecl,
+ NamespaceKeyword,
+ OccurrenceIndicator,
+ Operator,
+ Pragma,
+ PragmaContent,
+ ProcessingInstructionContent,
+ ProcessingInstructionName,
+ QuotAttributeContent,
+ StartTag,
+ VarName,
+ XMLComment,
+ XMLSpaceDecl,
+ XQueryVersion
+ };
+
+ XQueryTokenizer(const QString &query,
+ const QUrl &location,
+ const State startingState = Default);
+
+ virtual Token nextToken(YYLTYPE *const sourceLocator);
+ virtual int commenceScanOnly();
+ virtual void resumeTokenizationFrom(const int position);
+
+ /**
+ * Does nothing.
+ */
+ virtual void setParserContext(const ParserContext::Ptr &parseInfo);
+
+ private:
+
+ /**
+ * Returns the character corresponding to the builtin reference @p
+ * reference. For instance, passing @c gt will give you '>' in return.
+ *
+ * If @p reference is an invalid character reference, a null QChar is
+ * returned.
+ *
+ * @see QChar::isNull()
+ */
+ QChar charForReference(const QString &reference);
+
+ inline Token tokenAndChangeState(const TokenType code,
+ const State state,
+ const int advance = 1);
+ inline Token tokenAndChangeState(const TokenType code,
+ const QString &value,
+ const State state);
+ inline Token tokenAndAdvance(const TokenType code,
+ const int advance = 1);
+ QString tokenizeCharacterReference();
+
+ inline Token tokenizeStringLiteral();
+ inline Token tokenizeNumberLiteral();
+
+ /**
+ * @returns the character @p length characters from the current
+ * position.
+ */
+ inline char peekAhead(const int length = 1) const;
+
+ /**
+ * @returns whether the stream, starting from @p offset from the
+ * current position, matches @p chs. The length of @p chs is @p len.
+ */
+ inline bool aheadEquals(const char *const chs,
+ const int len,
+ const int offset = 1) const;
+
+ inline Token tokenizeNCName();
+ static inline bool isOperatorKeyword(const TokenType);
+
+ static inline bool isDigit(const char ch);
+ static inline Token error();
+ inline TokenType consumeWhitespace();
+
+ /**
+ * @short Returns the character at the current position, converted to
+ * @c ASCII.
+ *
+ * Equivalent to calling:
+ *
+ * @code
+ * current().toAscii();
+ * @endcode
+ */
+ inline char peekCurrent() const;
+
+ /**
+ * Disregarding encoding conversion, equivalent to calling:
+ *
+ * @code
+ * peekAhead(0);
+ * @endcode
+ */
+ inline const QChar current() const;
+
+ /**
+ * @p hadWhitespace is always set to a proper value.
+ *
+ * @returns the length of whitespace scanned before reaching "::", or
+ * -1 if something else was found.
+ */
+ int peekForColonColon() const;
+
+ static inline bool isNCNameStart(const QChar ch);
+ static inline bool isNCNameBody(const QChar ch);
+ static inline const TokenMap *lookupKeyword(const QString &keyword);
+ inline void popState();
+ inline void pushState(const State state);
+ inline State state() const;
+ inline void setState(const State s);
+ static bool isTypeToken(const TokenType t);
+
+ inline Token tokenizeNCNameOrQName();
+ /**
+ * Advances m_pos until content is encountered.
+ *
+ * Returned is the length stretching from m_pos when starting, until
+ * @p content is encountered. @p content is not included in the length.
+ */
+ int scanUntil(const char *const content);
+
+ /**
+ * Same as calling:
+ * @code
+ * pushState(currentState());
+ * @endcode
+ */
+ inline void pushState();
+
+ /**
+ * Consumes only whitespace, in the traditional sense. The function exits
+ * if non-whitespace is encountered, such as the start of a comment.
+ *
+ * @returns @c true if the end was reached, otherwise @c false
+ */
+ inline bool consumeRawWhitespace();
+
+ /**
+ * @short Parses comments: <tt>(: comment content :)</tt>. It recurses for
+ * parsing nested comments.
+ *
+ * It is assumed that the start token for the comment, "(:", has
+ * already been parsed.
+ *
+ * Typically, don't call this function, but ignoreWhitespace().
+ *
+ * @see <a href="http://www.w3.org/TR/xpath20/#comments">XML Path Language (XPath)
+ * 2.0, 2.6 Comments</a>
+ * @returns
+ * - SUCCESS if everything went ok
+ * - ERROR if there was an error in parsing one or more comments
+ * - END_OF_FILE if the end was reached
+ */
+ Tokenizer::TokenType consumeComment();
+
+ /**
+ * Determines whether @p code is a keyword
+ * that is followed by a second keyword. For instance <tt>declare
+ * function</tt>.
+ */
+ static inline bool isPhraseKeyword(const TokenType code);
+
+ /**
+ * A set of indexes into a QString, the one being passed to
+ * normalizeEOL() whose characters shouldn't be normalized. */
+ typedef QSet<int> CharacterSkips;
+
+ /**
+ * Returns @p input, normalized according to
+ * <a href="http://www.w3.org/TR/xquery/#id-eol-handling">XQuery 1.0:
+ * An XML Query Language, A.2.3 End-of-Line Handling</a>
+ */
+ static QString normalizeEOL(const QString &input,
+ const CharacterSkips &characterSkips);
+
+ inline bool atEnd() const
+ {
+ return m_pos == m_length;
+ }
+
+ Token nextToken();
+ /**
+ * Instead of recognizing and tokenizing embedded expressions in
+ * direct attriute constructors, this function is essentially a mini
+ * recursive-descent parser that has the necessary logic to recognize
+ * embedded expressions and their potentially interfering string literals, in
+ * order to scan to the very end of the attribute value, and return the
+ * whole as a string.
+ *
+ * There is of course syntax errors this function will not detect, but
+ * that is ok since the attributes will be parsed once more.
+ *
+ * An inelegant solution, but which gets the job done.
+ *
+ * @see commenceScanOnly(), resumeTokenizationFrom()
+ */
+ Token attributeAsRaw(const QChar separator,
+ int &stack,
+ const int startPos,
+ const bool inLiteral,
+ QString &result);
+
+ const QString m_data;
+ const int m_length;
+ State m_state;
+ QStack<State> m_stateStack;
+ int m_pos;
+
+ /**
+ * The current line number.
+ *
+ * The line number and column number both starts at 1.
+ */
+ int m_line;
+
+ /**
+ * The offset into m_length for where
+ * the current column starts. So m_length - m_columnOffset
+ * is the current column.
+ *
+ * The line number and column number both starts at 1.
+ */
+ int m_columnOffset;
+
+ const NamePool::Ptr m_namePool;
+ QStack<Token> m_tokenStack;
+ QHash<QString, QChar> m_charRefs;
+ bool m_scanOnly;
+
+ Q_DISABLE_COPY(XQueryTokenizer)
+ };
+}
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/xmlpatterns/parser/qxslttokenizer.cpp b/src/xmlpatterns/parser/qxslttokenizer.cpp
new file mode 100644
index 0000000000..11d12f87fd
--- /dev/null
+++ b/src/xmlpatterns/parser/qxslttokenizer.cpp
@@ -0,0 +1,2717 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QStringList>
+
+#include "qbuiltintypes_p.h"
+#include "qcommonnamespaces_p.h"
+#include "qquerytransformparser_p.h"
+#include "qxquerytokenizer_p.h"
+#include "qpatternistlocale_p.h"
+
+#include "qxslttokenizer_p.h"
+
+QT_BEGIN_NAMESPACE
+
+using namespace QPatternist;
+
+Tokenizer::Token SingleTokenContainer::nextToken(YYLTYPE *const location)
+{
+ if(m_hasDelivered)
+ return Tokenizer::Token(END_OF_FILE);
+ else
+ {
+ *location = m_location;
+ m_hasDelivered = true;
+ return m_token;
+ }
+}
+
+XSLTTokenizer::XSLTTokenizer(QIODevice *const queryDevice,
+ const QUrl &location,
+ const ReportContext::Ptr &context,
+ const NamePool::Ptr &np) : Tokenizer(location)
+ , MaintainingReader<XSLTTokenLookup>(createElementDescriptions(), createStandardAttributes(), context, queryDevice)
+ , m_location(location)
+ , m_namePool(np)
+ /* We initialize after all name constants. */
+ , m_validationAlternatives(createValidationAlternatives())
+ , m_parseInfo(0)
+{
+ Q_ASSERT(m_namePool);
+
+ pushState(OutsideDocumentElement);
+}
+
+bool XSLTTokenizer::isAnyAttributeAllowed() const
+{
+ return m_processingMode.top() == ForwardCompatible;
+}
+
+void XSLTTokenizer::setParserContext(const ParserContext::Ptr &parseInfo)
+{
+ m_parseInfo = parseInfo;
+}
+
+void XSLTTokenizer::validateElement() const
+{
+ MaintainingReader<XSLTTokenLookup>::validateElement(currentElementName());
+}
+
+QSet<XSLTTokenizer::NodeName> XSLTTokenizer::createStandardAttributes()
+{
+ QSet<NodeName> retval;
+ enum
+ {
+ ReservedForAttributes = 6
+ };
+
+ retval.reserve(6);
+
+ retval.insert(DefaultCollation);
+ retval.insert(ExcludeResultPrefixes);
+ retval.insert(ExtensionElementPrefixes);
+ retval.insert(UseWhen);
+ retval.insert(Version);
+ retval.insert(XpathDefaultNamespace);
+
+ Q_ASSERT(retval.count() == ReservedForAttributes);
+
+ return retval;
+}
+
+ElementDescription<XSLTTokenLookup>::Hash XSLTTokenizer::createElementDescriptions()
+{
+ ElementDescription<XSLTTokenLookup>::Hash result;
+ enum
+ {
+ ReservedForElements = 40
+ };
+ result.reserve(ReservedForElements);
+
+ /* xsl:apply-templates */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[ApplyTemplates];
+ e.optionalAttributes.insert(Select);
+ e.optionalAttributes.insert(Mode);
+ }
+
+ /* xsl:template */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[Template];
+ e.optionalAttributes.insert(Match);
+ e.optionalAttributes.insert(Name);
+ e.optionalAttributes.insert(Mode);
+ e.optionalAttributes.insert(Priority);
+ e.optionalAttributes.insert(As);
+ }
+
+ /* xsl:text, xsl:choose and xsl:otherwise */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[Text];
+ result.insert(Choose, e);
+ result.insert(Otherwise, e);
+ }
+
+ /* xsl:stylesheet */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[Stylesheet];
+
+ e.requiredAttributes.insert(Version);
+
+ e.optionalAttributes.insert(Id);
+ e.optionalAttributes.insert(ExtensionElementPrefixes);
+ e.optionalAttributes.insert(ExcludeResultPrefixes);
+ e.optionalAttributes.insert(XpathDefaultNamespace);
+ e.optionalAttributes.insert(DefaultValidation);
+ e.optionalAttributes.insert(DefaultCollation);
+ e.optionalAttributes.insert(InputTypeAnnotations);
+ }
+
+ /* xsl:transform */
+ {
+ result[Transform] = result[Stylesheet];
+ }
+
+ /* xsl:value-of */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[ValueOf];
+ e.optionalAttributes.insert(Separator);
+ e.optionalAttributes.insert(Select);
+ }
+
+ /* xsl:variable */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[Variable];
+
+ e.requiredAttributes.insert(Name);
+
+ e.optionalAttributes.insert(Select);
+ e.optionalAttributes.insert(As);
+ }
+
+ /* xsl:when & xsl:if */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[When];
+
+ e.requiredAttributes.insert(Test);
+
+ result.insert(If, e);
+ }
+
+ /* xsl:sequence, xsl:for-each */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[Sequence];
+
+ e.requiredAttributes.insert(Select);
+
+ result.insert(ForEach, e);
+ }
+
+ /* xsl:comment */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[XSLTTokenLookup::Comment];
+
+ e.optionalAttributes.insert(Select);
+ }
+
+ /* xsl:processing-instruction */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[XSLTTokenLookup::ProcessingInstruction];
+
+ e.requiredAttributes.insert(Name);
+ e.optionalAttributes.insert(Select);
+ }
+
+ /* xsl:document */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[Document];
+
+ e.optionalAttributes.insert(Validation);
+ e.optionalAttributes.insert(Type);
+ }
+
+ /* xsl:element */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[Element];
+
+ e.requiredAttributes.insert(Name);
+
+ e.optionalAttributes.insert(Namespace);
+ e.optionalAttributes.insert(InheritNamespaces);
+ e.optionalAttributes.insert(UseAttributeSets);
+ e.optionalAttributes.insert(Validation);
+ e.optionalAttributes.insert(Type);
+ }
+
+ /* xsl:attribute */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[Attribute];
+
+ e.requiredAttributes.insert(Name);
+
+ e.optionalAttributes.insert(Namespace);
+ e.optionalAttributes.insert(Select);
+ e.optionalAttributes.insert(Separator);
+ e.optionalAttributes.insert(Validation);
+ e.optionalAttributes.insert(Type);
+ }
+
+ /* xsl:function */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[Function];
+
+ e.requiredAttributes.insert(Name);
+
+ e.optionalAttributes.insert(As);
+ e.optionalAttributes.insert(Override);
+ }
+
+ /* xsl:param */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[Param];
+
+ e.requiredAttributes.insert(Name);
+
+ e.optionalAttributes.insert(Select);
+ e.optionalAttributes.insert(As);
+ e.optionalAttributes.insert(Required);
+ e.optionalAttributes.insert(Tunnel);
+ }
+
+ /* xsl:namespace */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[Namespace];
+
+ e.requiredAttributes.insert(Name);
+ e.optionalAttributes.insert(Select);
+ }
+
+ /* xsl:call-template */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[CallTemplate];
+ e.requiredAttributes.insert(Name);
+ }
+
+ /* xsl:perform-sort */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[PerformSort];
+ e.requiredAttributes.insert(Select);
+ }
+
+ /* xsl:sort */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[Sort];
+
+ e.optionalAttributes.reserve(7);
+ e.optionalAttributes.insert(Select);
+ e.optionalAttributes.insert(Lang);
+ e.optionalAttributes.insert(Order);
+ e.optionalAttributes.insert(Collation);
+ e.optionalAttributes.insert(Stable);
+ e.optionalAttributes.insert(CaseOrder);
+ e.optionalAttributes.insert(DataType);
+ }
+
+ /* xsl:import-schema */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[ImportSchema];
+
+ e.optionalAttributes.reserve(2);
+ e.optionalAttributes.insert(Namespace);
+ e.optionalAttributes.insert(SchemaLocation);
+ }
+
+ /* xsl:message */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[Message];
+
+ e.optionalAttributes.reserve(2);
+ e.optionalAttributes.insert(Select);
+ e.optionalAttributes.insert(Terminate);
+ }
+
+ /* xsl:copy-of */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[CopyOf];
+
+ e.requiredAttributes.insert(Select);
+
+ e.optionalAttributes.reserve(2);
+ e.optionalAttributes.insert(CopyNamespaces);
+ e.optionalAttributes.insert(Type);
+ e.optionalAttributes.insert(Validation);
+ }
+
+ /* xsl:copy */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[Copy];
+
+ e.optionalAttributes.reserve(5);
+ e.optionalAttributes.insert(CopyNamespaces);
+ e.optionalAttributes.insert(InheritNamespaces);
+ e.optionalAttributes.insert(UseAttributeSets);
+ e.optionalAttributes.insert(Type);
+ e.optionalAttributes.insert(Validation);
+ }
+
+ /* xsl:output */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[Output];
+
+ e.optionalAttributes.reserve(17);
+ e.optionalAttributes.insert(Name);
+ e.optionalAttributes.insert(Method);
+ e.optionalAttributes.insert(ByteOrderMark);
+ e.optionalAttributes.insert(CdataSectionElements);
+ e.optionalAttributes.insert(DoctypePublic);
+ e.optionalAttributes.insert(DoctypeSystem);
+ e.optionalAttributes.insert(Encoding);
+ e.optionalAttributes.insert(EscapeUriAttributes);
+ e.optionalAttributes.insert(IncludeContentType);
+ e.optionalAttributes.insert(Indent);
+ e.optionalAttributes.insert(MediaType);
+ e.optionalAttributes.insert(NormalizationForm);
+ e.optionalAttributes.insert(OmitXmlDeclaration);
+ e.optionalAttributes.insert(Standalone);
+ e.optionalAttributes.insert(UndeclarePrefixes);
+ e.optionalAttributes.insert(UseCharacterMaps);
+ e.optionalAttributes.insert(Version);
+ }
+
+ /* xsl:attribute-set */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[AttributeSet];
+
+ e.requiredAttributes.insert(Name);
+ e.optionalAttributes.insert(UseAttributeSets);
+ }
+
+ /* xsl:include and xsl:import. */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[Include];
+ e.requiredAttributes.insert(Href);
+ result[Import] = e;
+ }
+
+ /* xsl:with-param */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[WithParam];
+ e.requiredAttributes.insert(Name);
+
+ e.optionalAttributes.insert(Select);
+ e.optionalAttributes.insert(As);
+ e.optionalAttributes.insert(Tunnel);
+ }
+
+ /* xsl:strip-space */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[StripSpace];
+ e.requiredAttributes.insert(Elements);
+
+ result.insert(PreserveSpace, e);
+ }
+
+ /* xsl:result-document */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[ResultDocument];
+
+ e.optionalAttributes.insert(ByteOrderMark);
+ e.optionalAttributes.insert(CdataSectionElements);
+ e.optionalAttributes.insert(DoctypePublic);
+ e.optionalAttributes.insert(DoctypeSystem);
+ e.optionalAttributes.insert(Encoding);
+ e.optionalAttributes.insert(EscapeUriAttributes);
+ e.optionalAttributes.insert(Format);
+ e.optionalAttributes.insert(Href);
+ e.optionalAttributes.insert(IncludeContentType);
+ e.optionalAttributes.insert(Indent);
+ e.optionalAttributes.insert(MediaType);
+ e.optionalAttributes.insert(Method);
+ e.optionalAttributes.insert(NormalizationForm);
+ e.optionalAttributes.insert(OmitXmlDeclaration);
+ e.optionalAttributes.insert(OutputVersion);
+ e.optionalAttributes.insert(Standalone);
+ e.optionalAttributes.insert(Type);
+ e.optionalAttributes.insert(UndeclarePrefixes);
+ e.optionalAttributes.insert(UseCharacterMaps);
+ e.optionalAttributes.insert(Validation);
+ }
+
+ /* xsl:key */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[Key];
+
+ e.requiredAttributes.insert(Name);
+ e.requiredAttributes.insert(Match);
+
+ e.optionalAttributes.insert(Use);
+ e.optionalAttributes.insert(Collation);
+ }
+
+ /* xsl:analyze-string */
+ {
+ ElementDescription<XSLTTokenLookup> &e = result[AnalyzeString];
+
+ e.requiredAttributes.insert(Select);
+ e.requiredAttributes.insert(Regex);
+
+ e.optionalAttributes.insert(Flags);
+ }
+
+ /* xsl:matching-substring */
+ {
+ /* We insert a default constructed value. */
+ result[MatchingSubstring];
+ }
+
+ /* xsl:non-matching-substring */
+ {
+ /* We insert a default constructed value. */
+ result[NonMatchingSubstring];
+ }
+
+ Q_ASSERT(result.count() == ReservedForElements);
+
+ return result;
+}
+
+QHash<QString, int> XSLTTokenizer::createValidationAlternatives()
+{
+ QHash<QString, int> retval;
+
+ retval.insert(QLatin1String("preserve"), 0);
+ retval.insert(QLatin1String("strip"), 1);
+ retval.insert(QLatin1String("strict"), 2);
+ retval.insert(QLatin1String("lax"), 3);
+
+ return retval;
+}
+
+bool XSLTTokenizer::whitespaceToSkip() const
+{
+ return m_stripWhitespace.top() && isWhitespace();
+}
+
+void XSLTTokenizer::unexpectedContent(const ReportContext::ErrorCode code) const
+{
+ QString message;
+
+ ReportContext::ErrorCode effectiveCode = code;
+
+ switch(tokenType())
+ {
+ case QXmlStreamReader::StartElement:
+ {
+ if(isXSLT())
+ {
+ switch(currentElementName())
+ {
+ case Include:
+ effectiveCode = ReportContext::XTSE0170;
+ break;
+ case Import:
+ effectiveCode = ReportContext::XTSE0190;
+ break;
+ default:
+ ;
+ }
+ }
+
+ message = QtXmlPatterns::tr("Element %1 is not allowed at this location.")
+ .arg(formatKeyword(name()));
+ break;
+ }
+ case QXmlStreamReader::Characters:
+ {
+ if(whitespaceToSkip())
+ return;
+
+ message = QtXmlPatterns::tr("Text nodes are not allowed at this location.");
+ break;
+ }
+ case QXmlStreamReader::Invalid:
+ {
+ /* It's an issue with well-formedness. */
+ message = escape(errorString());
+ break;
+ }
+ default:
+ Q_ASSERT(false);
+ }
+
+ error(message, effectiveCode);
+}
+
+void XSLTTokenizer::checkForParseError() const
+{
+ if(hasError())
+ {
+ error(QtXmlPatterns::tr("Parse error: %1").arg(escape(errorString())), ReportContext::XTSE0010);
+ }
+}
+
+QString XSLTTokenizer::readElementText()
+{
+ QString result;
+
+ while(!atEnd())
+ {
+ switch(readNext())
+ {
+ case QXmlStreamReader::Characters:
+ {
+ result += text().toString();
+ continue;
+ }
+ case QXmlStreamReader::Comment:
+ /* Fallthrough. */
+ case QXmlStreamReader::ProcessingInstruction:
+ continue;
+ case QXmlStreamReader::EndElement:
+ return result;
+ default:
+ unexpectedContent();
+ }
+ }
+
+ checkForParseError();
+ return result;
+}
+
+int XSLTTokenizer::commenceScanOnly()
+{
+ /* Do nothing, return a dummy value. */
+ return 0;
+}
+
+void XSLTTokenizer::resumeTokenizationFrom(const int position)
+{
+ /* Do nothing. */
+ Q_UNUSED(position);
+}
+
+void XSLTTokenizer::handleXSLTVersion(TokenSource::Queue *const to,
+ QStack<Token> *const queueOnExit,
+ const bool isXSLTElement,
+ const QXmlStreamAttributes *atts,
+ const bool generateCode,
+ const bool setGlobalVersion)
+{
+ const QString ns(isXSLTElement ? QString() : CommonNamespaces::XSLT);
+ const QXmlStreamAttributes effectiveAtts(atts ? *atts : attributes());
+
+ if(!effectiveAtts.hasAttribute(ns, QLatin1String("version")))
+ return;
+
+ const QString attribute(effectiveAtts.value(ns, QLatin1String("version")).toString());
+ const AtomicValue::Ptr number(Decimal::fromLexical(attribute));
+
+ if(number->hasError())
+ {
+ error(QtXmlPatterns::tr("The value of the XSL-T version attribute "
+ "must be a value of type %1, which %2 isn't.").arg(formatType(m_namePool, BuiltinTypes::xsDecimal),
+ formatData(attribute)),
+ ReportContext::XTSE0110);
+ }
+ else
+ {
+
+ if(generateCode)
+ {
+ queueToken(Token(XSLT_VERSION, attribute), to);
+ queueToken(CURLY_LBRACE, to);
+ }
+
+ const xsDecimal version = number->as<Numeric>()->toDecimal();
+ if(version == 2.0)
+ m_processingMode.push(NormalProcessing);
+ else if(version == 1.0)
+ {
+ /* See section 3.6 Stylesheet Element discussing this. */
+ warning(QtXmlPatterns::tr("Running an XSL-T 1.0 stylesheet with a 2.0 processor."));
+ m_processingMode.push(BackwardsCompatible);
+
+ if(setGlobalVersion)
+ {
+ m_parseInfo->staticContext->setCompatModeEnabled(true);
+ m_parseInfo->isBackwardsCompat.push(true);
+ }
+ }
+ else if(version > 2.0)
+ m_processingMode.push(ForwardCompatible);
+ else if(version < 2.0)
+ m_processingMode.push(BackwardsCompatible);
+ }
+
+ if(generateCode)
+ queueOnExit->push(CURLY_RBRACE);
+}
+
+void XSLTTokenizer::handleXMLBase(TokenSource::Queue *const to,
+ QStack<Token> *const queueOnExit,
+ const bool isInstruction,
+ const QXmlStreamAttributes *atts)
+{
+ const QXmlStreamAttributes effectiveAtts(atts ? *atts : m_currentAttributes);
+
+ if(effectiveAtts.hasAttribute(QLatin1String("xml:base")))
+ {
+ const QStringRef val(effectiveAtts.value(QLatin1String("xml:base")));
+
+ if(!val.isEmpty())
+ {
+ if(isInstruction)
+ {
+ queueToken(BASEURI, to);
+ queueToken(Token(STRING_LITERAL, val.toString()), to);
+ queueToken(CURLY_LBRACE, to);
+ queueOnExit->push(CURLY_RBRACE);
+ }
+ else
+ {
+ queueToken(DECLARE, to);
+ queueToken(BASEURI, to);
+ queueToken(INTERNAL, to);
+ queueToken(Token(STRING_LITERAL, val.toString()), to);
+ queueToken(SEMI_COLON, to);
+ }
+ }
+ }
+}
+
+void XSLTTokenizer::handleStandardAttributes(const bool isXSLTElement)
+{
+ /* We're not necessarily StartElement, that's why we have atts passed in. */
+ Q_ASSERT(tokenType() == QXmlStreamReader::StartElement);
+
+ if(m_hasHandledStandardAttributes)
+ return;
+
+ m_hasHandledStandardAttributes = true;
+
+ const QString ns(isXSLTElement ? QString() : CommonNamespaces::XSLT);
+ const int len = m_currentAttributes.count();
+
+ for(int i = 0; i < len; ++i)
+ {
+ const QXmlStreamAttribute &att = m_currentAttributes.at(i);
+
+ if(att.qualifiedName() == QLatin1String("xml:space"))
+ {
+ const QStringRef val(m_currentAttributes.value(CommonNamespaces::XML, QLatin1String("space")));
+
+ /* We raise an error if the value is not recognized.
+ *
+ * Extensible Markup Language (XML) 1.0 (Fourth Edition), 2.10
+ * White Space Handling:
+ *
+ * 'This specification does not give meaning to any value of
+ * xml:space other than "default" and "preserve". It is an error
+ * for other values to be specified; the XML processor may report
+ * the error or may recover by ignoring the attribute specification
+ * or by reporting the (erroneous) value to the application.' */
+ m_stripWhitespace.push(readToggleAttribute(QLatin1String("xml:space"),
+ QLatin1String("default"),
+ QLatin1String("preserve"),
+ &m_currentAttributes));
+ }
+
+ if(att.namespaceUri() != ns)
+ continue;
+
+ switch(toToken(att.name()))
+ {
+ case Type:
+ /* Fallthrough. */
+ case Validation:
+ /* Fallthrough. */
+ case UseAttributeSets:
+ /* Fallthrough. */
+ case Version:
+ /* These are handled by other function such as
+ * handleValidationAttributes() and handleXSLTVersion(). */
+ continue;
+ default:
+ {
+ if(!isXSLTElement) /* validateElement() will take care of it, and we
+ * don't want to flag non-standard XSL-T attributes. */
+ {
+ error(QtXmlPatterns::tr("Unknown XSL-T attribute %1.")
+ .arg(formatKeyword(att.name())),
+ ReportContext::XTSE0805);
+ }
+ }
+ }
+ }
+}
+
+void XSLTTokenizer::handleValidationAttributes(const bool isLRE) const
+{
+ Q_ASSERT(tokenType() == QXmlStreamReader::StartElement);
+
+ const QString ns(isLRE ? QString() : CommonNamespaces::XSLT);
+
+ const bool hasValidation = hasAttribute(ns, QLatin1String("validation"));
+ const bool hasType = hasAttribute(ns, QLatin1String("type"));
+
+ if(!hasType && !hasValidation)
+ return;
+
+ if(hasType && hasValidation)
+ {
+ error(QtXmlPatterns::tr("Attribute %1 and %2 are mutually exclusive.")
+ .arg(formatKeyword(QLatin1String("validation")),
+ formatKeyword(QLatin1String("type"))),
+ ReportContext::XTSE1505);
+ }
+
+ /* QXmlStreamReader surely doesn't make this easy. */
+ QXmlStreamAttribute validationAttribute;
+ int len = m_currentAttributes.count();
+
+ for(int i = 0; i < len; ++i)
+ {
+ const QXmlStreamAttribute &at = m_currentAttributes.at(i);
+ if(at.name() == QLatin1String("validation") && at.namespaceUri() == ns)
+ validationAttribute = at;
+ }
+
+ Q_ASSERT_X(!validationAttribute.name().isNull(), Q_FUNC_INFO,
+ "We should always find the attribute.");
+
+ /* We don't care about the return value, we just want to check it's a valid
+ * one. */
+ readAlternativeAttribute(m_validationAlternatives,
+ validationAttribute);
+}
+
+Tokenizer::Token XSLTTokenizer::nextToken(YYLTYPE *const sourceLocator)
+{
+ Q_UNUSED(sourceLocator);
+
+ if(m_tokenSource.isEmpty())
+ {
+ switch(m_state.top())
+ {
+ case OutsideDocumentElement:
+ outsideDocumentElement();
+ break;
+ case InsideStylesheetModule:
+ insideStylesheetModule();
+ break;
+ case InsideSequenceConstructor:
+ insideSequenceConstructor(&m_tokenSource);
+ break;
+ }
+
+ if(m_tokenSource.isEmpty())
+ {
+ *sourceLocator = currentSourceLocator();
+ return Token(END_OF_FILE);
+ }
+ else
+ return m_tokenSource.head()->nextToken(sourceLocator);
+ }
+ else
+ {
+ do
+ {
+ const Token candidate(m_tokenSource.head()->nextToken(sourceLocator));
+ if(candidate.type == END_OF_FILE)
+ m_tokenSource.dequeue();
+ else
+ return candidate;
+ }
+ while(!m_tokenSource.isEmpty());
+
+ /* Now we will resume parsing inside the regular XSL-T(XML) file. */
+ return nextToken(sourceLocator);
+ }
+}
+
+bool XSLTTokenizer::isElement(const XSLTTokenLookup::NodeName &name) const
+{
+ Q_ASSERT(isXSLT());
+ Q_ASSERT(tokenType() == QXmlStreamReader::StartElement ||
+ tokenType() == QXmlStreamReader::EndElement);
+
+ return currentElementName() == name;
+}
+
+inline bool XSLTTokenizer::isXSLT() const
+{
+ Q_ASSERT_X(tokenType() == QXmlStreamReader::StartElement ||
+ tokenType() == QXmlStreamReader::EndElement,
+ Q_FUNC_INFO, "The current token state must be StartElement or EndElement.");
+ /* Possible optimization: let MaintainingReader set an m_isXSLT which we
+ * read. */
+ return namespaceUri() == CommonNamespaces::XSLT;
+}
+
+void XSLTTokenizer::queueOnExit(QStack<Token> &source,
+ TokenSource::Queue *const destination)
+{
+ while(!source.isEmpty())
+ queueToken(source.pop(), destination);
+}
+
+void XSLTTokenizer::outsideDocumentElement()
+{
+ while(!atEnd())
+ {
+ switch(readNext())
+ {
+ case QXmlStreamReader::StartElement:
+ {
+ /* First, we synthesize one of the built-in templates,
+ * see section 6.6 Built-in Template Rules.
+ *
+ * Note that insideStylesheetModule() can be called multiple
+ * times so we can't do it there. */
+ {
+ /* Start with the one for text nodes and attributes.
+ * declare template matches (text() | @*) mode #all
+ * {
+ * text{.}
+ * };
+ */
+
+ /* declare template matches (text() | @*) */
+ queueToken(DECLARE, &m_tokenSource);
+ queueToken(TEMPLATE, &m_tokenSource);
+ queueToken(MATCHES, &m_tokenSource);
+ queueToken(LPAREN, &m_tokenSource);
+ queueToken(TEXT, &m_tokenSource);
+ queueToken(LPAREN, &m_tokenSource);
+ queueToken(RPAREN, &m_tokenSource);
+ queueToken(BAR, &m_tokenSource);
+ queueToken(AT_SIGN, &m_tokenSource);
+ queueToken(STAR, &m_tokenSource);
+ queueToken(RPAREN, &m_tokenSource);
+
+ /* mode #all */
+ queueToken(MODE, &m_tokenSource);
+ queueToken(Token(NCNAME, QLatin1String("#all")), &m_tokenSource);
+ queueToken(CURLY_LBRACE, &m_tokenSource);
+
+ /* text{.} { */
+ queueToken(TEXT, &m_tokenSource);
+ queueToken(CURLY_LBRACE, &m_tokenSource);
+ queueToken(DOT, &m_tokenSource);
+ queueToken(CURLY_RBRACE, &m_tokenSource);
+
+ /* }; */
+ queueToken(CURLY_RBRACE, &m_tokenSource);
+ queueToken(SEMI_COLON, &m_tokenSource);
+ }
+
+ if(isXSLT() && isStylesheetElement())
+ {
+ handleStandardAttributes(true);
+ QStack<Token> onExitTokens;
+ handleXMLBase(&m_tokenSource, &onExitTokens, false);
+ handleXSLTVersion(&m_tokenSource, &onExitTokens, true, 0, false, true);
+ validateElement();
+ queueNamespaceDeclarations(&m_tokenSource, 0, true);
+
+ /* We're a regular stylesheet. */
+
+ pushState(InsideStylesheetModule);
+ insideStylesheetModule();
+ }
+ else
+ {
+ /* We're a simplified stylesheet. */
+
+ if(!hasAttribute(CommonNamespaces::XSLT, QLatin1String("version")))
+ {
+ error(QtXmlPatterns::tr("In a simplified stylesheet module, attribute %1 must be present.")
+ .arg(formatKeyword(QLatin1String("version"))),
+ ReportContext::XTSE0010);
+ }
+
+ QStack<Token> onExitTokens;
+
+ /* We synthesize this as exemplified in
+ * 3.7 Simplified Stylesheet Modules. */
+ queueToken(DECLARE, &m_tokenSource);
+ queueToken(TEMPLATE, &m_tokenSource);
+ queueToken(MATCHES, &m_tokenSource);
+ queueToken(LPAREN, &m_tokenSource);
+ queueToken(SLASH, &m_tokenSource);
+ queueToken(RPAREN, &m_tokenSource);
+ queueToken(CURLY_LBRACE, &m_tokenSource);
+ pushState(InsideSequenceConstructor);
+
+ handleXSLTVersion(&m_tokenSource, &onExitTokens, false, 0, true);
+ handleStandardAttributes(false);
+
+ insideSequenceConstructor(&m_tokenSource, false);
+
+ queueOnExit(onExitTokens, &m_tokenSource);
+ queueToken(CURLY_RBRACE, &m_tokenSource);
+ queueToken(CURLY_RBRACE, &m_tokenSource);
+ queueToken(SEMI_COLON, &m_tokenSource);
+ }
+
+ queueToken(APPLY_TEMPLATE, &m_tokenSource);
+ queueToken(LPAREN, &m_tokenSource);
+ queueToken(RPAREN, &m_tokenSource);
+
+ break;
+ }
+ default:
+ /* Do nothing. */;
+ }
+ }
+ checkForParseError();
+}
+
+void XSLTTokenizer::queueToken(const Token &token,
+ TokenSource::Queue *const to)
+{
+ TokenSource::Queue *const effective = to ? to : &m_tokenSource;
+
+ effective->enqueue(TokenSource::Ptr(new SingleTokenContainer(token, currentSourceLocator())));
+}
+
+void XSLTTokenizer::pushState(const State nextState)
+{
+ m_state.push(nextState);
+}
+
+void XSLTTokenizer::leaveState()
+{
+ m_state.pop();
+}
+
+void XSLTTokenizer::insideTemplate()
+{
+ const bool hasPriority = hasAttribute(QLatin1String("priority"));
+ const bool hasMatch = hasAttribute(QLatin1String("match"));
+ const bool hasName = hasAttribute(QLatin1String("name"));
+ const bool hasMode = hasAttribute(QLatin1String("mode"));
+ const bool hasAs = hasAttribute(QLatin1String("as"));
+
+ if(!hasMatch &&
+ (hasMode ||
+ hasPriority))
+ {
+ error(QtXmlPatterns::tr("If element %1 has no attribute %2, it cannot have attribute %3 or %4.")
+ .arg(formatKeyword(QLatin1String("template")),
+ formatKeyword(QLatin1String("match")),
+ formatKeyword(QLatin1String("mode")),
+ formatKeyword(QLatin1String("priority"))),
+ ReportContext::XTSE0500);
+ }
+ else if(!hasMatch && !hasName)
+ {
+ error(QtXmlPatterns::tr("Element %1 must have at least one of the attributes %2 or %3.")
+ .arg(formatKeyword(QLatin1String("template")),
+ formatKeyword(QLatin1String("name")),
+ formatKeyword(QLatin1String("match"))),
+ ReportContext::XTSE0500);
+ }
+
+ queueToken(DECLARE, &m_tokenSource);
+ queueToken(TEMPLATE, &m_tokenSource);
+
+ if(hasName)
+ {
+ queueToken(NAME, &m_tokenSource);
+ queueToken(Token(QNAME, readAttribute(QLatin1String("name"))), &m_tokenSource);
+ }
+
+ if(hasMatch)
+ {
+ queueToken(MATCHES, &m_tokenSource);
+ queueExpression(readAttribute(QLatin1String("match")), &m_tokenSource);
+ }
+
+ if(hasMode)
+ {
+ const QString modeString(readAttribute(QLatin1String("mode")).simplified());
+
+ if(modeString.isEmpty())
+ {
+ error(QtXmlPatterns::tr("At least one mode must be specified in the %1-attribute on element %2.")
+ .arg(formatKeyword(QLatin1String("mode")),
+ formatKeyword(QLatin1String("template"))),
+ ReportContext::XTSE0500);
+ }
+
+ queueToken(MODE, &m_tokenSource);
+
+ const QStringList modeList(modeString.split(QLatin1Char(' ')));
+
+ for(int i = 0; i < modeList.count(); ++i)
+ {
+ const QString &mode = modeList.at(i);
+
+ queueToken(Token(mode.contains(QLatin1Char(':')) ? QNAME : NCNAME, mode), &m_tokenSource);
+
+ if(i < modeList.count() - 1)
+ queueToken(COMMA, &m_tokenSource);
+ }
+ }
+
+ if(hasPriority)
+ {
+ queueToken(PRIORITY, &m_tokenSource);
+ queueToken(Token(STRING_LITERAL, readAttribute(QLatin1String("priority"))), &m_tokenSource);
+ }
+
+ QStack<Token> onExitTokens;
+ Q_ASSERT(tokenType() == QXmlStreamReader::StartElement);
+
+ /* queueParams moves the reader so we need to freeze the attributes. */
+ const QXmlStreamAttributes atts(m_currentAttributes);
+ handleStandardAttributes(true);
+ queueToken(LPAREN, &m_tokenSource);
+ queueParams(Template, &m_tokenSource);
+ queueToken(RPAREN, &m_tokenSource);
+
+ if(hasAs)
+ {
+ queueToken(AS, &m_tokenSource);
+ queueSequenceType(atts.value(QLatin1String("as")).toString());
+ }
+
+ queueToken(CURLY_LBRACE, &m_tokenSource);
+
+ handleXMLBase(&m_tokenSource, &onExitTokens, true, &atts);
+ handleXSLTVersion(&m_tokenSource, &onExitTokens, true, &atts);
+ pushState(InsideSequenceConstructor);
+ startStorageOfCurrent(&m_tokenSource);
+ insideSequenceConstructor(&m_tokenSource, onExitTokens, false);
+ queueOnExit(onExitTokens, &m_tokenSource);
+}
+
+void XSLTTokenizer::queueExpression(const QString &expr,
+ TokenSource::Queue *const to,
+ const bool wrapWithParantheses)
+{
+ TokenSource::Queue *const effectiveTo = to ? to : &m_tokenSource;
+
+ if(wrapWithParantheses)
+ queueToken(LPAREN, effectiveTo);
+
+ effectiveTo->enqueue(TokenSource::Ptr(new XQueryTokenizer(expr, queryURI())));
+
+ if(wrapWithParantheses)
+ queueToken(RPAREN, effectiveTo);
+}
+
+void XSLTTokenizer::queueAVT(const QString &expr,
+ TokenSource::Queue *const to)
+{
+ queueToken(AVT, to);
+ queueToken(LPAREN, to);
+ to->enqueue(TokenSource::Ptr(new XQueryTokenizer(expr, queryURI(),
+ XQueryTokenizer::QuotAttributeContent)));
+ queueToken(RPAREN, to);
+}
+
+void XSLTTokenizer::queueSequenceType(const QString &expr)
+{
+ m_tokenSource.enqueue(TokenSource::Ptr(new XQueryTokenizer(expr, queryURI(),
+ XQueryTokenizer::ItemType)));
+}
+
+void XSLTTokenizer::commencingExpression(bool &hasWrittenExpression,
+ TokenSource::Queue *const to)
+{
+ if(hasWrittenExpression)
+ queueToken(COMMA, to);
+ else
+ hasWrittenExpression = true;
+}
+
+void XSLTTokenizer::queueEmptySequence(TokenSource::Queue *const to)
+{
+ queueToken(LPAREN, to);
+ queueToken(RPAREN, to);
+}
+
+void XSLTTokenizer::insideChoose(TokenSource::Queue *const to)
+{
+ Q_ASSERT(tokenType() == QXmlStreamReader::StartElement);
+ bool hasHandledOtherwise = false;
+ bool hasEncounteredAtLeastOneWhen = false;
+
+ while(!atEnd())
+ {
+ switch(readNext())
+ {
+ case QXmlStreamReader::StartElement:
+ {
+ if(isXSLT())
+ {
+ QStack<Token> onExitTokens;
+ handleStandardAttributes(true);
+ validateElement();
+
+ switch(currentElementName())
+ {
+ case When:
+ {
+ if(hasHandledOtherwise)
+ {
+ error(QtXmlPatterns::tr("Element %1 must come last.")
+ .arg(formatKeyword(QLatin1String("otherwise"))),
+ ReportContext::XTSE0010);
+ }
+
+ queueToken(IF, to);
+ queueToken(LPAREN, to);
+ queueExpression(readAttribute(QLatin1String("test")), to);
+ queueToken(RPAREN, to);
+ queueToken(THEN, to);
+ queueToken(LPAREN, to);
+ pushState(InsideSequenceConstructor);
+ insideSequenceConstructor(to);
+ queueToken(RPAREN, to);
+ Q_ASSERT(tokenType() == QXmlStreamReader::EndElement);
+ queueToken(ELSE, to);
+ hasEncounteredAtLeastOneWhen = true;
+ queueOnExit(onExitTokens, to);
+ break;
+ }
+ case Otherwise:
+ {
+ if(!hasEncounteredAtLeastOneWhen)
+ {
+ error(QtXmlPatterns::tr("At least one %1-element must occur before %2.")
+ .arg(formatKeyword(QLatin1String("when")),
+ formatKeyword(QLatin1String("otherwise"))),
+ ReportContext::XTSE0010);
+ }
+ else if(hasHandledOtherwise)
+ {
+ error(QtXmlPatterns::tr("Only one %1-element can appear.")
+ .arg(formatKeyword(QLatin1String("otherwise"))),
+ ReportContext::XTSE0010);
+ }
+
+ pushState(InsideSequenceConstructor);
+ queueToken(LPAREN, to);
+ insideSequenceConstructor(to, to);
+ queueToken(RPAREN, to);
+ hasHandledOtherwise = true;
+ queueOnExit(onExitTokens, to);
+ break;
+ }
+ default:
+ unexpectedContent();
+ }
+ }
+ else
+ unexpectedContent();
+ break;
+ }
+ case QXmlStreamReader::EndElement:
+ {
+ if(isXSLT())
+ {
+ switch(currentElementName())
+ {
+ case Choose:
+ {
+ if(!hasEncounteredAtLeastOneWhen)
+ {
+ error(QtXmlPatterns::tr("At least one %1-element must occur inside %2.")
+ .arg(formatKeyword(QLatin1String("when")),
+ formatKeyword(QLatin1String("choose"))),
+ ReportContext::XTSE0010);
+ }
+
+ if(!hasHandledOtherwise)
+ queueEmptySequence(to);
+ return;
+ }
+ case Otherwise:
+ continue;
+ default:
+ unexpectedContent();
+ }
+ }
+ else
+ unexpectedContent();
+ break;
+ }
+ case QXmlStreamReader::Comment:
+ /* Fallthrough. */
+ case QXmlStreamReader::ProcessingInstruction:
+ continue;
+ case QXmlStreamReader::Characters:
+ {
+ /* We ignore regardless of what xml:space says, see step 4 in
+ * 4.2 Stripping Whitespace from the Stylesheet. */
+ if(isWhitespace())
+ continue;
+ /* Fallthrough. */
+ }
+ default:
+ /* Fallthrough. */
+ unexpectedContent();
+ break;
+ }
+ }
+ checkForParseError();
+}
+
+bool XSLTTokenizer::queueSelectOrSequenceConstructor(const ReportContext::ErrorCode code,
+ const bool emptynessAllowed,
+ TokenSource::Queue *const to,
+ const QXmlStreamAttributes *const attsP,
+ const bool queueEmptyOnEmpty)
+{
+ Q_ASSERT(tokenType() == QXmlStreamReader::StartElement || attsP);
+ const NodeName elementName(currentElementName());
+ const QXmlStreamAttributes atts(attsP ? *attsP : m_currentAttributes);
+
+ if(atts.hasAttribute(QLatin1String("select")))
+ {
+ queueExpression(atts.value(QLatin1String("select")).toString(), to);
+
+ /* First, verify that we don't have a body. */
+ if(skipSubTree(true))
+ {
+ error(QtXmlPatterns::tr("When attribute %1 is present on %2, a sequence "
+ "constructor cannot be used.").arg(formatKeyword(QLatin1String("select")),
+ formatKeyword(toString(elementName))),
+ code);
+ }
+
+ return true;
+ }
+ else
+ {
+ pushState(InsideSequenceConstructor);
+ if(!insideSequenceConstructor(to, true, queueEmptyOnEmpty) && !emptynessAllowed)
+ {
+ error(QtXmlPatterns::tr("Element %1 must have either a %2-attribute "
+ "or a sequence constructor.").arg(formatKeyword(toString(elementName)),
+ formatKeyword(QLatin1String("select"))),
+ code);
+
+ }
+
+ return false;
+ }
+}
+
+void XSLTTokenizer::queueSimpleContentConstructor(const ReportContext::ErrorCode code,
+ const bool emptynessAllowed,
+ TokenSource::Queue *const to,
+ const bool selectOnlyFirst)
+{
+ queueToken(INTERNAL_NAME, to);
+ queueToken(Token(NCNAME, QLatin1String("generic-string-join")), to);
+ queueToken(LPAREN, to);
+
+ /* We have to read the attribute before calling
+ * queueSelectOrSequenceConstructor(), since it advances the reader. */
+ const bool hasSeparator = m_currentAttributes.hasAttribute(QLatin1String("separator"));
+ const QString separatorAVT(m_currentAttributes.value(QLatin1String("separator")).toString());
+
+ queueToken(LPAREN, to);
+ const bool viaSelectAttribute = queueSelectOrSequenceConstructor(code, emptynessAllowed, to);
+ queueToken(RPAREN, to);
+
+ if(selectOnlyFirst)
+ {
+ queueToken(LBRACKET, to);
+ queueToken(Token(NUMBER, QChar::fromLatin1('1')), to);
+ queueToken(RBRACKET, to);
+ }
+
+ queueToken(COMMA, to);
+
+ if(hasSeparator)
+ queueAVT(separatorAVT, to);
+ else
+ {
+ /* The default value depends on whether the value is from @select, or from
+ * the sequence constructor. */
+ queueToken(Token(STRING_LITERAL, viaSelectAttribute ? QString(QLatin1Char(' '))
+ : QString()),
+ to);
+ }
+
+ queueToken(RPAREN, to);
+}
+
+void XSLTTokenizer::queueTextConstructor(QString &chars,
+ bool &hasWrittenExpression,
+ TokenSource::Queue *const to)
+{
+ if(!chars.isEmpty())
+ {
+ commencingExpression(hasWrittenExpression, to);
+ queueToken(TEXT, to);
+ queueToken(CURLY_LBRACE, to);
+ queueToken(Token(STRING_LITERAL, chars), to);
+ queueToken(CURLY_RBRACE, to);
+ chars.clear();
+ }
+}
+
+void XSLTTokenizer::queueVariableDeclaration(const VariableType variableType,
+ TokenSource::Queue *const to)
+{
+ Q_ASSERT(tokenType() == QXmlStreamReader::StartElement);
+
+ if(variableType == VariableInstruction)
+ {
+ queueToken(LET, to);
+ queueToken(INTERNAL, to);
+ }
+ else if(variableType == VariableDeclaration || variableType == GlobalParameter)
+ {
+ queueToken(DECLARE, to);
+ queueToken(VARIABLE, to);
+ queueToken(INTERNAL, to);
+ }
+
+ queueToken(DOLLAR, to);
+
+ queueExpression(readAttribute(QLatin1String("name")), to, false);
+
+ const bool hasAs = m_currentAttributes.hasAttribute(QLatin1String("as"));
+ if(hasAs)
+ {
+ queueToken(AS, to);
+ queueSequenceType(m_currentAttributes.value(QLatin1String("as")).toString());
+ }
+
+ if(variableType == FunctionParameter)
+ {
+ skipBodyOfParam(ReportContext::XTSE0760);
+ return;
+ }
+
+ /* We must do this here, because queueSelectOrSequenceConstructor()
+ * advances the reader. */
+ const bool hasSelect = hasAttribute(QLatin1String("select"));
+ const bool isRequired = hasAttribute(QLatin1String("required")) ? attributeYesNo(QLatin1String("required")) : false;
+
+ TokenSource::Queue storage;
+ queueSelectOrSequenceConstructor(ReportContext::XTSE0620, true, &storage, 0, false);
+
+ /* XSL-T has some wicked rules, see
+ * 9.3 Values of Variables and Parameters. */
+
+ const bool hasQueuedContent = !storage.isEmpty();
+
+ /* The syntax for global parameters is:
+ *
+ * declare variable $var external := 'defaultValue';
+ */
+ if(variableType == GlobalParameter)
+ queueToken(EXTERNAL, to);
+
+ if(isRequired)
+ {
+ if(hasQueuedContent)
+ {
+ error(QtXmlPatterns::tr("When a parameter is required, a default value "
+ "cannot be supplied through a %1-attribute or "
+ "a sequence constructor.").arg(formatKeyword(QLatin1String("select"))),
+ ReportContext::XTSE0010);
+ }
+ }
+ else
+ {
+ if(hasQueuedContent)
+ {
+ queueToken(ASSIGN, to);
+
+ if(!hasSelect && !hasAs && !hasQueuedContent)
+ queueToken(Token(STRING_LITERAL, QString()), to);
+ else if(hasAs || hasSelect)
+ queueToken(LPAREN, to);
+ else
+ {
+ queueToken(DOCUMENT, to);
+ queueToken(INTERNAL, to);
+ queueToken(CURLY_LBRACE, to);
+ }
+ }
+ else
+ {
+ if(!hasAs)
+ {
+ queueToken(ASSIGN, to);
+ queueToken(Token(STRING_LITERAL, QString()), to);
+ }
+ else if(variableType == VariableDeclaration || variableType == VariableInstruction)
+ {
+ queueToken(ASSIGN, to);
+ queueEmptySequence(to);
+ }
+ }
+
+ /* storage has tokens if hasSelect or hasQueuedContent is true. */
+ if(hasSelect | hasQueuedContent)
+ *to += storage;
+
+ if(hasQueuedContent)
+ {
+ if(!hasSelect && !hasAs && !hasQueuedContent)
+ queueToken(Token(STRING_LITERAL, QString()), to);
+ else if(hasAs || hasSelect)
+ queueToken(RPAREN, to);
+ else
+ queueToken(CURLY_RBRACE, to);
+ }
+ }
+
+ if(variableType == VariableInstruction)
+ queueToken(RETURN, to);
+ else if(variableType == VariableDeclaration || variableType == GlobalParameter)
+ queueToken(SEMI_COLON, to);
+}
+
+void XSLTTokenizer::startStorageOfCurrent(TokenSource::Queue *const to)
+{
+ queueToken(CURRENT, to);
+ queueToken(CURLY_LBRACE, to);
+}
+
+void XSLTTokenizer::endStorageOfCurrent(TokenSource::Queue *const to)
+{
+ queueToken(CURLY_RBRACE, to);
+}
+
+void XSLTTokenizer::queueNamespaceDeclarations(TokenSource::Queue *const to,
+ QStack<Token> *const queueOnExit,
+ const bool isDeclaration)
+{
+ Q_ASSERT(tokenType() == QXmlStreamReader::StartElement);
+ Q_ASSERT_X(isDeclaration || queueOnExit,
+ Q_FUNC_INFO,
+ "If isDeclaration is false, queueOnExit must be passed.");
+
+ const QXmlStreamNamespaceDeclarations nss(namespaceDeclarations());
+
+ for(int i = 0; i < nss.count(); ++i)
+ {
+ const QXmlStreamNamespaceDeclaration &at = nss.at(i);
+ queueToken(DECLARE, to);
+ queueToken(NAMESPACE, to);
+ queueToken(Token(NCNAME, at.prefix().toString()), to);
+ queueToken(G_EQ, to);
+ queueToken(Token(STRING_LITERAL, at.namespaceUri().toString()), to);
+
+ if(isDeclaration)
+ {
+ queueToken(INTERNAL, to);
+ queueToken(SEMI_COLON, to);
+ }
+ else
+ {
+ queueToken(CURLY_LBRACE, to);
+ queueOnExit->push(CURLY_RBRACE);
+ }
+ }
+}
+
+bool XSLTTokenizer::insideSequenceConstructor(TokenSource::Queue *const to,
+ const bool initialAdvance,
+ const bool queueEmptyOnEmpty)
+{
+ QStack<Token> onExitTokens;
+ return insideSequenceConstructor(to, onExitTokens, initialAdvance, queueEmptyOnEmpty);
+}
+
+bool XSLTTokenizer::insideSequenceConstructor(TokenSource::Queue *const to,
+ QStack<Token> &onExitTokens,
+ const bool initialAdvance,
+ const bool queueEmptyOnEmpty)
+{
+ bool effectiveInitialAdvance = initialAdvance;
+ bool hasWrittenExpression = false;
+
+ /* Buffer which all text nodes, that might be split up by comments,
+ * processing instructions and CDATA sections, are appended to. */
+ QString characters;
+
+ while(!atEnd())
+ {
+ if(effectiveInitialAdvance)
+ readNext();
+ else
+ effectiveInitialAdvance = true;
+
+ switch(tokenType())
+ {
+ case QXmlStreamReader::StartElement:
+ {
+ queueTextConstructor(characters, hasWrittenExpression, to);
+ handleXMLBase(to, &onExitTokens);
+
+ pushState(InsideSequenceConstructor);
+
+ commencingExpression(hasWrittenExpression, to);
+
+ if(isXSLT())
+ {
+ handleXSLTVersion(&m_tokenSource, &onExitTokens, true);
+ handleStandardAttributes(true);
+ validateElement();
+
+ queueNamespaceDeclarations(to, &onExitTokens);
+
+ switch(currentElementName())
+ {
+ case If:
+ {
+ queueToken(IF, to);
+ queueToken(LPAREN, to);
+
+ queueExpression(readAttribute(QLatin1String("test")), to);
+ queueToken(RPAREN, to);
+ queueToken(THEN, to);
+
+ queueToken(LPAREN, to);
+ pushState(InsideSequenceConstructor);
+ insideSequenceConstructor(to);
+
+ break;
+ }
+ case Choose:
+ {
+ insideChoose(to);
+ break;
+ }
+ case ValueOf:
+ {
+ /* We generate a computed text node constructor. */
+ queueToken(TEXT, to);
+ queueToken(CURLY_LBRACE, to);
+
+ queueSimpleContentConstructor(ReportContext::XTSE0870, true, to,
+ !hasAttribute(QLatin1String("separator")) && m_processingMode.top() == BackwardsCompatible);
+ queueToken(CURLY_RBRACE, to);
+ break;
+ }
+ case Sequence:
+ {
+ queueExpression(readAttribute(QLatin1String("select")), to);
+ parseFallbacksOnly();
+ break;
+ }
+ case Text:
+ {
+ queueToken(TEXT, to);
+ queueToken(CURLY_LBRACE, to);
+
+ queueToken(Token(STRING_LITERAL, readElementText()), to);
+ queueToken(CURLY_RBRACE, to);
+ break;
+ }
+ case Variable:
+ {
+ queueVariableDeclaration(VariableInstruction, to);
+
+ /* We wrap the children in parantheses since we may
+ * queue several expressions using the comma operator,
+ * and in that case the let-binding is only in-scope
+ * for the first expression. */
+ queueToken(LPAREN, to);
+
+ /* We don't want a comma outputted, we're expecting an
+ * expression now. */
+ hasWrittenExpression = false;
+
+ onExitTokens.push(RPAREN);
+
+ break;
+ }
+ case CallTemplate:
+ {
+ queueToken(CALL_TEMPLATE, to);
+ queueToken(Token(QNAME, readAttribute(QLatin1String("name"))), to);
+ queueToken(LPAREN, to);
+ queueWithParams(CallTemplate, to);
+ queueToken(RPAREN, to);
+ break;
+ }
+ case ForEach:
+ {
+ queueExpression(readAttribute(QLatin1String("select")), to);
+ queueToken(MAP, to);
+ pushState(InsideSequenceConstructor);
+
+ TokenSource::Queue sorts;
+ queueSorting(false, &sorts);
+
+
+ if(sorts.isEmpty())
+ {
+ startStorageOfCurrent(to);
+ insideSequenceConstructor(to, false);
+ endStorageOfCurrent(to);
+ }
+ else
+ {
+ queueToken(SORT, to);
+ *to += sorts;
+ queueToken(RETURN, to);
+ startStorageOfCurrent(to);
+ insideSequenceConstructor(to, false);
+ endStorageOfCurrent(to);
+ queueToken(END_SORT, to);
+ }
+
+ break;
+ }
+ case XSLTTokenLookup::Comment:
+ {
+ queueToken(COMMENT, to);
+ queueToken(INTERNAL, to);
+ queueToken(CURLY_LBRACE, to);
+ queueSelectOrSequenceConstructor(ReportContext::XTSE0940, true, to);
+ queueToken(CURLY_RBRACE, to);
+ break;
+ }
+ case CopyOf:
+ {
+ queueExpression(readAttribute(QLatin1String("select")), to);
+ // TODO
+
+ if(readNext() == QXmlStreamReader::EndElement)
+ break;
+ else
+ {
+ error(QtXmlPatterns::tr("Element %1 cannot have children.").arg(formatKeyword(QLatin1String("copy-of"))),
+ ReportContext::XTSE0010);
+ }
+ break;
+ }
+ case AnalyzeString:
+ {
+ // TODO
+ skipSubTree();
+ break;
+ }
+ case ResultDocument:
+ {
+ // TODO
+ pushState(InsideSequenceConstructor);
+ insideSequenceConstructor(to);
+ break;
+ }
+ case Copy:
+ {
+ /* We translate:
+ * <xsl:copy>expr</xsl:copy>
+ * into:
+ *
+ * let $body := expr
+ * return
+ * if(self::element()) then
+ * element internal {node-name()} {$body}
+ * else if(self::document-node()) then
+ * document internal {$body}
+ * else (: This includes comments, processing-instructions,
+ * attributes, and comments. :)
+ * .
+ *
+ * TODO node identity is the same as the old node.
+ * TODO namespace bindings are lost when elements are constructed
+ */
+
+ /* let $body := expr */
+ queueToken(LET, to);
+ queueToken(INTERNAL, to);
+ queueToken(DOLLAR, to);
+ queueToken(Token(NCNAME, QString(QLatin1Char('b'))), to); // TODO we need an internal name
+ queueToken(ASSIGN, to);
+ queueToken(LPAREN, to);
+ pushState(InsideSequenceConstructor);
+ /* Don't queue an empty sequence, we want the dot. */
+ insideSequenceConstructor(to);
+ queueToken(RPAREN, to);
+ queueToken(RETURN, to);
+
+ /* if(self::element()) then */
+ queueToken(IF, to);
+ queueToken(LPAREN, to);
+ queueToken(SELF, to);
+ queueToken(COLONCOLON, to);
+ queueToken(ELEMENT, to);
+ queueToken(LPAREN, to);
+ queueToken(RPAREN, to);
+ queueToken(RPAREN, to);
+ queueToken(THEN, to);
+
+ /* element internal {node-name()} {$body} */
+ queueToken(ELEMENT, to);
+ queueToken(INTERNAL, to);
+ queueToken(CURLY_LBRACE, to);
+ queueToken(Token(NCNAME, QLatin1String("node-name")), to); // TODO what if the default ns changes?
+ queueToken(LPAREN, to);
+ queueToken(DOT, to);
+ queueToken(RPAREN, to);
+ queueToken(CURLY_RBRACE, to);
+ queueToken(CURLY_LBRACE, to);
+ queueToken(DOLLAR, to);
+ queueToken(Token(NCNAME, QString(QLatin1Char('b'))), to); // TODO we need an internal name
+ queueToken(CURLY_RBRACE, to);
+
+ /* else if(self::document-node()) then */
+ queueToken(ELSE, to);
+ queueToken(IF, to);
+ queueToken(LPAREN, to);
+ queueToken(SELF, to);
+ queueToken(COLONCOLON, to);
+ queueToken(DOCUMENT_NODE, to);
+ queueToken(LPAREN, to);
+ queueToken(RPAREN, to);
+ queueToken(RPAREN, to);
+ queueToken(THEN, to);
+
+ /* document internal {$body} */
+ queueToken(DOCUMENT, to);
+ queueToken(INTERNAL, to);
+ queueToken(CURLY_LBRACE, to);
+ queueToken(DOLLAR, to);
+ queueToken(Token(NCNAME, QString(QLatin1Char('b'))), to); // TODO we need an internal name
+ queueToken(CURLY_RBRACE, to);
+
+ /* else . */
+ queueToken(ELSE, to);
+ queueToken(DOT, to);
+
+ break;
+ }
+ case XSLTTokenLookup::ProcessingInstruction:
+ {
+ queueToken(PROCESSING_INSTRUCTION, to);
+ queueToken(CURLY_LBRACE, to);
+ queueAVT(readAttribute(QLatin1String("name")), to);
+ queueToken(CURLY_RBRACE, to);
+ queueToken(CURLY_LBRACE, to);
+ queueSelectOrSequenceConstructor(ReportContext::XTSE0880, true, to);
+ queueToken(CURLY_RBRACE, to);
+ break;
+ }
+ case Document:
+ {
+ handleValidationAttributes(false);
+
+ // TODO base-URI
+ queueToken(DOCUMENT, to);
+ queueToken(INTERNAL, to);
+ queueToken(CURLY_LBRACE, to);
+ pushState(InsideSequenceConstructor);
+ insideSequenceConstructor(to);
+ queueToken(CURLY_RBRACE, to);
+ break;
+ }
+ case Element:
+ {
+ handleValidationAttributes(false);
+
+ // TODO base-URI
+ queueToken(ELEMENT, to);
+ queueToken(INTERNAL, to);
+
+ /* The name. */
+ queueToken(CURLY_LBRACE, to);
+ // TODO only strings allowed, not qname values.
+ queueAVT(readAttribute(QLatin1String("name")), to);
+ queueToken(CURLY_RBRACE, to);
+
+ /* The sequence constructor. */
+ queueToken(CURLY_LBRACE, to);
+ pushState(InsideSequenceConstructor);
+ insideSequenceConstructor(to);
+ queueToken(CURLY_RBRACE, to);
+ break;
+ }
+ case Attribute:
+ {
+ handleValidationAttributes(false);
+
+ // TODO base-URI
+ queueToken(ATTRIBUTE, to);
+ queueToken(INTERNAL, to);
+
+ /* The name. */
+ queueToken(CURLY_LBRACE, to);
+ // TODO only strings allowed, not qname values.
+ queueAVT(readAttribute(QLatin1String("name")), to);
+ queueToken(CURLY_RBRACE, to);
+
+ /* The sequence constructor. */
+ queueToken(CURLY_LBRACE, to);
+ queueSimpleContentConstructor(ReportContext::XTSE0840,
+ true, to);
+ queueToken(CURLY_RBRACE, to);
+ break;
+ }
+ case Namespace:
+ {
+ queueToken(NAMESPACE, to);
+
+ /* The name. */
+ queueToken(CURLY_LBRACE, to);
+ queueAVT(readAttribute(QLatin1String("name")), to);
+ queueToken(CURLY_RBRACE, to);
+
+ /* The sequence constructor. */
+ queueToken(CURLY_LBRACE, to);
+ queueSelectOrSequenceConstructor(ReportContext::XTSE0910,
+ false, to);
+ queueToken(CURLY_RBRACE, to);
+ break;
+ }
+ case PerformSort:
+ {
+ /* For:
+ * <xsl:perform-sort select="$in">
+ * <xsl:sort select="@key"/>
+ * </xsl:perform-sort>
+ *
+ * we generate:
+ *
+ * $in map sort order by @key
+ * return .
+ * end_sort
+ */
+
+ /* In XQuery, the sort keys appear after the expression
+ * supplying the initial sequence, while in
+ * xsl:perform-sort, if a sequence constructor is used,
+ * they appear in the opposite order. Hence, we need to
+ * reorder it. */
+
+ /* We store the attributes of xsl:perform-sort, before
+ * queueSorting() advances the reader. */
+ const QXmlStreamAttributes atts(m_currentAttributes);
+
+ TokenSource::Queue sorts;
+ queueSorting(true, &sorts);
+ queueSelectOrSequenceConstructor(ReportContext::XTSE1040,
+ true,
+ to,
+ &atts);
+ /* queueSelectOrSequenceConstructor() positions us on EndElement. */
+ effectiveInitialAdvance = false;
+ queueToken(MAP, to);
+ queueToken(SORT, to);
+ *to += sorts;
+ queueToken(RETURN, to);
+ queueToken(DOT, to);
+ queueToken(END_SORT, to);
+
+ break;
+ }
+ case Message:
+ {
+ // TODO
+ queueEmptySequence(to);
+ skipSubTree();
+ break;
+ }
+ case ApplyTemplates:
+ {
+ if(hasAttribute(QLatin1String("select")))
+ queueExpression(readAttribute(QLatin1String("select")), to);
+ else
+ {
+ queueToken(CHILD, to);
+ queueToken(COLONCOLON, to);
+ queueToken(NODE, to);
+ queueToken(LPAREN, to);
+ queueToken(RPAREN, to);
+ }
+
+ bool hasMode = hasAttribute(QLatin1String("mode"));
+ QString mode;
+
+ if(hasMode)
+ mode = readAttribute(QLatin1String("mode")).trimmed();
+
+ queueToken(FOR_APPLY_TEMPLATE, to);
+
+ TokenSource::Queue sorts;
+ queueSorting(false, &sorts, true);
+
+ if(!sorts.isEmpty())
+ {
+ queueToken(SORT, to);
+ *to += sorts;
+ queueToken(RETURN, to);
+ }
+
+ queueToken(APPLY_TEMPLATE, to);
+
+ if(hasMode)
+ {
+ queueToken(MODE, to);
+ queueToken(Token(mode.startsWith(QLatin1Char('#')) ? NCNAME : QNAME, mode), to);
+ }
+
+ queueToken(LPAREN, to);
+ queueWithParams(ApplyTemplates, to, false);
+ queueToken(RPAREN, to);
+
+ if(!sorts.isEmpty())
+ queueToken(END_SORT, to);
+
+ break;
+ }
+ default:
+ unexpectedContent();
+ }
+ continue;
+ }
+ else
+ {
+ handleXSLTVersion(&m_tokenSource, &onExitTokens, true);
+ handleStandardAttributes(false);
+ handleValidationAttributes(false);
+
+ /* We're generating an element constructor. */
+ queueNamespaceDeclarations(to, &onExitTokens); // TODO same in the isXSLT() branch
+ queueToken(ELEMENT, to);
+ queueToken(INTERNAL, to);
+ queueToken(Token(QNAME, qualifiedName().toString()), to);
+ queueToken(CURLY_LBRACE, to);
+ const int len = m_currentAttributes.count();
+
+ for(int i = 0; i < len; ++i)
+ {
+ const QXmlStreamAttribute &at = m_currentAttributes.at(i);
+
+ /* We don't want to generate constructors for XSL-T attributes. */
+ if(at.namespaceUri() == CommonNamespaces::XSLT)
+ continue;
+
+ queueToken(ATTRIBUTE, to);
+ queueToken(INTERNAL, to);
+
+ queueToken(Token(at.prefix().isEmpty() ? NCNAME : QNAME, at.qualifiedName().toString()), to);
+ queueToken(CURLY_LBRACE, to);
+ queueAVT(at.value().toString(), to);
+ queueToken(CURLY_RBRACE, to);
+ queueToken(COMMA, to);
+ }
+
+ pushState(InsideSequenceConstructor);
+ insideSequenceConstructor(to);
+ Q_ASSERT(tokenType() == QXmlStreamReader::EndElement || hasError());
+ continue;
+ }
+
+ unexpectedContent();
+ break;
+ }
+ case QXmlStreamReader::EndElement:
+ {
+ queueTextConstructor(characters, hasWrittenExpression, to);
+ leaveState();
+
+ if(!hasWrittenExpression && queueEmptyOnEmpty)
+ queueEmptySequence(to);
+
+ queueOnExit(onExitTokens, to);
+
+ if(isXSLT())
+ {
+ Q_ASSERT(!isElement(Sequence));
+
+ switch(currentElementName())
+ {
+ /* Fallthrough all these. */
+ case When:
+ case Choose:
+ case ForEach:
+ case Otherwise:
+ case PerformSort:
+ case Message:
+ case ResultDocument:
+ case Copy:
+ case CallTemplate:
+ case Text:
+ case ValueOf:
+ {
+ hasWrittenExpression = true;
+ break;
+ }
+ case If:
+ {
+ queueToken(RPAREN, to);
+ queueToken(ELSE, to);
+ queueEmptySequence(to);
+ break;
+ }
+ case Function:
+ {
+ queueToken(CURLY_RBRACE, to);
+ queueToken(SEMI_COLON, to);
+ break;
+ }
+ case Template:
+ {
+ endStorageOfCurrent(&m_tokenSource);
+ /* TODO, fallthrough to Function. */
+ queueToken(CURLY_RBRACE, to);
+ queueToken(SEMI_COLON, to);
+ break;
+ }
+ default:
+ ;
+ }
+ }
+ else
+ {
+ /* We're closing a direct element constructor. */
+ hasWrittenExpression = true;
+ queueToken(CURLY_RBRACE, to);
+ }
+
+ return hasWrittenExpression;
+ }
+ case QXmlStreamReader::ProcessingInstruction:
+ /* Fallthrough. */
+ case QXmlStreamReader::Comment:
+ /* We do nothing, we just ignore them. */
+ continue;
+ case QXmlStreamReader::Characters:
+ {
+ if(whitespaceToSkip())
+ continue;
+ else
+ {
+ characters += text().toString();
+ continue;
+ }
+ }
+ default:
+ ;
+ }
+ }
+
+ leaveState();
+ return hasWrittenExpression;
+}
+
+bool XSLTTokenizer::isStylesheetElement() const
+{
+ Q_ASSERT(isXSLT());
+ Q_ASSERT(tokenType() == QXmlStreamReader::StartElement ||
+ tokenType() == QXmlStreamReader::EndElement);
+
+ const NodeName name = currentElementName();
+ return name == Stylesheet || name == Transform;
+}
+
+void XSLTTokenizer::skipBodyOfParam(const ReportContext::ErrorCode code)
+{
+ Q_ASSERT(isXSLT());
+ Q_ASSERT(tokenType() == QXmlStreamReader::StartElement);
+ const NodeName name(currentElementName());
+
+ if(skipSubTree())
+ {
+ error(QtXmlPatterns::tr("Element %1 cannot have a sequence constructor.")
+ .arg(formatKeyword(toString(name))),
+ code);
+ }
+}
+
+void XSLTTokenizer::queueWithParams(const XSLTTokenLookup::NodeName parentName,
+ TokenSource::Queue *const to,
+ const bool initialAdvance)
+{
+ Q_ASSERT(parentName == ApplyTemplates || parentName == CallTemplate);
+
+ bool effectiveInitialAdvance = initialAdvance;
+ bool hasQueuedParam = false;
+
+ while(!atEnd())
+ {
+ if(effectiveInitialAdvance)
+ readNext();
+ else
+ effectiveInitialAdvance = true;
+
+ switch(tokenType())
+ {
+ case QXmlStreamReader::StartElement:
+ {
+ if(hasQueuedParam)
+ queueToken(COMMA, to);
+
+ if(isXSLT() && isElement(WithParam))
+ {
+ if(hasAttribute(QLatin1String("tunnel")) && attributeYesNo(QLatin1String("tunnel")))
+ queueToken(TUNNEL, to);
+
+ queueVariableDeclaration(WithParamVariable, to);
+ hasQueuedParam = true;
+ continue;
+ }
+ else
+ unexpectedContent();
+ }
+ case QXmlStreamReader::EndElement:
+ {
+ if(isElement(parentName))
+ return;
+ else
+ continue;
+ }
+ case QXmlStreamReader::ProcessingInstruction:
+ /* Fallthrough. */
+ case QXmlStreamReader::Comment:
+ continue;
+ case QXmlStreamReader::Characters:
+ if(whitespaceToSkip())
+ continue;
+ else
+ return;
+ default:
+ unexpectedContent();
+ }
+ }
+ unexpectedContent();
+}
+
+void XSLTTokenizer::queueParams(const XSLTTokenLookup::NodeName parentName,
+ TokenSource::Queue *const to)
+{
+ bool hasQueuedParam = false;
+
+ Q_ASSERT(tokenType() == QXmlStreamReader::StartElement);
+
+ while(!atEnd())
+ {
+ switch(readNext())
+ {
+ case QXmlStreamReader::StartElement:
+ {
+ if(isXSLT() && isElement(Param))
+ {
+ if(hasQueuedParam)
+ queueToken(COMMA, to);
+
+ validateElement();
+
+ if(parentName == Function && m_currentAttributes.hasAttribute(QLatin1String("select")))
+ {
+ error(QtXmlPatterns::tr("The attribute %1 cannot appear on %2, when it is a child of %3.")
+ .arg(formatKeyword(QLatin1String("select")),
+ formatKeyword(QLatin1String("param")),
+ formatKeyword(QLatin1String("function"))),
+ ReportContext::XTSE0760);
+ }
+
+ if(parentName == Function && m_currentAttributes.hasAttribute(QLatin1String("required")))
+ {
+ error(QtXmlPatterns::tr("The attribute %1 cannot appear on %2, when it is a child of %3.")
+ .arg(formatKeyword(QLatin1String("required")),
+ formatKeyword(QLatin1String("param")),
+ formatKeyword(QLatin1String("function"))),
+ ReportContext::XTSE0010);
+ }
+
+ const bool hasTunnel = m_currentAttributes.hasAttribute(QLatin1String("tunnel"));
+ const bool isTunnel = hasTunnel ? attributeYesNo(QLatin1String("tunnel")) : false;
+
+ if(isTunnel)
+ {
+ if(parentName == Function)
+ {
+ /* See W3C public report 5650: http://www.w3.org/Bugs/Public/show_bug.cgi?id=5650 */
+ error(QtXmlPatterns::tr("A parameter in a function cannot be declared to be a tunnel."),
+ ReportContext::XTSE0010);
+ }
+ else
+ queueToken(TUNNEL, to);
+ }
+
+ hasQueuedParam = true;
+ queueVariableDeclaration(parentName == Function ? FunctionParameter : TemplateParameter, to);
+ continue;
+ }
+ else
+ return;
+ }
+ case QXmlStreamReader::Characters:
+ {
+ if(whitespaceToSkip())
+ continue;
+ /* Fallthrough. */
+ }
+ case QXmlStreamReader::EndElement:
+ return;
+ default:
+ ;
+ }
+ }
+}
+
+bool XSLTTokenizer::skipSubTree(const bool exitOnContent)
+{
+ bool hasContent = false;
+ int depth = 0;
+
+ while(!atEnd())
+ {
+ switch(readNext())
+ {
+ case QXmlStreamReader::Characters:
+ {
+ if(whitespaceToSkip())
+ continue;
+ else
+ {
+ hasContent = true;
+ if(exitOnContent)
+ return true;
+
+ break;
+ }
+ }
+ case QXmlStreamReader::StartElement:
+ {
+ hasContent = true;
+ if(exitOnContent)
+ return true;
+
+ ++depth;
+ break;
+ }
+ case QXmlStreamReader::EndElement:
+ {
+ --depth;
+ break;
+ }
+ default:
+ continue;
+ }
+
+ if(depth == -1)
+ return hasContent;
+ }
+
+ checkForParseError();
+ return hasContent;
+}
+
+void XSLTTokenizer::parseFallbacksOnly()
+{
+ Q_ASSERT(isXSLT());
+ Q_ASSERT(tokenType() == QXmlStreamReader::StartElement);
+
+ skipSubTree();
+ Q_ASSERT(tokenType() == QXmlStreamReader::EndElement);
+}
+
+void XSLTTokenizer::insideAttributeSet()
+{
+ while(!atEnd())
+ {
+ switch(readNext())
+ {
+ case QXmlStreamReader::StartElement:
+ {
+ if(isXSLT() && isElement(AttributeSet))
+ {
+ // TODO
+ skipSubTree();
+ }
+ else
+ unexpectedContent();
+ }
+ case QXmlStreamReader::EndElement:
+ return;
+ case QXmlStreamReader::ProcessingInstruction:
+ /* Fallthrough. */
+ case QXmlStreamReader::Comment:
+ continue;
+ case QXmlStreamReader::Characters:
+ if(whitespaceToSkip())
+ continue;
+ /* Fallthrough. */
+ default:
+ unexpectedContent();
+ }
+ }
+ unexpectedContent();
+}
+
+void XSLTTokenizer::insideStylesheetModule()
+{
+ while(!atEnd())
+ {
+ switch(readNext())
+ {
+ case QXmlStreamReader::StartElement:
+ {
+ if(isXSLT())
+ {
+ handleStandardAttributes(true);
+ handleXSLTVersion(0, 0, true, 0, false);
+ validateElement();
+
+ /* Handle the various declarations. */
+ switch(currentElementName())
+ {
+ case Template:
+ insideTemplate();
+ break;
+ case Function:
+ insideFunction();
+ break;
+ case Variable:
+ queueVariableDeclaration(VariableDeclaration, &m_tokenSource);
+ break;
+ case Param:
+ queueVariableDeclaration(GlobalParameter, &m_tokenSource);
+ break;
+ case ImportSchema:
+ {
+ error(QtXmlPatterns::tr("This processor is not Schema-aware and "
+ "therefore %1 cannot be used.").arg(formatKeyword(toString(ImportSchema))),
+ ReportContext::XTSE1660);
+ break;
+ }
+ case Output:
+ {
+ // TODO
+ skipSubTree();
+ break;
+ }
+ case StripSpace:
+ /* Fallthrough. */
+ case PreserveSpace:
+ {
+ // TODO @elements
+ skipSubTree(true);
+ readNext();
+
+ if(!isEndElement())
+ unexpectedContent();
+ break;
+ }
+ case Include:
+ {
+ // TODO
+ if(skipSubTree(true))
+ unexpectedContent();
+ break;
+ }
+ case Import:
+ {
+ // TODO
+ if(skipSubTree(true))
+ unexpectedContent();
+ break;
+ }
+ case Key:
+ {
+ // TODO
+ skipSubTree();
+ break;
+ }
+ case AttributeSet:
+ insideAttributeSet();
+ break;
+ default:
+ if(m_processingMode.top() != ForwardCompatible)
+ unexpectedContent();
+ }
+ }
+ else
+ {
+ /* We have a user-defined data element. See section 3.6.2. */
+
+ if(namespaceUri().isEmpty())
+ {
+ error(QtXmlPatterns::tr("Top level stylesheet elements must be "
+ "in a non-null namespace, which %1 isn't.").arg(formatKeyword(name())),
+ ReportContext::XTSE0130);
+ }
+ else
+ skipSubTree();
+ }
+ break;
+ }
+ case QXmlStreamReader::Characters:
+ {
+ /* Regardless of xml:space, we skip whitespace, see step 4 in
+ * 4.2 Stripping Whitespace from the Stylesheet. */
+ if(isWhitespace())
+ continue;
+
+ unexpectedContent(ReportContext::XTSE0120);
+ break;
+ }
+ case QXmlStreamReader::EndElement:
+ {
+ if(isXSLT())
+ leaveState();
+
+ break;
+ }
+ default:
+ ;
+ }
+ }
+ checkForParseError();
+}
+
+bool XSLTTokenizer::readToggleAttribute(const QString &localName,
+ const QString &isTrue,
+ const QString &isFalse,
+ const QXmlStreamAttributes *const attsP) const
+{
+ const QXmlStreamAttributes atts(attsP ? *attsP : m_currentAttributes);
+ Q_ASSERT(atts.hasAttribute(localName));
+ const QString value(atts.value(localName).toString());
+
+ if(value == isTrue)
+ return true;
+ else if(value == isFalse)
+ return false;
+ else
+ {
+ error(QtXmlPatterns::tr("The value for attribute %1 on element %2 must either "
+ "be %3 or %4, not %5.").arg(formatKeyword(localName),
+ formatKeyword(name()),
+ formatData(isTrue),
+ formatData(isFalse),
+ formatData(value)),
+ ReportContext::XTSE0020);
+ /* Silences a compiler warning. */
+ return false;
+ }
+}
+
+int XSLTTokenizer::readAlternativeAttribute(const QHash<QString, int> &alternatives,
+ const QXmlStreamAttribute &attr) const
+{
+ const QString value(attr.value().toString().trimmed());
+
+ if(alternatives.contains(value))
+ return alternatives[value];
+
+ error(QtXmlPatterns::tr("Attribute %1 cannot have the value %2.")
+ .arg(formatKeyword(attr.name().toString()),
+ formatData(attr.value().toString())),
+ ReportContext::XTSE0020);
+ return 0; /* Silence compiler warning. */
+}
+
+bool XSLTTokenizer::attributeYesNo(const QString &localName) const
+{
+ return readToggleAttribute(localName, QLatin1String("yes"), QLatin1String("no"));
+}
+
+void XSLTTokenizer::queueSorting(const bool oneSortRequired,
+ TokenSource::Queue *const to,
+ const bool speciallyTreatWhitespace)
+{
+ Q_ASSERT(tokenType() == QXmlStreamReader::StartElement);
+
+ const NodeName elementName(currentElementName());
+ bool hasQueuedOneSort = false;
+
+ while(!atEnd())
+ {
+ switch(readNext())
+ {
+ case QXmlStreamReader::EndElement:
+ {
+ /* Let's say we have no sequence constructor, but only
+ * ignorable space. In that case we will actually loop
+ * infinitely if we don't have this check. */
+ if(isXSLT())
+ {
+ switch(currentElementName())
+ {
+ case PerformSort:
+ /* Fallthrough. */
+ case ForEach:
+ /* Fallthrough. */
+ case ApplyTemplates:
+ return;
+ default:
+ ;
+ }
+ }
+ continue;
+ }
+ case QXmlStreamReader::StartElement:
+ {
+ if(isXSLT() && isElement(Sort))
+ {
+ if(hasQueuedOneSort)
+ queueToken(COMMA, to);
+
+ /* sorts are by default stable. */
+ if(hasAttribute(QLatin1String("stable")))
+ {
+ if(hasQueuedOneSort)
+ {
+ error(QtXmlPatterns::tr("The attribute %1 can only appear on "
+ "the first %2 element.").arg(formatKeyword(QLatin1String("stable")),
+ formatKeyword(QLatin1String("sort"))),
+ ReportContext::XTSE0020);
+ }
+
+ if(attributeYesNo(QLatin1String("stable")))
+ queueToken(STABLE, to);
+ }
+
+ if(!hasQueuedOneSort)
+ {
+ queueToken(ORDER, to);
+ queueToken(BY, to);
+ }
+
+ /* We store a copy such that we can use them after
+ * queueSelectOrSequenceConstructor() advances the reader. */
+ const QXmlStreamAttributes atts(m_currentAttributes);
+
+ const int before = to->count();
+
+ // TODO This doesn't work as is. @data-type can be an AVT.
+ if(atts.hasAttribute(QLatin1String("data-type")))
+ {
+ if(readToggleAttribute(QLatin1String("data-type"),
+ QLatin1String("text"),
+ QLatin1String("number"),
+ &atts))
+ queueToken(Token(NCNAME, QLatin1String("string")), to);
+ else
+ queueToken(Token(NCNAME, QLatin1String("number")), to);
+ }
+ /* We queue these parantheses for the sake of the function
+ * call for attribute data-type. In the case we don't have
+ * such an attribute, the parantheses are just redundant. */
+ queueToken(LPAREN, to);
+ queueSelectOrSequenceConstructor(ReportContext::XTSE1015,
+ true,
+ to,
+ 0,
+ false);
+ /* If neither a select attribute or a sequence constructor is supplied,
+ * we're supposed to use the context item. */
+ queueToken(RPAREN, to);
+ if(before == to->count())
+ queueToken(DOT, to);
+
+ // TODO case-order
+ // TODO lang
+
+ // TODO This doesn't work as is. @order can be an AVT, and so can case-order and lang.
+ if(atts.hasAttribute(QLatin1String("order")) && readToggleAttribute(QLatin1String("order"),
+ QLatin1String("descending"),
+ QLatin1String("ascending"),
+ &atts))
+ {
+ queueToken(DESCENDING, to);
+ }
+ else
+ {
+ /* This is the default. */
+ queueToken(ASCENDING, to);
+ }
+
+ if(atts.hasAttribute(QLatin1String("collation")))
+ {
+ queueToken(INTERNAL, to);
+ queueToken(COLLATION, to);
+ queueAVT(atts.value(QLatin1String("collation")).toString(), to);
+ }
+
+ hasQueuedOneSort = true;
+ continue;
+ }
+ else
+ break;
+ }
+ case QXmlStreamReader::Characters:
+ {
+ if(speciallyTreatWhitespace && isWhitespace())
+ continue;
+
+ if(QXmlStreamReader::Characters && whitespaceToSkip())
+ continue;
+
+ /* We have an instruction which is a text node, we're done. */
+ break;
+ }
+ case QXmlStreamReader::ProcessingInstruction:
+ /* Fallthrough. */
+ case QXmlStreamReader::Comment:
+ continue;
+ default:
+ unexpectedContent();
+
+ };
+ if(oneSortRequired && !hasQueuedOneSort)
+ {
+ error(QtXmlPatterns::tr("At least one %1 element must appear as child of %2.")
+ .arg(formatKeyword(QLatin1String("sort")), formatKeyword(toString(elementName))),
+ ReportContext::XTSE0010);
+ }
+ else
+ return;
+ }
+ checkForParseError();
+}
+
+void XSLTTokenizer::insideFunction()
+{
+ queueToken(DECLARE, &m_tokenSource);
+ queueToken(FUNCTION, &m_tokenSource);
+ queueToken(INTERNAL, &m_tokenSource);
+ queueToken(Token(QNAME, readAttribute(QLatin1String("name"))), &m_tokenSource);
+ queueToken(LPAREN, &m_tokenSource);
+ const QString expectedType(hasAttribute(QLatin1String("as")) ? readAttribute(QLatin1String("as")): QString());
+
+ if(hasAttribute(QLatin1String("override")))
+ {
+ /* We currently have no external functions, so we don't pass it on currently. */
+ attributeYesNo(QLatin1String("override"));
+ }
+
+ queueParams(Function, &m_tokenSource);
+
+ queueToken(RPAREN, &m_tokenSource);
+
+ if(!expectedType.isNull())
+ {
+ queueToken(AS, &m_tokenSource);
+ queueSequenceType(expectedType);
+ }
+
+ QStack<Token> onExitTokens;
+ handleXMLBase(&m_tokenSource, &onExitTokens, true, &m_currentAttributes);
+ handleXSLTVersion(&m_tokenSource, &onExitTokens, true);
+ queueToken(CURLY_LBRACE, &m_tokenSource);
+
+ pushState(InsideSequenceConstructor);
+ insideSequenceConstructor(&m_tokenSource, onExitTokens, false);
+ /* We don't queue CURLY_RBRACE, because it's done in
+ * insideSequenceConstructor(). */
+}
+
+YYLTYPE XSLTTokenizer::currentSourceLocator() const
+{
+ YYLTYPE retval;
+ retval.first_line = lineNumber();
+ retval.first_column = columnNumber();
+ return retval;
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/xmlpatterns/parser/qxslttokenizer_p.h b/src/xmlpatterns/parser/qxslttokenizer_p.h
new file mode 100644
index 0000000000..9fb43c7b60
--- /dev/null
+++ b/src/xmlpatterns/parser/qxslttokenizer_p.h
@@ -0,0 +1,481 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@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.
+
+#ifndef Patternist_XSLTTokenizer_H
+#define Patternist_XSLTTokenizer_H
+
+#include <QQueue>
+#include <QStack>
+#include <QUrl>
+
+#include "qmaintainingreader_p.h"
+#include "qreportcontext_p.h"
+#include "qtokenizer_p.h"
+#include "qxslttokenlookup_p.h"
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+namespace QPatternist
+{
+ /**
+ * @short A TokenSource which contains one Tokenizer::Token.
+ *
+ * One possible way to optimize this is to let SingleTokenContainer
+ * actually contain a list of tokens, such that XSLTTokenizer::queueToken()
+ * could append to that, instead of instansiating a SingleTokenContainer
+ * all the time.
+ *
+ * @author Frans Englich <fenglich@trolltech.com>
+ */
+ class SingleTokenContainer : public TokenSource
+ {
+ public:
+ inline SingleTokenContainer(const Tokenizer::Token &token,
+ const YYLTYPE &location);
+
+ virtual Tokenizer::Token nextToken(YYLTYPE *const sourceLocator);
+ private:
+ const Tokenizer::Token m_token;
+ const YYLTYPE m_location;
+ bool m_hasDelivered;
+ };
+
+ SingleTokenContainer::SingleTokenContainer(const Tokenizer::Token &token,
+ const YYLTYPE &location) : m_token(token)
+ , m_location(location)
+ , m_hasDelivered(false)
+ {
+ }
+
+ /**
+ * @short Tokenizes XSL-T 2.0 documents.
+ *
+ * XSLTTokenizer takes in its constructor a pointer to a QIODevice which is
+ * supposed to contain an XSL-T document. XSLTTokenizer then rewrites that
+ * document into XQuery tokens delivered via nextToken(), which the regular
+ * XQuery parser then reads. Hence, the XSL-T language is rewritten into
+ * XQuery code, slightly extended to handle the featuress specific to
+ * XSL-T.
+ *
+ * @author Frans Englich <fenglich@trolltech.com>
+ */
+ class XSLTTokenizer : public Tokenizer
+ , private MaintainingReader<XSLTTokenLookup>
+ {
+ public:
+ /**
+ * XSLTTokenizer do not own @p queryDevice.
+ */
+ XSLTTokenizer(QIODevice *const queryDevice,
+ const QUrl &location,
+ const ReportContext::Ptr &context,
+ const NamePool::Ptr &np);
+
+ virtual Token nextToken(YYLTYPE *const sourceLocator);
+
+ /**
+ * For XSLT we don't need this mechanism, so we do nothing.
+ */
+ virtual int commenceScanOnly();
+
+ /**
+ * For XSLT we don't need this mechanism, so we do nothing.
+ */
+ virtual void resumeTokenizationFrom(const int position);
+
+ virtual void setParserContext(const ParserContext::Ptr &parseInfo);
+
+ virtual QUrl documentURI() const
+ {
+ return queryURI();
+ }
+
+ protected:
+ virtual bool isAnyAttributeAllowed() const;
+
+ private:
+ inline void validateElement() const;
+
+ YYLTYPE currentSourceLocator() const;
+
+ enum State
+ {
+ OutsideDocumentElement,
+ InsideStylesheetModule,
+ InsideSequenceConstructor
+ };
+
+ enum VariableType
+ {
+ FunctionParameter,
+ GlobalParameter,
+ TemplateParameter,
+ VariableDeclaration,
+ VariableInstruction,
+ WithParamVariable
+ };
+
+ void queueNamespaceDeclarations(TokenSource::Queue *const ts,
+ QStack<Token> *const target,
+ const bool isDeclaration = false);
+
+ inline void queueToken(const Token &token,
+ TokenSource::Queue *const ts);
+ void queueEmptySequence(TokenSource::Queue *const to);
+ void queueSequenceType(const QString &expr);
+ /**
+ * If @p emptynessAllowed is @c true, the @c select attribute may
+ * be empty while there also is no sequence constructor.
+ */
+ void queueSimpleContentConstructor(const ReportContext::ErrorCode code,
+ const bool emptynessAllowed,
+ TokenSource::Queue *const to,
+ const bool selectOnlyFirst = false);
+ /**
+ * Tokenizes and queues @p expr as if it was an attribute value
+ * template.
+ */
+ void queueAVT(const QString &expr,
+ TokenSource::Queue *const to);
+
+ void hasWrittenExpression(bool &beacon);
+ void commencingExpression(bool &hasWrittenExpression,
+ TokenSource::Queue *const to);
+
+ void outsideDocumentElement();
+ void insideChoose(TokenSource::Queue *const to);
+ void insideFunction();
+
+ bool attributeYesNo(const QString &localName) const;
+
+ /**
+ * Scans/skips @c xsl:fallback elements only. This is the case of the
+ * children of @c xsl:sequence, for instance.
+ */
+ void parseFallbacksOnly();
+
+ /**
+ * Returns true if the current element is either @c stylesheet
+ * or the synonym @c transform.
+ *
+ * This function assumes that m_reader is positioned at an element
+ * and that the namespace is XSL-T.
+ */
+ bool isStylesheetElement() const;
+
+ /**
+ * Returns true if the current element name is @p name.
+ *
+ * It is assumed that the namespace is XSL-T and that the current
+ * state in m_reader is either QXmlStreamReader::StartElement or
+ * QXmlStreamReader::EndElement.
+ */
+ bool isElement(const NodeName &name) const;
+
+ /**
+ * Queues a text constructor for @p chars, if @p chars is
+ * not empty.
+ */
+ void queueTextConstructor(QString &chars,
+ bool &hasWrittenExpression,
+ TokenSource::Queue *const to);
+
+ /**
+ *
+ * @see <a href="http://www.w3.org/TR/xslt20/#stylesheet-structure">XSL
+ * Transformations (XSLT) Version 2, 3.6 Stylesheet Element</a>
+ */
+ void insideStylesheetModule();
+ void insideTemplate();
+
+ /**
+ * Takes @p expr for an XPath expression, and pushes the necessary
+ * things for having it delivered as a stream of token, appropriate
+ * for Effective Boolean Value parsing.
+ */
+ void queueExpression(const QString &expr,
+ TokenSource::Queue *const to,
+ const bool wrapWithParantheses = true);
+
+ void skipBodyOfParam(const ReportContext::ErrorCode code);
+
+ void queueParams(const NodeName parentName,
+ TokenSource::Queue *const to);
+
+ /**
+ * Used for @c xsl:apply-templates and @c xsl:call-templates.
+ */
+ void queueWithParams(const NodeName parentName,
+ TokenSource::Queue *const to,
+ const bool initialAdvance = true);
+
+ /**
+ * Queues an @c xsl:variable declaration. If @p isInstruction is @c
+ * true, it is assumed to be a an instruction, otherwise a top-level
+ * declaration element.
+ */
+ void queueVariableDeclaration(const VariableType variableType,
+ TokenSource::Queue *const to);
+
+ /**
+ * Skips the current sub-tree.
+ *
+ * If text nodes that aren't strippable whitespace, or elements are
+ * encountered, @c true is returned, otherwise @c false.
+ *
+ * If @p exitOnContent is @c true, this function exits immediately
+ * if content is encountered for which it would return @c false.
+ */
+ bool skipSubTree(const bool exitOnContent = false);
+
+ /**
+ * Queues the necessary tokens for the expression that is either
+ * supplied using a @c select attribute or a sequence constructor,
+ * while doing the necessary error handling for ensuring they are
+ * mutually exclusive.
+ *
+ * It is assumed that the current state of m_reader is
+ * QXmlStreamReader::StartElement, or that the attributes for the
+ * element is supplied through @p atts. This function advances m_reader
+ * up until the corresponding QXmlStreamReader::EndElement.
+ *
+ * If @p emptynessAllowed is @c false, the element must either have a
+ * sequence constructor or a @c select attribute. If @c true, both may
+ * be absent.
+ *
+ * Returns @c true if the queued expression was supplied through the
+ * @c select attribute otherwise @c false.
+ */
+ bool queueSelectOrSequenceConstructor(const ReportContext::ErrorCode code,
+ const bool emptynessAllowed,
+ TokenSource::Queue *const to,
+ const QXmlStreamAttributes *const atts = 0,
+ const bool queueEmptyOnEmpty = true);
+
+ /**
+ * If @p initialAdvance is @c true, insideSequenceConstructor() will
+ * advance m_reader, otherwise it won't. Not doing so is useful
+ * when the caller is already inside a sequence constructor.
+ *
+ * Returns @c true if a sequence constructor was found and queued.
+ * Returns @c false if none was found, and the empty sequence was
+ * synthesized.
+ */
+ bool insideSequenceConstructor(TokenSource::Queue *const to,
+ const bool initialAdvance = true,
+ const bool queueEmptyOnEmpty = true);
+
+ bool insideSequenceConstructor(TokenSource::Queue *const to,
+ QStack<Token> &queueOnExit,
+ const bool initialAdvance = true,
+ const bool queueEmptyOnEmpty = true);
+
+ void insideAttributeSet();
+ void pushState(const State nextState);
+ void leaveState();
+
+ /**
+ * @short Handles @c xml:space and standard attributes.
+ *
+ * If @p isXSLTElement is @c true, the current element is an XSL-T
+ * element, as opposed to a Literal Result Element.
+ *
+ * handleStandardAttributes() must be called before validateElement(),
+ * because the former determines the version in use, and
+ * validateElement() depends on that.
+ *
+ * The core of this function can't be run many times because it pushes
+ * whitespace handling onto m_stripWhitespace.
+ * m_hasHandledStandardAttributes protects helping against this.
+ *
+ * @see validateElement()
+ * @see <a href="http://www.w3.org/TR/xslt20/#standard-attributes">XSL
+ * Transformations (XSLT) Version 2.0, 3.5 Standard Attributes</a>
+ */
+ void handleStandardAttributes(const bool isXSLTElement);
+
+ /**
+ * @short Sends the tokens in @p source to @p destination.
+ */
+ inline void queueOnExit(QStack<Token> &source,
+ TokenSource::Queue *const destination);
+
+ /**
+ * Handles the @c type and @c validation attribute on instructions and
+ * literal result elements.
+ *
+ * @p isLRE should be true if the current element is not in the XSL-T
+ * namespace, that is if it's a Literal Result Element.
+ *
+ * @see <a href="http://www.w3.org/TR/xslt20/#validation">XSL
+ * Transformations (XSLT) Version 2.0, 19.2 Validation</a>
+ */
+ void handleValidationAttributes(const bool isLRE) const;
+
+ void unexpectedContent(const ReportContext::ErrorCode code = ReportContext::XTSE0010) const;
+
+ void checkForParseError() const;
+
+ inline void startStorageOfCurrent(TokenSource::Queue *const to);
+ inline void endStorageOfCurrent(TokenSource::Queue *const to);
+
+ /**
+ * Checks that @p attribute has a value in accordance with what
+ * is allowed and supported.
+ */
+ void handleXSLTVersion(TokenSource::Queue *const to,
+ QStack<Token> *const queueOnExit,
+ const bool isXSLTElement,
+ const QXmlStreamAttributes *atts = 0,
+ const bool generateCode = true,
+ const bool setGlobalVersion = false);
+
+ /**
+ * @short Generates code for reflecting @c xml:base attributes.
+ */
+ void handleXMLBase(TokenSource::Queue *const to,
+ QStack<Token> *const queueOnExit,
+ const bool isInstruction = true,
+ const QXmlStreamAttributes *atts = 0);
+
+ /**
+ * Concatenates text nodes, ignores comments and processing
+ * instructions, and raises errors on everything else.
+ *
+ * Hence, similar to QXmlStreamReader::readElementText(), except
+ * for error handling.
+ */
+ QString readElementText();
+
+ /**
+ * Tokenizes and validate xsl:sort statements, if any, until
+ * other content is encountered. The produced tokens are returned
+ * in a list.
+ *
+ * If @p oneSortRequired, at least one @c sort element must appear,
+ * otherwise an error is raised.
+ *
+ * If @p speciallyTreatWhitespace whitespace will be treated as if it
+ * was one of the elements mentioned in step 4 in section 4.2 Stripping
+ * Whitespace from the Stylesheet.
+ */
+ void queueSorting(const bool oneSortRequired,
+ TokenSource::Queue *const to,
+ const bool speciallyTreatWhitespace = false);
+
+ static ElementDescription<XSLTTokenLookup>::Hash createElementDescriptions();
+ static QHash<QString, int> createValidationAlternatives();
+ static QSet<NodeName> createStandardAttributes();
+
+ /**
+ * Reads the attribute by name @p attributeName, and returns @c true if
+ * its value is @p isTrue, @c false if it is @p isFalse, and raise an
+ * error otherwise.
+ */
+ bool readToggleAttribute(const QString &attributeName,
+ const QString &isTrue,
+ const QString &isFalse,
+ const QXmlStreamAttributes *const atts = 0) const;
+
+ int readAlternativeAttribute(const QHash<QString, int> &alternatives,
+ const QXmlStreamAttribute &attr) const;
+
+ /**
+ * Returns @c true if the current text node can be skipped without
+ * it leading to a validation error, with respect to whitespace.
+ */
+ inline bool whitespaceToSkip() const;
+
+ const QUrl m_location;
+ const NamePool::Ptr m_namePool;
+ QStack<State> m_state;
+ TokenSource::Queue m_tokenSource;
+
+ enum ProcessMode
+ {
+ BackwardsCompatible,
+ ForwardCompatible,
+ NormalProcessing
+ };
+
+ /**
+ * Whether we're processing in Forwards-Compatible or
+ * Backwards-Compatible mode.
+ *
+ * This is set by handleStandardAttributes().
+ *
+ * ParserContext have similar information in
+ * ParserContext::isBackwardsCompat. A big distinction is that both the
+ * tokenizer and the parser buffer tokens and have positions disjoint
+ * to each other. E.g, the state the parser has when reducing into
+ * non-terminals, is different from the tokenizer's.
+ */
+ QStack<ProcessMode> m_processingMode;
+
+ /**
+ * Returns @c true if the current state in m_reader is in the XSLT
+ * namespace. It is assumed that the current state is an element.
+ */
+ inline bool isXSLT() const;
+
+ const QHash<QString, int> m_validationAlternatives;
+
+ ParserContext::Ptr m_parseInfo;
+ };
+}
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/xmlpatterns/parser/qxslttokenlookup.cpp b/src/xmlpatterns/parser/qxslttokenlookup.cpp
new file mode 100644
index 0000000000..9184de7b5f
--- /dev/null
+++ b/src/xmlpatterns/parser/qxslttokenlookup.cpp
@@ -0,0 +1,3006 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/* NOTE: This file is AUTO GENERATED by qtokenautomaton2cpp.xsl. */
+
+#include "qxslttokenlookup_p.h"
+
+QT_BEGIN_NAMESPACE
+
+using namespace QPatternist;
+
+XSLTTokenLookup::NodeName XSLTTokenLookup::classifier2(const QChar *data)
+
+ {
+ if (data[0] == 97)
+
+
+ {
+
+ if(data[1] == 115)
+
+
+ return As;
+
+ }
+
+ else if (data[0] == 105)
+
+
+ {
+ if (data[1] == 100)
+
+
+ {
+
+
+ return Id;
+
+ }
+
+ else if (data[1] == 102)
+
+
+ {
+
+
+ return If;
+
+ }
+
+
+ }
+
+
+
+ return NoKeyword;
+ }
+ XSLTTokenLookup::NodeName XSLTTokenLookup::classifier3(const QChar *data)
+
+ {
+ if (data[0] == 107)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 101, 121
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 2) == 0)
+
+
+ return Key;
+
+ }
+
+ else if (data[0] == 117)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 115, 101
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 2) == 0)
+
+
+ return Use;
+
+ }
+
+
+
+ return NoKeyword;
+ }
+ XSLTTokenLookup::NodeName XSLTTokenLookup::classifier4(const QChar *data)
+
+ {
+ if (data[0] == 99)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 111, 112, 121
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
+
+
+ return Copy;
+
+ }
+
+ else if (data[0] == 104)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 114, 101, 102
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
+
+
+ return Href;
+
+ }
+
+ else if (data[0] == 108)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 97, 110, 103
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
+
+
+ return Lang;
+
+ }
+
+ else if (data[0] == 109)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 111, 100, 101
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
+
+
+ return Mode;
+
+ }
+
+ else if (data[0] == 110)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 97, 109, 101
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
+
+
+ return Name;
+
+ }
+
+ else if (data[0] == 115)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 111, 114, 116
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
+
+
+ return Sort;
+
+ }
+
+ else if (data[0] == 116)
+
+
+ {
+ if (data[1] == 101)
+
+
+ {
+ if (data[2] == 115)
+
+
+ {
+
+ if(data[3] == 116)
+
+
+ return Test;
+
+ }
+
+ else if (data[2] == 120)
+
+
+ {
+
+ if(data[3] == 116)
+
+
+ return Text;
+
+ }
+
+
+ }
+
+ else if (data[1] == 121)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 112, 101
+ };
+ if(memcmp(&data[2], &string, sizeof(QChar) * 2) == 0)
+
+
+ return Type;
+
+ }
+
+
+ }
+
+ else if (data[0] == 119)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 104, 101, 110
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 3) == 0)
+
+
+ return When;
+
+ }
+
+
+
+ return NoKeyword;
+ }
+ XSLTTokenLookup::NodeName XSLTTokenLookup::classifier5(const QChar *data)
+
+ {
+ if (data[0] == 102)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 108, 97, 103, 115
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
+
+
+ return Flags;
+
+ }
+
+ else if (data[0] == 109)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 97, 116, 99, 104
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
+
+
+ return Match;
+
+ }
+
+ else if (data[0] == 111)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 114, 100, 101, 114
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
+
+
+ return Order;
+
+ }
+
+ else if (data[0] == 112)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 97, 114, 97, 109
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
+
+
+ return Param;
+
+ }
+
+ else if (data[0] == 114)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 101, 103, 101, 120
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 4) == 0)
+
+
+ return Regex;
+
+ }
+
+
+
+ return NoKeyword;
+ }
+ XSLTTokenLookup::NodeName XSLTTokenLookup::classifier6(const QChar *data)
+
+ {
+ if (data[0] == 99)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 104, 111, 111, 115, 101
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
+
+
+ return Choose;
+
+ }
+
+ else if (data[0] == 102)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 111, 114, 109, 97, 116
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
+
+
+ return Format;
+
+ }
+
+ else if (data[0] == 105)
+
+
+ {
+ if (data[1] == 109)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 112, 111, 114, 116
+ };
+ if(memcmp(&data[2], &string, sizeof(QChar) * 4) == 0)
+
+
+ return Import;
+
+ }
+
+ else if (data[1] == 110)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 100, 101, 110, 116
+ };
+ if(memcmp(&data[2], &string, sizeof(QChar) * 4) == 0)
+
+
+ return Indent;
+
+ }
+
+
+ }
+
+ else if (data[0] == 109)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 101, 116, 104, 111, 100
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
+
+
+ return Method;
+
+ }
+
+ else if (data[0] == 111)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 117, 116, 112, 117, 116
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
+
+
+ return Output;
+
+ }
+
+ else if (data[0] == 115)
+
+
+ {
+ if (data[1] == 101)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 108, 101, 99, 116
+ };
+ if(memcmp(&data[2], &string, sizeof(QChar) * 4) == 0)
+
+
+ return Select;
+
+ }
+
+ else if (data[1] == 116)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 97, 98, 108, 101
+ };
+ if(memcmp(&data[2], &string, sizeof(QChar) * 4) == 0)
+
+
+ return Stable;
+
+ }
+
+
+ }
+
+ else if (data[0] == 116)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 117, 110, 110, 101, 108
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 5) == 0)
+
+
+ return Tunnel;
+
+ }
+
+
+
+ return NoKeyword;
+ }
+ XSLTTokenLookup::NodeName XSLTTokenLookup::classifier7(const QChar *data)
+
+ {
+ if (data[0] == 99)
+
+
+ {
+ if (data[1] == 111)
+
+
+ {
+ if (data[2] == 109)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 109, 101, 110, 116
+ };
+ if(memcmp(&data[3], &string, sizeof(QChar) * 4) == 0)
+
+
+ return Comment;
+
+ }
+
+ else if (data[2] == 112)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 121, 45, 111, 102
+ };
+ if(memcmp(&data[3], &string, sizeof(QChar) * 4) == 0)
+
+
+ return CopyOf;
+
+ }
+
+
+ }
+
+
+ }
+
+ else if (data[0] == 101)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 108, 101, 109, 101, 110, 116
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0)
+
+
+ return Element;
+
+ }
+
+ else if (data[0] == 105)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 110, 99, 108, 117, 100, 101
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0)
+
+
+ return Include;
+
+ }
+
+ else if (data[0] == 109)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 101, 115, 115, 97, 103, 101
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0)
+
+
+ return Message;
+
+ }
+
+ else if (data[0] == 118)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 101, 114, 115, 105, 111, 110
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 6) == 0)
+
+
+ return Version;
+
+ }
+
+
+
+ return NoKeyword;
+ }
+ XSLTTokenLookup::NodeName XSLTTokenLookup::classifier8(const QChar *data)
+
+ {
+ if (data[0] == 100)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 111, 99, 117, 109, 101, 110, 116
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
+
+
+ return Document;
+
+ }
+
+ else if (data[0] == 101)
+
+
+ {
+ if (data[1] == 108)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 101, 109, 101, 110, 116, 115
+ };
+ if(memcmp(&data[2], &string, sizeof(QChar) * 6) == 0)
+
+
+ return Elements;
+
+ }
+
+ else if (data[1] == 110)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 99, 111, 100, 105, 110, 103
+ };
+ if(memcmp(&data[2], &string, sizeof(QChar) * 6) == 0)
+
+
+ return Encoding;
+
+ }
+
+
+ }
+
+ else if (data[0] == 102)
+
+
+ {
+ if (data[1] == 111)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 114, 45, 101, 97, 99, 104
+ };
+ if(memcmp(&data[2], &string, sizeof(QChar) * 6) == 0)
+
+
+ return ForEach;
+
+ }
+
+ else if (data[1] == 117)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 110, 99, 116, 105, 111, 110
+ };
+ if(memcmp(&data[2], &string, sizeof(QChar) * 6) == 0)
+
+
+ return Function;
+
+ }
+
+
+ }
+
+ else if (data[0] == 111)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 118, 101, 114, 114, 105, 100, 101
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
+
+
+ return Override;
+
+ }
+
+ else if (data[0] == 112)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 114, 105, 111, 114, 105, 116, 121
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
+
+
+ return Priority;
+
+ }
+
+ else if (data[0] == 114)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 101, 113, 117, 105, 114, 101, 100
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
+
+
+ return Required;
+
+ }
+
+ else if (data[0] == 115)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 101, 113, 117, 101, 110, 99, 101
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
+
+
+ return Sequence;
+
+ }
+
+ else if (data[0] == 116)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 101, 109, 112, 108, 97, 116, 101
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
+
+
+ return Template;
+
+ }
+
+ else if (data[0] == 117)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 115, 101, 45, 119, 104, 101, 110
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 7) == 0)
+
+
+ return UseWhen;
+
+ }
+
+ else if (data[0] == 118)
+
+
+ {
+ if (data[1] == 97)
+
+
+ {
+ if (data[2] == 108)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 117, 101, 45, 111, 102
+ };
+ if(memcmp(&data[3], &string, sizeof(QChar) * 5) == 0)
+
+
+ return ValueOf;
+
+ }
+
+ else if (data[2] == 114)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 105, 97, 98, 108, 101
+ };
+ if(memcmp(&data[3], &string, sizeof(QChar) * 5) == 0)
+
+
+ return Variable;
+
+ }
+
+
+ }
+
+
+ }
+
+
+
+ return NoKeyword;
+ }
+ XSLTTokenLookup::NodeName XSLTTokenLookup::classifier9(const QChar *data)
+
+ {
+ if (data[0] == 97)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 116, 116, 114, 105, 98, 117, 116, 101
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0)
+
+
+ return Attribute;
+
+ }
+
+ else if (data[0] == 99)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 111, 108, 108, 97, 116, 105, 111, 110
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0)
+
+
+ return Collation;
+
+ }
+
+ else if (data[0] == 100)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 97, 116, 97, 45, 116, 121, 112, 101
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0)
+
+
+ return DataType;
+
+ }
+
+ else if (data[0] == 110)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 97, 109, 101, 115, 112, 97, 99, 101
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0)
+
+
+ return Namespace;
+
+ }
+
+ else if (data[0] == 111)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 116, 104, 101, 114, 119, 105, 115, 101
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0)
+
+
+ return Otherwise;
+
+ }
+
+ else if (data[0] == 115)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 101, 112, 97, 114, 97, 116, 111, 114
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 8) == 0)
+
+
+ return Separator;
+
+ }
+
+ else if (data[0] == 116)
+
+
+ {
+ if (data[1] == 101)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 114, 109, 105, 110, 97, 116, 101
+ };
+ if(memcmp(&data[2], &string, sizeof(QChar) * 7) == 0)
+
+
+ return Terminate;
+
+ }
+
+ else if (data[1] == 114)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 97, 110, 115, 102, 111, 114, 109
+ };
+ if(memcmp(&data[2], &string, sizeof(QChar) * 7) == 0)
+
+
+ return Transform;
+
+ }
+
+
+ }
+
+
+
+ return NoKeyword;
+ }
+ XSLTTokenLookup::NodeName XSLTTokenLookup::classifier10(const QChar *data)
+
+ {
+ if (data[0] == 99)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 97, 115, 101, 45, 111, 114, 100, 101, 114
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 9) == 0)
+
+
+ return CaseOrder;
+
+ }
+
+ else if (data[0] == 109)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 101, 100, 105, 97, 45, 116, 121, 112, 101
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 9) == 0)
+
+
+ return MediaType;
+
+ }
+
+ else if (data[0] == 115)
+
+
+ {
+ if (data[1] == 116)
+
+
+ {
+ if (data[2] == 97)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 110, 100, 97, 108, 111, 110, 101
+ };
+ if(memcmp(&data[3], &string, sizeof(QChar) * 7) == 0)
+
+
+ return Standalone;
+
+ }
+
+ else if (data[2] == 121)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 108, 101, 115, 104, 101, 101, 116
+ };
+ if(memcmp(&data[3], &string, sizeof(QChar) * 7) == 0)
+
+
+ return Stylesheet;
+
+ }
+
+
+ }
+
+
+ }
+
+ else if (data[0] == 118)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 97, 108, 105, 100, 97, 116, 105, 111, 110
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 9) == 0)
+
+
+ return Validation;
+
+ }
+
+ else if (data[0] == 119)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 105, 116, 104, 45, 112, 97, 114, 97, 109
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 9) == 0)
+
+
+ return WithParam;
+
+ }
+
+
+
+ return NoKeyword;
+ }
+ XSLTTokenLookup::NodeName XSLTTokenLookup::classifier11(const QChar *data)
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 115, 116, 114, 105, 112, 45, 115, 112, 97, 99, 101
+ };
+ if(memcmp(&data[0], &string, sizeof(QChar) * 11) == 0)
+
+
+ return StripSpace;
+
+
+ return NoKeyword;
+ }
+ XSLTTokenLookup::NodeName XSLTTokenLookup::classifier12(const QChar *data)
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 112, 101, 114, 102, 111, 114, 109, 45, 115, 111, 114, 116
+ };
+ if(memcmp(&data[0], &string, sizeof(QChar) * 12) == 0)
+
+
+ return PerformSort;
+
+
+ return NoKeyword;
+ }
+ XSLTTokenLookup::NodeName XSLTTokenLookup::classifier13(const QChar *data)
+
+ {
+ if (data[0] == 97)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 116, 116, 114, 105, 98, 117, 116, 101, 45, 115, 101, 116
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 12) == 0)
+
+
+ return AttributeSet;
+
+ }
+
+ else if (data[0] == 99)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 97, 108, 108, 45, 116, 101, 109, 112, 108, 97, 116, 101
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 12) == 0)
+
+
+ return CallTemplate;
+
+ }
+
+ else if (data[0] == 105)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 109, 112, 111, 114, 116, 45, 115, 99, 104, 101, 109, 97
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 12) == 0)
+
+
+ return ImportSchema;
+
+ }
+
+
+
+ return NoKeyword;
+ }
+ XSLTTokenLookup::NodeName XSLTTokenLookup::classifier14(const QChar *data)
+
+ {
+ if (data[0] == 97)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 110, 97, 108, 121, 122, 101, 45, 115, 116, 114, 105, 110, 103
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 13) == 0)
+
+
+ return AnalyzeString;
+
+ }
+
+ else if (data[0] == 100)
+
+
+ {
+ if (data[1] == 111)
+
+
+ {
+ if (data[2] == 99)
+
+
+ {
+ if (data[3] == 116)
+
+
+ {
+ if (data[4] == 121)
+
+
+ {
+ if (data[5] == 112)
+
+
+ {
+ if (data[6] == 101)
+
+
+ {
+ if (data[7] == 45)
+
+
+ {
+ if (data[8] == 112)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 117, 98, 108, 105, 99
+ };
+ if(memcmp(&data[9], &string, sizeof(QChar) * 5) == 0)
+
+
+ return DoctypePublic;
+
+ }
+
+ else if (data[8] == 115)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 121, 115, 116, 101, 109
+ };
+ if(memcmp(&data[9], &string, sizeof(QChar) * 5) == 0)
+
+
+ return DoctypeSystem;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ else if (data[0] == 111)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 117, 116, 112, 117, 116, 45, 118, 101, 114, 115, 105, 111, 110
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 13) == 0)
+
+
+ return OutputVersion;
+
+ }
+
+ else if (data[0] == 112)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 114, 101, 115, 101, 114, 118, 101, 45, 115, 112, 97, 99, 101
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 13) == 0)
+
+
+ return PreserveSpace;
+
+ }
+
+
+
+ return NoKeyword;
+ }
+ XSLTTokenLookup::NodeName XSLTTokenLookup::classifier15(const QChar *data)
+
+ {
+ if (data[0] == 97)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 112, 112, 108, 121, 45, 116, 101, 109, 112, 108, 97, 116, 101, 115
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 14) == 0)
+
+
+ return ApplyTemplates;
+
+ }
+
+ else if (data[0] == 98)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 121, 116, 101, 45, 111, 114, 100, 101, 114, 45, 109, 97, 114, 107
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 14) == 0)
+
+
+ return ByteOrderMark;
+
+ }
+
+ else if (data[0] == 99)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 111, 112, 121, 45, 110, 97, 109, 101, 115, 112, 97, 99, 101, 115
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 14) == 0)
+
+
+ return CopyNamespaces;
+
+ }
+
+ else if (data[0] == 114)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 101, 115, 117, 108, 116, 45, 100, 111, 99, 117, 109, 101, 110, 116
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 14) == 0)
+
+
+ return ResultDocument;
+
+ }
+
+ else if (data[0] == 115)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 99, 104, 101, 109, 97, 45, 108, 111, 99, 97, 116, 105, 111, 110
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 14) == 0)
+
+
+ return SchemaLocation;
+
+ }
+
+
+
+ return NoKeyword;
+ }
+ XSLTTokenLookup::NodeName XSLTTokenLookup::classifier17(const QChar *data)
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 100, 101, 102, 97, 117, 108, 116, 45, 99, 111, 108, 108, 97, 116, 105, 111, 110
+ };
+ if(memcmp(&data[0], &string, sizeof(QChar) * 17) == 0)
+
+
+ return DefaultCollation;
+
+
+ return NoKeyword;
+ }
+ XSLTTokenLookup::NodeName XSLTTokenLookup::classifier18(const QChar *data)
+
+ {
+ if (data[0] == 100)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 101, 102, 97, 117, 108, 116, 45, 118, 97, 108, 105, 100, 97, 116, 105, 111, 110
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 17) == 0)
+
+
+ return DefaultValidation;
+
+ }
+
+ else if (data[0] == 105)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 110, 104, 101, 114, 105, 116, 45, 110, 97, 109, 101, 115, 112, 97, 99, 101, 115
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 17) == 0)
+
+
+ return InheritNamespaces;
+
+ }
+
+ else if (data[0] == 109)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 97, 116, 99, 104, 105, 110, 103, 45, 115, 117, 98, 115, 116, 114, 105, 110, 103
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 17) == 0)
+
+
+ return MatchingSubstring;
+
+ }
+
+ else if (data[0] == 110)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 111, 114, 109, 97, 108, 105, 122, 97, 116, 105, 111, 110, 45, 102, 111, 114, 109
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 17) == 0)
+
+
+ return NormalizationForm;
+
+ }
+
+ else if (data[0] == 117)
+
+
+ {
+ if (data[1] == 110)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 100, 101, 99, 108, 97, 114, 101, 45, 112, 114, 101, 102, 105, 120, 101, 115
+ };
+ if(memcmp(&data[2], &string, sizeof(QChar) * 16) == 0)
+
+
+ return UndeclarePrefixes;
+
+ }
+
+ else if (data[1] == 115)
+
+
+ {
+ if (data[2] == 101)
+
+
+ {
+ if (data[3] == 45)
+
+
+ {
+ if (data[4] == 97)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 116, 116, 114, 105, 98, 117, 116, 101, 45, 115, 101, 116, 115
+ };
+ if(memcmp(&data[5], &string, sizeof(QChar) * 13) == 0)
+
+
+ return UseAttributeSets;
+
+ }
+
+ else if (data[4] == 99)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 104, 97, 114, 97, 99, 116, 101, 114, 45, 109, 97, 112, 115
+ };
+ if(memcmp(&data[5], &string, sizeof(QChar) * 13) == 0)
+
+
+ return UseCharacterMaps;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+
+ return NoKeyword;
+ }
+ XSLTTokenLookup::NodeName XSLTTokenLookup::classifier20(const QChar *data)
+
+ {
+ if (data[0] == 105)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 110, 99, 108, 117, 100, 101, 45, 99, 111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 19) == 0)
+
+
+ return IncludeContentType;
+
+ }
+
+ else if (data[0] == 111)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 109, 105, 116, 45, 120, 109, 108, 45, 100, 101, 99, 108, 97, 114, 97, 116, 105, 111, 110
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 19) == 0)
+
+
+ return OmitXmlDeclaration;
+
+ }
+
+
+
+ return NoKeyword;
+ }
+ XSLTTokenLookup::NodeName XSLTTokenLookup::classifier21(const QChar *data)
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 101, 115, 99, 97, 112, 101, 45, 117, 114, 105, 45, 97, 116, 116, 114, 105, 98, 117, 116, 101, 115
+ };
+ if(memcmp(&data[0], &string, sizeof(QChar) * 21) == 0)
+
+
+ return EscapeUriAttributes;
+
+
+ return NoKeyword;
+ }
+ XSLTTokenLookup::NodeName XSLTTokenLookup::classifier22(const QChar *data)
+
+ {
+ if (data[0] == 99)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 100, 97, 116, 97, 45, 115, 101, 99, 116, 105, 111, 110, 45, 101, 108, 101, 109, 101, 110, 116, 115
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 21) == 0)
+
+
+ return CdataSectionElements;
+
+ }
+
+ else if (data[0] == 105)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 110, 112, 117, 116, 45, 116, 121, 112, 101, 45, 97, 110, 110, 111, 116, 97, 116, 105, 111, 110, 115
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 21) == 0)
+
+
+ return InputTypeAnnotations;
+
+ }
+
+ else if (data[0] == 110)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 111, 110, 45, 109, 97, 116, 99, 104, 105, 110, 103, 45, 115, 117, 98, 115, 116, 114, 105, 110, 103
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 21) == 0)
+
+
+ return NonMatchingSubstring;
+
+ }
+
+ else if (data[0] == 112)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 114, 111, 99, 101, 115, 115, 105, 110, 103, 45, 105, 110, 115, 116, 114, 117, 99, 116, 105, 111, 110
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 21) == 0)
+
+
+ return ProcessingInstruction;
+
+ }
+
+
+
+ return NoKeyword;
+ }
+ XSLTTokenLookup::NodeName XSLTTokenLookup::classifier23(const QChar *data)
+
+ {
+ if (data[0] == 101)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 120, 99, 108, 117, 100, 101, 45, 114, 101, 115, 117, 108, 116, 45, 112, 114, 101, 102, 105, 120, 101, 115
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 22) == 0)
+
+
+ return ExcludeResultPrefixes;
+
+ }
+
+ else if (data[0] == 120)
+
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 112, 97, 116, 104, 45, 100, 101, 102, 97, 117, 108, 116, 45, 110, 97, 109, 101, 115, 112, 97, 99, 101
+ };
+ if(memcmp(&data[1], &string, sizeof(QChar) * 22) == 0)
+
+
+ return XpathDefaultNamespace;
+
+ }
+
+
+
+ return NoKeyword;
+ }
+ XSLTTokenLookup::NodeName XSLTTokenLookup::classifier26(const QChar *data)
+
+ {
+
+ static const unsigned short string[] =
+ {
+ 101, 120, 116, 101, 110, 115, 105, 111, 110, 45, 101, 108, 101, 109, 101, 110, 116, 45, 112, 114, 101, 102, 105, 120, 101, 115
+ };
+ if(memcmp(&data[0], &string, sizeof(QChar) * 26) == 0)
+
+
+ return ExtensionElementPrefixes;
+
+
+ return NoKeyword;
+ }
+ XSLTTokenLookup::NodeName XSLTTokenLookup::toToken(const QChar *data, int length)
+ {
+ switch(length)
+ {
+
+ case 2:
+ return classifier2(data);
+
+
+ case 3:
+ return classifier3(data);
+
+
+ case 4:
+ return classifier4(data);
+
+
+ case 5:
+ return classifier5(data);
+
+
+ case 6:
+ return classifier6(data);
+
+
+ case 7:
+ return classifier7(data);
+
+
+ case 8:
+ return classifier8(data);
+
+
+ case 9:
+ return classifier9(data);
+
+
+ case 10:
+ return classifier10(data);
+
+
+ case 11:
+ return classifier11(data);
+
+
+ case 12:
+ return classifier12(data);
+
+
+ case 13:
+ return classifier13(data);
+
+
+ case 14:
+ return classifier14(data);
+
+
+ case 15:
+ return classifier15(data);
+
+
+ case 17:
+ return classifier17(data);
+
+
+ case 18:
+ return classifier18(data);
+
+
+ case 20:
+ return classifier20(data);
+
+
+ case 21:
+ return classifier21(data);
+
+
+ case 22:
+ return classifier22(data);
+
+
+ case 23:
+ return classifier23(data);
+
+
+ case 26:
+ return classifier26(data);
+
+
+ default:
+ return NoKeyword;
+ }
+ }
+
+
+ QString XSLTTokenLookup::toString(NodeName token)
+ {
+ const unsigned short *data = 0;
+ int length = 0;
+
+ switch(token)
+ {
+
+ case AnalyzeString:
+ {
+ static const unsigned short staticallyStoredAnalyzeString[] =
+ {
+ 97, 110, 97, 108, 121, 122, 101, 45, 115, 116, 114, 105, 110, 103, 0
+ };
+ data = staticallyStoredAnalyzeString;
+ length = 14;
+ break;
+ }
+
+ case ApplyTemplates:
+ {
+ static const unsigned short staticallyStoredApplyTemplates[] =
+ {
+ 97, 112, 112, 108, 121, 45, 116, 101, 109, 112, 108, 97, 116, 101, 115, 0
+ };
+ data = staticallyStoredApplyTemplates;
+ length = 15;
+ break;
+ }
+
+ case As:
+ {
+ static const unsigned short staticallyStoredAs[] =
+ {
+ 97, 115, 0
+ };
+ data = staticallyStoredAs;
+ length = 2;
+ break;
+ }
+
+ case Attribute:
+ {
+ static const unsigned short staticallyStoredAttribute[] =
+ {
+ 97, 116, 116, 114, 105, 98, 117, 116, 101, 0
+ };
+ data = staticallyStoredAttribute;
+ length = 9;
+ break;
+ }
+
+ case AttributeSet:
+ {
+ static const unsigned short staticallyStoredAttributeSet[] =
+ {
+ 97, 116, 116, 114, 105, 98, 117, 116, 101, 45, 115, 101, 116, 0
+ };
+ data = staticallyStoredAttributeSet;
+ length = 13;
+ break;
+ }
+
+ case ByteOrderMark:
+ {
+ static const unsigned short staticallyStoredByteOrderMark[] =
+ {
+ 98, 121, 116, 101, 45, 111, 114, 100, 101, 114, 45, 109, 97, 114, 107, 0
+ };
+ data = staticallyStoredByteOrderMark;
+ length = 15;
+ break;
+ }
+
+ case CallTemplate:
+ {
+ static const unsigned short staticallyStoredCallTemplate[] =
+ {
+ 99, 97, 108, 108, 45, 116, 101, 109, 112, 108, 97, 116, 101, 0
+ };
+ data = staticallyStoredCallTemplate;
+ length = 13;
+ break;
+ }
+
+ case CaseOrder:
+ {
+ static const unsigned short staticallyStoredCaseOrder[] =
+ {
+ 99, 97, 115, 101, 45, 111, 114, 100, 101, 114, 0
+ };
+ data = staticallyStoredCaseOrder;
+ length = 10;
+ break;
+ }
+
+ case CdataSectionElements:
+ {
+ static const unsigned short staticallyStoredCdataSectionElements[] =
+ {
+ 99, 100, 97, 116, 97, 45, 115, 101, 99, 116, 105, 111, 110, 45, 101, 108, 101, 109, 101, 110, 116, 115, 0
+ };
+ data = staticallyStoredCdataSectionElements;
+ length = 22;
+ break;
+ }
+
+ case Choose:
+ {
+ static const unsigned short staticallyStoredChoose[] =
+ {
+ 99, 104, 111, 111, 115, 101, 0
+ };
+ data = staticallyStoredChoose;
+ length = 6;
+ break;
+ }
+
+ case Collation:
+ {
+ static const unsigned short staticallyStoredCollation[] =
+ {
+ 99, 111, 108, 108, 97, 116, 105, 111, 110, 0
+ };
+ data = staticallyStoredCollation;
+ length = 9;
+ break;
+ }
+
+ case Comment:
+ {
+ static const unsigned short staticallyStoredComment[] =
+ {
+ 99, 111, 109, 109, 101, 110, 116, 0
+ };
+ data = staticallyStoredComment;
+ length = 7;
+ break;
+ }
+
+ case Copy:
+ {
+ static const unsigned short staticallyStoredCopy[] =
+ {
+ 99, 111, 112, 121, 0
+ };
+ data = staticallyStoredCopy;
+ length = 4;
+ break;
+ }
+
+ case CopyNamespaces:
+ {
+ static const unsigned short staticallyStoredCopyNamespaces[] =
+ {
+ 99, 111, 112, 121, 45, 110, 97, 109, 101, 115, 112, 97, 99, 101, 115, 0
+ };
+ data = staticallyStoredCopyNamespaces;
+ length = 15;
+ break;
+ }
+
+ case CopyOf:
+ {
+ static const unsigned short staticallyStoredCopyOf[] =
+ {
+ 99, 111, 112, 121, 45, 111, 102, 0
+ };
+ data = staticallyStoredCopyOf;
+ length = 7;
+ break;
+ }
+
+ case DataType:
+ {
+ static const unsigned short staticallyStoredDataType[] =
+ {
+ 100, 97, 116, 97, 45, 116, 121, 112, 101, 0
+ };
+ data = staticallyStoredDataType;
+ length = 9;
+ break;
+ }
+
+ case DefaultCollation:
+ {
+ static const unsigned short staticallyStoredDefaultCollation[] =
+ {
+ 100, 101, 102, 97, 117, 108, 116, 45, 99, 111, 108, 108, 97, 116, 105, 111, 110, 0
+ };
+ data = staticallyStoredDefaultCollation;
+ length = 17;
+ break;
+ }
+
+ case DefaultValidation:
+ {
+ static const unsigned short staticallyStoredDefaultValidation[] =
+ {
+ 100, 101, 102, 97, 117, 108, 116, 45, 118, 97, 108, 105, 100, 97, 116, 105, 111, 110, 0
+ };
+ data = staticallyStoredDefaultValidation;
+ length = 18;
+ break;
+ }
+
+ case DoctypePublic:
+ {
+ static const unsigned short staticallyStoredDoctypePublic[] =
+ {
+ 100, 111, 99, 116, 121, 112, 101, 45, 112, 117, 98, 108, 105, 99, 0
+ };
+ data = staticallyStoredDoctypePublic;
+ length = 14;
+ break;
+ }
+
+ case DoctypeSystem:
+ {
+ static const unsigned short staticallyStoredDoctypeSystem[] =
+ {
+ 100, 111, 99, 116, 121, 112, 101, 45, 115, 121, 115, 116, 101, 109, 0
+ };
+ data = staticallyStoredDoctypeSystem;
+ length = 14;
+ break;
+ }
+
+ case Document:
+ {
+ static const unsigned short staticallyStoredDocument[] =
+ {
+ 100, 111, 99, 117, 109, 101, 110, 116, 0
+ };
+ data = staticallyStoredDocument;
+ length = 8;
+ break;
+ }
+
+ case Element:
+ {
+ static const unsigned short staticallyStoredElement[] =
+ {
+ 101, 108, 101, 109, 101, 110, 116, 0
+ };
+ data = staticallyStoredElement;
+ length = 7;
+ break;
+ }
+
+ case Elements:
+ {
+ static const unsigned short staticallyStoredElements[] =
+ {
+ 101, 108, 101, 109, 101, 110, 116, 115, 0
+ };
+ data = staticallyStoredElements;
+ length = 8;
+ break;
+ }
+
+ case Encoding:
+ {
+ static const unsigned short staticallyStoredEncoding[] =
+ {
+ 101, 110, 99, 111, 100, 105, 110, 103, 0
+ };
+ data = staticallyStoredEncoding;
+ length = 8;
+ break;
+ }
+
+ case EscapeUriAttributes:
+ {
+ static const unsigned short staticallyStoredEscapeUriAttributes[] =
+ {
+ 101, 115, 99, 97, 112, 101, 45, 117, 114, 105, 45, 97, 116, 116, 114, 105, 98, 117, 116, 101, 115, 0
+ };
+ data = staticallyStoredEscapeUriAttributes;
+ length = 21;
+ break;
+ }
+
+ case ExcludeResultPrefixes:
+ {
+ static const unsigned short staticallyStoredExcludeResultPrefixes[] =
+ {
+ 101, 120, 99, 108, 117, 100, 101, 45, 114, 101, 115, 117, 108, 116, 45, 112, 114, 101, 102, 105, 120, 101, 115, 0
+ };
+ data = staticallyStoredExcludeResultPrefixes;
+ length = 23;
+ break;
+ }
+
+ case ExtensionElementPrefixes:
+ {
+ static const unsigned short staticallyStoredExtensionElementPrefixes[] =
+ {
+ 101, 120, 116, 101, 110, 115, 105, 111, 110, 45, 101, 108, 101, 109, 101, 110, 116, 45, 112, 114, 101, 102, 105, 120, 101, 115, 0
+ };
+ data = staticallyStoredExtensionElementPrefixes;
+ length = 26;
+ break;
+ }
+
+ case Flags:
+ {
+ static const unsigned short staticallyStoredFlags[] =
+ {
+ 102, 108, 97, 103, 115, 0
+ };
+ data = staticallyStoredFlags;
+ length = 5;
+ break;
+ }
+
+ case ForEach:
+ {
+ static const unsigned short staticallyStoredForEach[] =
+ {
+ 102, 111, 114, 45, 101, 97, 99, 104, 0
+ };
+ data = staticallyStoredForEach;
+ length = 8;
+ break;
+ }
+
+ case Format:
+ {
+ static const unsigned short staticallyStoredFormat[] =
+ {
+ 102, 111, 114, 109, 97, 116, 0
+ };
+ data = staticallyStoredFormat;
+ length = 6;
+ break;
+ }
+
+ case Function:
+ {
+ static const unsigned short staticallyStoredFunction[] =
+ {
+ 102, 117, 110, 99, 116, 105, 111, 110, 0
+ };
+ data = staticallyStoredFunction;
+ length = 8;
+ break;
+ }
+
+ case Href:
+ {
+ static const unsigned short staticallyStoredHref[] =
+ {
+ 104, 114, 101, 102, 0
+ };
+ data = staticallyStoredHref;
+ length = 4;
+ break;
+ }
+
+ case Id:
+ {
+ static const unsigned short staticallyStoredId[] =
+ {
+ 105, 100, 0
+ };
+ data = staticallyStoredId;
+ length = 2;
+ break;
+ }
+
+ case If:
+ {
+ static const unsigned short staticallyStoredIf[] =
+ {
+ 105, 102, 0
+ };
+ data = staticallyStoredIf;
+ length = 2;
+ break;
+ }
+
+ case Import:
+ {
+ static const unsigned short staticallyStoredImport[] =
+ {
+ 105, 109, 112, 111, 114, 116, 0
+ };
+ data = staticallyStoredImport;
+ length = 6;
+ break;
+ }
+
+ case ImportSchema:
+ {
+ static const unsigned short staticallyStoredImportSchema[] =
+ {
+ 105, 109, 112, 111, 114, 116, 45, 115, 99, 104, 101, 109, 97, 0
+ };
+ data = staticallyStoredImportSchema;
+ length = 13;
+ break;
+ }
+
+ case Include:
+ {
+ static const unsigned short staticallyStoredInclude[] =
+ {
+ 105, 110, 99, 108, 117, 100, 101, 0
+ };
+ data = staticallyStoredInclude;
+ length = 7;
+ break;
+ }
+
+ case IncludeContentType:
+ {
+ static const unsigned short staticallyStoredIncludeContentType[] =
+ {
+ 105, 110, 99, 108, 117, 100, 101, 45, 99, 111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 0
+ };
+ data = staticallyStoredIncludeContentType;
+ length = 20;
+ break;
+ }
+
+ case Indent:
+ {
+ static const unsigned short staticallyStoredIndent[] =
+ {
+ 105, 110, 100, 101, 110, 116, 0
+ };
+ data = staticallyStoredIndent;
+ length = 6;
+ break;
+ }
+
+ case InheritNamespaces:
+ {
+ static const unsigned short staticallyStoredInheritNamespaces[] =
+ {
+ 105, 110, 104, 101, 114, 105, 116, 45, 110, 97, 109, 101, 115, 112, 97, 99, 101, 115, 0
+ };
+ data = staticallyStoredInheritNamespaces;
+ length = 18;
+ break;
+ }
+
+ case InputTypeAnnotations:
+ {
+ static const unsigned short staticallyStoredInputTypeAnnotations[] =
+ {
+ 105, 110, 112, 117, 116, 45, 116, 121, 112, 101, 45, 97, 110, 110, 111, 116, 97, 116, 105, 111, 110, 115, 0
+ };
+ data = staticallyStoredInputTypeAnnotations;
+ length = 22;
+ break;
+ }
+
+ case Key:
+ {
+ static const unsigned short staticallyStoredKey[] =
+ {
+ 107, 101, 121, 0
+ };
+ data = staticallyStoredKey;
+ length = 3;
+ break;
+ }
+
+ case Lang:
+ {
+ static const unsigned short staticallyStoredLang[] =
+ {
+ 108, 97, 110, 103, 0
+ };
+ data = staticallyStoredLang;
+ length = 4;
+ break;
+ }
+
+ case Match:
+ {
+ static const unsigned short staticallyStoredMatch[] =
+ {
+ 109, 97, 116, 99, 104, 0
+ };
+ data = staticallyStoredMatch;
+ length = 5;
+ break;
+ }
+
+ case MatchingSubstring:
+ {
+ static const unsigned short staticallyStoredMatchingSubstring[] =
+ {
+ 109, 97, 116, 99, 104, 105, 110, 103, 45, 115, 117, 98, 115, 116, 114, 105, 110, 103, 0
+ };
+ data = staticallyStoredMatchingSubstring;
+ length = 18;
+ break;
+ }
+
+ case MediaType:
+ {
+ static const unsigned short staticallyStoredMediaType[] =
+ {
+ 109, 101, 100, 105, 97, 45, 116, 121, 112, 101, 0
+ };
+ data = staticallyStoredMediaType;
+ length = 10;
+ break;
+ }
+
+ case Message:
+ {
+ static const unsigned short staticallyStoredMessage[] =
+ {
+ 109, 101, 115, 115, 97, 103, 101, 0
+ };
+ data = staticallyStoredMessage;
+ length = 7;
+ break;
+ }
+
+ case Method:
+ {
+ static const unsigned short staticallyStoredMethod[] =
+ {
+ 109, 101, 116, 104, 111, 100, 0
+ };
+ data = staticallyStoredMethod;
+ length = 6;
+ break;
+ }
+
+ case Mode:
+ {
+ static const unsigned short staticallyStoredMode[] =
+ {
+ 109, 111, 100, 101, 0
+ };
+ data = staticallyStoredMode;
+ length = 4;
+ break;
+ }
+
+ case Name:
+ {
+ static const unsigned short staticallyStoredName[] =
+ {
+ 110, 97, 109, 101, 0
+ };
+ data = staticallyStoredName;
+ length = 4;
+ break;
+ }
+
+ case Namespace:
+ {
+ static const unsigned short staticallyStoredNamespace[] =
+ {
+ 110, 97, 109, 101, 115, 112, 97, 99, 101, 0
+ };
+ data = staticallyStoredNamespace;
+ length = 9;
+ break;
+ }
+
+ case NonMatchingSubstring:
+ {
+ static const unsigned short staticallyStoredNonMatchingSubstring[] =
+ {
+ 110, 111, 110, 45, 109, 97, 116, 99, 104, 105, 110, 103, 45, 115, 117, 98, 115, 116, 114, 105, 110, 103, 0
+ };
+ data = staticallyStoredNonMatchingSubstring;
+ length = 22;
+ break;
+ }
+
+ case NormalizationForm:
+ {
+ static const unsigned short staticallyStoredNormalizationForm[] =
+ {
+ 110, 111, 114, 109, 97, 108, 105, 122, 97, 116, 105, 111, 110, 45, 102, 111, 114, 109, 0
+ };
+ data = staticallyStoredNormalizationForm;
+ length = 18;
+ break;
+ }
+
+ case OmitXmlDeclaration:
+ {
+ static const unsigned short staticallyStoredOmitXmlDeclaration[] =
+ {
+ 111, 109, 105, 116, 45, 120, 109, 108, 45, 100, 101, 99, 108, 97, 114, 97, 116, 105, 111, 110, 0
+ };
+ data = staticallyStoredOmitXmlDeclaration;
+ length = 20;
+ break;
+ }
+
+ case Order:
+ {
+ static const unsigned short staticallyStoredOrder[] =
+ {
+ 111, 114, 100, 101, 114, 0
+ };
+ data = staticallyStoredOrder;
+ length = 5;
+ break;
+ }
+
+ case Otherwise:
+ {
+ static const unsigned short staticallyStoredOtherwise[] =
+ {
+ 111, 116, 104, 101, 114, 119, 105, 115, 101, 0
+ };
+ data = staticallyStoredOtherwise;
+ length = 9;
+ break;
+ }
+
+ case Output:
+ {
+ static const unsigned short staticallyStoredOutput[] =
+ {
+ 111, 117, 116, 112, 117, 116, 0
+ };
+ data = staticallyStoredOutput;
+ length = 6;
+ break;
+ }
+
+ case OutputVersion:
+ {
+ static const unsigned short staticallyStoredOutputVersion[] =
+ {
+ 111, 117, 116, 112, 117, 116, 45, 118, 101, 114, 115, 105, 111, 110, 0
+ };
+ data = staticallyStoredOutputVersion;
+ length = 14;
+ break;
+ }
+
+ case Override:
+ {
+ static const unsigned short staticallyStoredOverride[] =
+ {
+ 111, 118, 101, 114, 114, 105, 100, 101, 0
+ };
+ data = staticallyStoredOverride;
+ length = 8;
+ break;
+ }
+
+ case Param:
+ {
+ static const unsigned short staticallyStoredParam[] =
+ {
+ 112, 97, 114, 97, 109, 0
+ };
+ data = staticallyStoredParam;
+ length = 5;
+ break;
+ }
+
+ case PerformSort:
+ {
+ static const unsigned short staticallyStoredPerformSort[] =
+ {
+ 112, 101, 114, 102, 111, 114, 109, 45, 115, 111, 114, 116, 0
+ };
+ data = staticallyStoredPerformSort;
+ length = 12;
+ break;
+ }
+
+ case PreserveSpace:
+ {
+ static const unsigned short staticallyStoredPreserveSpace[] =
+ {
+ 112, 114, 101, 115, 101, 114, 118, 101, 45, 115, 112, 97, 99, 101, 0
+ };
+ data = staticallyStoredPreserveSpace;
+ length = 14;
+ break;
+ }
+
+ case Priority:
+ {
+ static const unsigned short staticallyStoredPriority[] =
+ {
+ 112, 114, 105, 111, 114, 105, 116, 121, 0
+ };
+ data = staticallyStoredPriority;
+ length = 8;
+ break;
+ }
+
+ case ProcessingInstruction:
+ {
+ static const unsigned short staticallyStoredProcessingInstruction[] =
+ {
+ 112, 114, 111, 99, 101, 115, 115, 105, 110, 103, 45, 105, 110, 115, 116, 114, 117, 99, 116, 105, 111, 110, 0
+ };
+ data = staticallyStoredProcessingInstruction;
+ length = 22;
+ break;
+ }
+
+ case Regex:
+ {
+ static const unsigned short staticallyStoredRegex[] =
+ {
+ 114, 101, 103, 101, 120, 0
+ };
+ data = staticallyStoredRegex;
+ length = 5;
+ break;
+ }
+
+ case Required:
+ {
+ static const unsigned short staticallyStoredRequired[] =
+ {
+ 114, 101, 113, 117, 105, 114, 101, 100, 0
+ };
+ data = staticallyStoredRequired;
+ length = 8;
+ break;
+ }
+
+ case ResultDocument:
+ {
+ static const unsigned short staticallyStoredResultDocument[] =
+ {
+ 114, 101, 115, 117, 108, 116, 45, 100, 111, 99, 117, 109, 101, 110, 116, 0
+ };
+ data = staticallyStoredResultDocument;
+ length = 15;
+ break;
+ }
+
+ case SchemaLocation:
+ {
+ static const unsigned short staticallyStoredSchemaLocation[] =
+ {
+ 115, 99, 104, 101, 109, 97, 45, 108, 111, 99, 97, 116, 105, 111, 110, 0
+ };
+ data = staticallyStoredSchemaLocation;
+ length = 15;
+ break;
+ }
+
+ case Select:
+ {
+ static const unsigned short staticallyStoredSelect[] =
+ {
+ 115, 101, 108, 101, 99, 116, 0
+ };
+ data = staticallyStoredSelect;
+ length = 6;
+ break;
+ }
+
+ case Separator:
+ {
+ static const unsigned short staticallyStoredSeparator[] =
+ {
+ 115, 101, 112, 97, 114, 97, 116, 111, 114, 0
+ };
+ data = staticallyStoredSeparator;
+ length = 9;
+ break;
+ }
+
+ case Sequence:
+ {
+ static const unsigned short staticallyStoredSequence[] =
+ {
+ 115, 101, 113, 117, 101, 110, 99, 101, 0
+ };
+ data = staticallyStoredSequence;
+ length = 8;
+ break;
+ }
+
+ case Sort:
+ {
+ static const unsigned short staticallyStoredSort[] =
+ {
+ 115, 111, 114, 116, 0
+ };
+ data = staticallyStoredSort;
+ length = 4;
+ break;
+ }
+
+ case Stable:
+ {
+ static const unsigned short staticallyStoredStable[] =
+ {
+ 115, 116, 97, 98, 108, 101, 0
+ };
+ data = staticallyStoredStable;
+ length = 6;
+ break;
+ }
+
+ case Standalone:
+ {
+ static const unsigned short staticallyStoredStandalone[] =
+ {
+ 115, 116, 97, 110, 100, 97, 108, 111, 110, 101, 0
+ };
+ data = staticallyStoredStandalone;
+ length = 10;
+ break;
+ }
+
+ case StripSpace:
+ {
+ static const unsigned short staticallyStoredStripSpace[] =
+ {
+ 115, 116, 114, 105, 112, 45, 115, 112, 97, 99, 101, 0
+ };
+ data = staticallyStoredStripSpace;
+ length = 11;
+ break;
+ }
+
+ case Stylesheet:
+ {
+ static const unsigned short staticallyStoredStylesheet[] =
+ {
+ 115, 116, 121, 108, 101, 115, 104, 101, 101, 116, 0
+ };
+ data = staticallyStoredStylesheet;
+ length = 10;
+ break;
+ }
+
+ case Template:
+ {
+ static const unsigned short staticallyStoredTemplate[] =
+ {
+ 116, 101, 109, 112, 108, 97, 116, 101, 0
+ };
+ data = staticallyStoredTemplate;
+ length = 8;
+ break;
+ }
+
+ case Terminate:
+ {
+ static const unsigned short staticallyStoredTerminate[] =
+ {
+ 116, 101, 114, 109, 105, 110, 97, 116, 101, 0
+ };
+ data = staticallyStoredTerminate;
+ length = 9;
+ break;
+ }
+
+ case Test:
+ {
+ static const unsigned short staticallyStoredTest[] =
+ {
+ 116, 101, 115, 116, 0
+ };
+ data = staticallyStoredTest;
+ length = 4;
+ break;
+ }
+
+ case Text:
+ {
+ static const unsigned short staticallyStoredText[] =
+ {
+ 116, 101, 120, 116, 0
+ };
+ data = staticallyStoredText;
+ length = 4;
+ break;
+ }
+
+ case Transform:
+ {
+ static const unsigned short staticallyStoredTransform[] =
+ {
+ 116, 114, 97, 110, 115, 102, 111, 114, 109, 0
+ };
+ data = staticallyStoredTransform;
+ length = 9;
+ break;
+ }
+
+ case Tunnel:
+ {
+ static const unsigned short staticallyStoredTunnel[] =
+ {
+ 116, 117, 110, 110, 101, 108, 0
+ };
+ data = staticallyStoredTunnel;
+ length = 6;
+ break;
+ }
+
+ case Type:
+ {
+ static const unsigned short staticallyStoredType[] =
+ {
+ 116, 121, 112, 101, 0
+ };
+ data = staticallyStoredType;
+ length = 4;
+ break;
+ }
+
+ case UndeclarePrefixes:
+ {
+ static const unsigned short staticallyStoredUndeclarePrefixes[] =
+ {
+ 117, 110, 100, 101, 99, 108, 97, 114, 101, 45, 112, 114, 101, 102, 105, 120, 101, 115, 0
+ };
+ data = staticallyStoredUndeclarePrefixes;
+ length = 18;
+ break;
+ }
+
+ case Use:
+ {
+ static const unsigned short staticallyStoredUse[] =
+ {
+ 117, 115, 101, 0
+ };
+ data = staticallyStoredUse;
+ length = 3;
+ break;
+ }
+
+ case UseAttributeSets:
+ {
+ static const unsigned short staticallyStoredUseAttributeSets[] =
+ {
+ 117, 115, 101, 45, 97, 116, 116, 114, 105, 98, 117, 116, 101, 45, 115, 101, 116, 115, 0
+ };
+ data = staticallyStoredUseAttributeSets;
+ length = 18;
+ break;
+ }
+
+ case UseCharacterMaps:
+ {
+ static const unsigned short staticallyStoredUseCharacterMaps[] =
+ {
+ 117, 115, 101, 45, 99, 104, 97, 114, 97, 99, 116, 101, 114, 45, 109, 97, 112, 115, 0
+ };
+ data = staticallyStoredUseCharacterMaps;
+ length = 18;
+ break;
+ }
+
+ case UseWhen:
+ {
+ static const unsigned short staticallyStoredUseWhen[] =
+ {
+ 117, 115, 101, 45, 119, 104, 101, 110, 0
+ };
+ data = staticallyStoredUseWhen;
+ length = 8;
+ break;
+ }
+
+ case Validation:
+ {
+ static const unsigned short staticallyStoredValidation[] =
+ {
+ 118, 97, 108, 105, 100, 97, 116, 105, 111, 110, 0
+ };
+ data = staticallyStoredValidation;
+ length = 10;
+ break;
+ }
+
+ case ValueOf:
+ {
+ static const unsigned short staticallyStoredValueOf[] =
+ {
+ 118, 97, 108, 117, 101, 45, 111, 102, 0
+ };
+ data = staticallyStoredValueOf;
+ length = 8;
+ break;
+ }
+
+ case Variable:
+ {
+ static const unsigned short staticallyStoredVariable[] =
+ {
+ 118, 97, 114, 105, 97, 98, 108, 101, 0
+ };
+ data = staticallyStoredVariable;
+ length = 8;
+ break;
+ }
+
+ case Version:
+ {
+ static const unsigned short staticallyStoredVersion[] =
+ {
+ 118, 101, 114, 115, 105, 111, 110, 0
+ };
+ data = staticallyStoredVersion;
+ length = 7;
+ break;
+ }
+
+ case When:
+ {
+ static const unsigned short staticallyStoredWhen[] =
+ {
+ 119, 104, 101, 110, 0
+ };
+ data = staticallyStoredWhen;
+ length = 4;
+ break;
+ }
+
+ case WithParam:
+ {
+ static const unsigned short staticallyStoredWithParam[] =
+ {
+ 119, 105, 116, 104, 45, 112, 97, 114, 97, 109, 0
+ };
+ data = staticallyStoredWithParam;
+ length = 10;
+ break;
+ }
+
+ case XpathDefaultNamespace:
+ {
+ static const unsigned short staticallyStoredXpathDefaultNamespace[] =
+ {
+ 120, 112, 97, 116, 104, 45, 100, 101, 102, 97, 117, 108, 116, 45, 110, 97, 109, 101, 115, 112, 97, 99, 101, 0
+ };
+ data = staticallyStoredXpathDefaultNamespace;
+ length = 23;
+ break;
+ }
+
+ default:
+ /* It's either the default token, or an undefined enum
+ * value. We silence a compiler warning, and return the
+ * empty string. */
+ ;
+ }
+
+ union
+ {
+ const unsigned short *data;
+ const QChar *asQChar;
+ } converter;
+ converter.data = data;
+
+ return QString::fromRawData(converter.asQChar, length);
+ }
+
+QT_END_NAMESPACE
+
diff --git a/src/xmlpatterns/parser/qxslttokenlookup.xml b/src/xmlpatterns/parser/qxslttokenlookup.xml
new file mode 100644
index 0000000000..228eae2c2f
--- /dev/null
+++ b/src/xmlpatterns/parser/qxslttokenlookup.xml
@@ -0,0 +1,167 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<tokenAutomaton scope="public"
+ className="XSLTTokenLookup"
+ headerFile="qxslttokenlookup_p.h"
+ sourceFile="qxslttokenlookup.cpp"
+ namespace="QPatternist"
+ defaultToken="NoKeyword"
+ hasToString="true"
+ tokenEnum="NodeName"
+ includeGuardName="qxslttokenlookup_p_H">
+ <tokens>
+ <token>analyze-string</token>
+ <token>apply-templates</token>
+ <token>as</token>
+ <token>attribute-set</token>
+ <token>attribute</token>
+ <token>byte-order-mark</token>
+ <token>call-template</token>
+ <token>case-order</token>
+ <token>cdata-section-elements</token>
+ <token>choose</token>
+ <token>collation</token>
+ <token>comment</token>
+ <token>copy-namespaces</token>
+ <token>copy-of</token>
+ <token>copy</token>
+ <token>data-type</token>
+ <token>default-collation</token>
+ <token>default-validation</token>
+ <token>doctype-public</token>
+ <token>doctype-system</token>
+ <token>document</token>
+ <token>elements</token>
+ <token>element</token>
+ <token>encoding</token>
+ <token>escape-uri-attributes</token>
+ <token>exclude-result-prefixes</token>
+ <token>extension-element-prefixes</token>
+ <token>flags</token>
+ <token>for-each</token>
+ <token>format</token>
+ <token>function</token>
+ <token>href</token>
+ <token>id</token>
+ <token>if</token>
+ <token>import-schema</token>
+ <token>import</token>
+ <token>include-content-type</token>
+ <token>include</token>
+ <token>indent</token>
+ <token>inherit-namespaces</token>
+ <token>input-type-annotations</token>
+ <token>key</token>
+ <token>lang</token>
+ <token>matching-substring</token>
+ <token>match</token>
+ <token>media-type</token>
+ <token>message</token>
+ <token>method</token>
+ <token>mode</token>
+ <token>namespace</token>
+ <token>name</token>
+ <token>non-matching-substring</token>
+ <token>normalization-form</token>
+ <token>omit-xml-declaration</token>
+ <token>order</token>
+ <token>otherwise</token>
+ <token>output</token>
+ <token>output-version</token>
+ <token>override</token>
+ <token>param</token>
+ <token>perform-sort</token>
+ <token>preserve-space</token>
+ <token>priority</token>
+ <token>processing-instruction</token>
+ <token>regex</token>
+ <token>required</token>
+ <token>result-document</token>
+ <token>schema-location</token>
+ <token>select</token>
+ <token>separator</token>
+ <token>sequence</token>
+ <token>sort</token>
+ <token>stable</token>
+ <token>standalone</token>
+ <token>strip-space</token>
+ <token>stylesheet</token>
+ <token>template</token>
+ <token>terminate</token>
+ <token>test</token>
+ <token>text</token>
+ <token>transform</token>
+ <token>tunnel</token>
+ <token>type</token>
+ <token>undeclare-prefixes</token>
+ <token>use-attribute-sets</token>
+ <token>use-character-maps</token>
+ <token>use</token>
+ <token>use-when</token>
+ <token>validation</token>
+ <token>value-of</token>
+ <token>variable</token>
+ <token>version</token>
+ <token>when</token>
+ <token>with-param</token>
+ <token>xpath-default-namespace</token>
+ </tokens>
+
+ <boilerplate>
+
+ <prolog>/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@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.
+//
+
+</prolog>
+
+ </boilerplate>
+
+</tokenAutomaton>
diff --git a/src/xmlpatterns/parser/qxslttokenlookup_p.h b/src/xmlpatterns/parser/qxslttokenlookup_p.h
new file mode 100644
index 0000000000..c9551e3e22
--- /dev/null
+++ b/src/xmlpatterns/parser/qxslttokenlookup_p.h
@@ -0,0 +1,213 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@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.
+//
+
+/* NOTE: This file is AUTO GENERATED by qautomaton2cpp.xsl. */
+
+#ifndef qxslttokenlookup_p_H
+#define qxslttokenlookup_p_H
+
+#include <QtCore/QString>
+
+QT_BEGIN_NAMESPACE
+
+namespace QPatternist
+{
+ class XSLTTokenLookup
+ {
+ public:
+ enum NodeName
+
+ {
+ NoKeyword,
+ AnalyzeString,
+ ApplyTemplates,
+ As,
+ Attribute,
+ AttributeSet,
+ ByteOrderMark,
+ CallTemplate,
+ CaseOrder,
+ CdataSectionElements,
+ Choose,
+ Collation,
+ Comment,
+ Copy,
+ CopyNamespaces,
+ CopyOf,
+ DataType,
+ DefaultCollation,
+ DefaultValidation,
+ DoctypePublic,
+ DoctypeSystem,
+ Document,
+ Element,
+ Elements,
+ Encoding,
+ EscapeUriAttributes,
+ ExcludeResultPrefixes,
+ ExtensionElementPrefixes,
+ Flags,
+ ForEach,
+ Format,
+ Function,
+ Href,
+ Id,
+ If,
+ Import,
+ ImportSchema,
+ Include,
+ IncludeContentType,
+ Indent,
+ InheritNamespaces,
+ InputTypeAnnotations,
+ Key,
+ Lang,
+ Match,
+ MatchingSubstring,
+ MediaType,
+ Message,
+ Method,
+ Mode,
+ Name,
+ Namespace,
+ NonMatchingSubstring,
+ NormalizationForm,
+ OmitXmlDeclaration,
+ Order,
+ Otherwise,
+ Output,
+ OutputVersion,
+ Override,
+ Param,
+ PerformSort,
+ PreserveSpace,
+ Priority,
+ ProcessingInstruction,
+ Regex,
+ Required,
+ ResultDocument,
+ SchemaLocation,
+ Select,
+ Separator,
+ Sequence,
+ Sort,
+ Stable,
+ Standalone,
+ StripSpace,
+ Stylesheet,
+ Template,
+ Terminate,
+ Test,
+ Text,
+ Transform,
+ Tunnel,
+ Type,
+ UndeclarePrefixes,
+ Use,
+ UseAttributeSets,
+ UseCharacterMaps,
+ UseWhen,
+ Validation,
+ ValueOf,
+ Variable,
+ Version,
+ When,
+ WithParam,
+ XpathDefaultNamespace
+ };
+
+ static inline NodeName toToken(const QString &value);
+ static inline NodeName toToken(const QStringRef &value);
+ static NodeName toToken(const QChar *data, int length);
+ static QString toString(NodeName token);
+
+
+ private:
+ static inline NodeName classifier2(const QChar *data);
+ static inline NodeName classifier3(const QChar *data);
+ static inline NodeName classifier4(const QChar *data);
+ static inline NodeName classifier5(const QChar *data);
+ static inline NodeName classifier6(const QChar *data);
+ static inline NodeName classifier7(const QChar *data);
+ static inline NodeName classifier8(const QChar *data);
+ static inline NodeName classifier9(const QChar *data);
+ static inline NodeName classifier10(const QChar *data);
+ static inline NodeName classifier11(const QChar *data);
+ static inline NodeName classifier12(const QChar *data);
+ static inline NodeName classifier13(const QChar *data);
+ static inline NodeName classifier14(const QChar *data);
+ static inline NodeName classifier15(const QChar *data);
+ static inline NodeName classifier17(const QChar *data);
+ static inline NodeName classifier18(const QChar *data);
+ static inline NodeName classifier20(const QChar *data);
+ static inline NodeName classifier21(const QChar *data);
+ static inline NodeName classifier22(const QChar *data);
+ static inline NodeName classifier23(const QChar *data);
+ static inline NodeName classifier26(const QChar *data);
+
+ };
+
+ inline XSLTTokenLookup::NodeName XSLTTokenLookup::toToken(const QString &value)
+ {
+ return toToken(value.constData(), value.length());
+ }
+
+ inline XSLTTokenLookup::NodeName XSLTTokenLookup::toToken(const QStringRef &value)
+ {
+ return toToken(value.constData(), value.length());
+ }
+
+}
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/xmlpatterns/parser/trolltechHeader.txt b/src/xmlpatterns/parser/trolltechHeader.txt
new file mode 100644
index 0000000000..8ec655d039
--- /dev/null
+++ b/src/xmlpatterns/parser/trolltechHeader.txt
@@ -0,0 +1,51 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@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.
+
diff --git a/src/xmlpatterns/parser/winCEWorkaround.sed b/src/xmlpatterns/parser/winCEWorkaround.sed
new file mode 100644
index 0000000000..d1c09e83e5
--- /dev/null
+++ b/src/xmlpatterns/parser/winCEWorkaround.sed
@@ -0,0 +1,20 @@
+/\/\* Tokens\. \*\// i\
+\/\* These tokens are defined to nothing on Windows because they\'re\
+ \* used in their documentation parser, for use in things like:\
+ \*\
+ \* int foo(IN char\* name, OUT char\* path);\
+ \*\
+ \* Hence this un-break fix. Note that this file was auto generated. *\/\
+\#ifdef IN\
+\# undef IN\
+\#endif\
+\#ifdef INSTANCE\
+\# undef INSTANCE\
+\#endif\
+\#ifdef STRICT\
+\# undef STRICT\
+\#endif\
+\#ifdef SELF\
+\# undef SELF\
+\#endif\
+