qt-everywhere-src-5.14.1/qtxmlpatterns/src/xmlpatterns/expr/qexpressionfactory.cpp - orbit - Git at Google

 /****************************************************************************
 **
 ** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtXmlPatterns module of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
 ** Commercial License Usage
 ** Licensees holding valid commercial Qt licenses may use this file in
 ** accordance with the commercial license agreement provided with the
 ** Software or, alternatively, in accordance with the terms contained in
 ** a written agreement between you and The Qt Company. For licensing terms
 ** and conditions see https://www.qt.io/terms-conditions. For further
 ** information use the contact form at https://www.qt.io/contact-us.
 **
 ** GNU Lesser General Public License Usage
 ** Alternatively, this file may be used under the terms of the GNU Lesser
 ** General Public License version 3 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.LGPL3 included in the
 ** packaging of this file. Please review the following information to
 ** ensure the GNU Lesser General Public License version 3 requirements
 ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
 **
 ** GNU General Public License Usage
 ** Alternatively, this file may be used under the terms of the GNU
 ** General Public License version 2.0 or (at your option) the GNU General
 ** Public license version 3 or any later version approved by the KDE Free
 ** Qt Foundation. The licenses are as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
 ** included in the packaging of this file. Please review the following
 ** information to ensure the GNU General Public License requirements will
 ** be met: https://www.gnu.org/licenses/gpl-2.0.html and
 ** https://www.gnu.org/licenses/gpl-3.0.html.
 **
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/

 #include <QBuffer>
 #include <QByteArray>

 #include "qcalltemplate_p.h"
 #include "qcommonsequencetypes_p.h"
 #include "qxmldebug_p.h"
 #include "qexpression_p.h"
 #include "qgenericstaticcontext_p.h"
 #include "qoperandsiterator_p.h"
 #include "qoptimizationpasses_p.h"
 #include "qparsercontext_p.h"
 #include "qpath_p.h"
 #include "qquerytransformparser_p.h"
 #include "qstaticfocuscontext_p.h"
 #include "qtokenrevealer_p.h"
 #include "qxquerytokenizer_p.h"
 #include "qxslttokenizer_p.h"

 #include "qexpressionfactory_p.h"

 QT_BEGIN_NAMESPACE

 namespace QPatternist {

 /**
  * @short The entry point to the parser.
  *
  * @param info supplies the information the parser & scanner
  * needs to create expressions. The created expression, if everything
  * succeeds, can be retrieved via the object @p info points to.
  * @returns non-negative if the parser fails.
  * @see ExpressionFactory::createExpression()
  */
 extern int XPathparse(QPatternist::ParserContext *const info);

 Expression::Ptr ExpressionFactory::createExpression(const QString &expr,
                                                     const StaticContext::Ptr &context,
                                                     const QXmlQuery::QueryLanguage lang,
                                                     const SequenceType::Ptr &requiredType,
                                                     const QUrl &queryURI,
                                                     const QXmlName &initialTemplateName)
 {
     if(lang == QXmlQuery::XSLT20)
     {
         QByteArray query(expr.toUtf8());
         QBuffer buffer(&query);
         buffer.open(QIODevice::ReadOnly);

         return createExpression(&buffer,
                                 context,
                                 lang,
                                 requiredType,
                                 queryURI,
                                 initialTemplateName);
     }
     else
     {
         return createExpression(Tokenizer::Ptr(new XQueryTokenizer(expr, queryURI)),
                                 context,
                                 lang,
                                 requiredType,
                                 queryURI,
                                 initialTemplateName);
     }
 }

 Expression::Ptr ExpressionFactory::createExpression(QIODevice *const device,
                                                     const StaticContext::Ptr &context,
                                                     const QXmlQuery::QueryLanguage lang,
                                                     const SequenceType::Ptr &requiredType,
                                                     const QUrl &queryURI,
                                                     const QXmlName &initialTemplateName)
 {
     Q_ASSERT(device);
     Q_ASSERT(device->isReadable());

     Tokenizer::Ptr tokenizer;

     if(lang == QXmlQuery::XSLT20)
         tokenizer = Tokenizer::Ptr(new XSLTTokenizer(device, queryURI, context, context->namePool()));
     else
         tokenizer = Tokenizer::Ptr(new XQueryTokenizer(QString::fromUtf8(device->readAll()), queryURI));

     return createExpression(tokenizer, context, lang, requiredType, queryURI, initialTemplateName);
 }

 Expression::Ptr ExpressionFactory::createExpression(const Tokenizer::Ptr &tokenizer,
                                                     const StaticContext::Ptr &context,
                                                     const QXmlQuery::QueryLanguage lang,
                                                     const SequenceType::Ptr &requiredType,
                                                     const QUrl &queryURI,
                                                     const QXmlName &initialTemplateName)
 {
     Q_ASSERT(context);
     Q_ASSERT(requiredType);
     Q_ASSERT(queryURI.isValid());

     Tokenizer::Ptr effectiveTokenizer(tokenizer);
 #ifdef Patternist_DEBUG
     effectiveTokenizer = Tokenizer::Ptr(new TokenRevealer(queryURI, tokenizer));
 #endif

     OptimizationPasses::Coordinator::init();

     const ParserContext::Ptr info(new ParserContext(context, lang, effectiveTokenizer.data()));
     info->initialTemplateName = initialTemplateName;

     effectiveTokenizer->setParserContext(info);

     const int bisonRetval = QPatternist::XPathparse(info.data());

     Q_ASSERT_X(bisonRetval == 0, Q_FUNC_INFO,
                "We shouldn't be able to get an error, because we throw exceptions.");
     Q_UNUSED(bisonRetval); /* Needed when not compiled in debug mode, since bisonRetval won't
                             * be used in the Q_ASSERT_X above. */

     Expression::Ptr result(info->queryBody);

     if(!result)
     {
         context->error(QtXmlPatterns::tr("A library module cannot be evaluated "
                                          "directly. It must be imported from a "
                                          "main module."),
                        ReportContext::XPST0003,
                        QSourceLocation(queryURI, 1, 1));
     }

     /* Optimization: I think many things are done in the wrong order below. We
      * probably want everything typechecked before compressing, since we can
      * have references all over the place(variable references, template
      * invocations, function callsites). This could even be a source to bugs.
      */

     /* Here, we type check user declared functions and global variables. This
      * means that variables and functions that are not used are type
      * checked(which they otherwise wouldn't have been), and those which are
      * used, are type-checked twice, unfortunately. */

     const bool hasExternalFocus = context->contextItemType();

     if(lang == QXmlQuery::XSLT20)
     {
         /* Bind xsl:call-template instructions to their template bodies.
          *
          * We do this before type checking and compressing them, because a
          * CallTemplate obviously needs its template before being compressed.
          *
          * Also, we do this before type checking and compressing user
          * functions, since they can contain template call sites.
          */
         for(int i = 0; i < info->templateCalls.count(); ++i)
         {
             CallTemplate *const site = info->templateCalls.at(i)->as<CallTemplate>();
             const QXmlName targetName(site->name());
             const Template::Ptr t(info->namedTemplates.value(targetName));

             if(t)
                 site->setTemplate(t);
             else
             {
                 context->error(QtXmlPatterns::tr("No template by name %1 exists.").arg(formatKeyword(context->namePool(), targetName)),
                                ReportContext::XTSE0650,
                                site);
             }
         }
     }

     /* Type check and compress user functions. */
     {
         const UserFunction::List::const_iterator end(info->userFunctions.constEnd());
         UserFunction::List::const_iterator it(info->userFunctions.constBegin());

         /* If the query has a focus(which is common, in the case of a
          * stylesheet), we must ensure that the focus isn't visible in the
          * function body. */
         StaticContext::Ptr effectiveContext;

         if(hasExternalFocus)
         {
             effectiveContext = StaticContext::Ptr(new StaticFocusContext(ItemType::Ptr(),
                                                                          context));
         }
         else
             effectiveContext = context;

         for(; it != end; ++it)
         {
             pDebug() << "-----      User Function Typecheck      -----";
             registerLastPath((*it)->body());

             /* We will most likely call body()->typeCheck() again, once for
              * each callsite. That is, it will be called from
              * UserFunctionCallsite::typeCheck(), which will be called
              * indirectly when we check the query body. */
             const Expression::Ptr typeCheck((*it)->body()->typeCheck(effectiveContext,
                                                                      (*it)->signature()->returnType()));
             /* We don't have to call (*it)->setBody(typeCheck) here since it's
              * only used directly below. */
             processTreePass(typeCheck, UserFunctionTypeCheck);
             pDebug() << "------------------------------";

             pDebug() << "-----      User Function Compress      -----";
             const Expression::Ptr comp(typeCheck->compress(effectiveContext));
             (*it)->setBody(comp);
             processTreePass(comp, UserFunctionCompression);
             pDebug() << "------------------------------";
         }
     }

     /* Type check and compress global variables. */
     {
         const VariableDeclaration::Stack::const_iterator vend(info->variables.constEnd());
         VariableDeclaration::Stack::const_iterator vit(info->variables.constBegin());
         for(; vit != vend; ++vit)
         {
             Q_ASSERT(*vit);
             /* This is a bit murky, the global variable will have it
              * Expression::typeCheck() function called from all its references,
              * but we also want to check it here globally, so we do
              * typechecking using a proper focus. */
             if((*vit)->type == VariableDeclaration::ExternalVariable)
                 continue;

             pDebug() << "-----      Global Variable Typecheck      -----";
             Q_ASSERT((*vit)->expression());
             /* We supply ZeroOrMoreItems, meaning the variable can evaluate to anything. */
             // FIXME which is a source to bugs
             // TODO What about compressing variables?
             const Expression::Ptr
             nev((*vit)->expression()->typeCheck(context, CommonSequenceTypes::ZeroOrMoreItems));
             processTreePass(nev, GlobalVariableTypeCheck);
             pDebug() << "------------------------------";
         }
     }

     /* Do all tests specific to XSL-T. */
     if(lang == QXmlQuery::XSLT20)
     {
         /* Type check and compress named templates. */
         {
             pDebug() << "Have " << info->namedTemplates.count() << "named templates";

             for (auto it = info->namedTemplates.cbegin(), end = info->namedTemplates.cend(); it != end; ++it) {
                 processNamedTemplate(it.key(), it.value()->body, TemplateInitial);

                 it.value()->body = it.value()->body->typeCheck(context, CommonSequenceTypes::ZeroOrMoreItems);
                 processNamedTemplate(it.key(), it.value()->body, TemplateTypeCheck);

                 it.value()->body = it.value()->body->compress(context);
                 processNamedTemplate(it.key(), it.value()->body, TemplateCompress);

                 it.value()->compileParameters(context);
             }
         }

         /* Type check and compress template rules. */
         {

             /* Since a pattern can exist of AxisStep, its typeCheck() stage
              * requires a focus. In the case that we're invoked with a name but
              * no focus, this will yield a compile error, unless we declare a
              * focus manually. This only needs to be done for the pattern
              * expression, since the static type of the pattern is used as the
              * static type for the focus of the template body. */
             StaticContext::Ptr patternContext;
             if(hasExternalFocus)
                 patternContext = context;
             else
                 patternContext = StaticContext::Ptr(new StaticFocusContext(BuiltinTypes::node, context));

             /* For each template pattern. */
             for (auto it = info->templateRules.cbegin(), end = info->templateRules.cend(); it != end; ++it) {
                 const TemplateMode::Ptr &mode = it.value();
                 const int len = mode->templatePatterns.count();
                 TemplatePattern::ID currentTemplateID = -1;
                 bool hasDoneItOnce = false;

                 /* For each template pattern. */
                 for(int i = 0; i < len; ++i)
                 {
                     /* We can't use references for these two members, since we
                      * assign to them. */
                     const TemplatePattern::Ptr &pattern = mode->templatePatterns.at(i);
                     Expression::Ptr matchPattern(pattern->matchPattern());

                     processTemplateRule(pattern->templateTarget()->body,
                                         pattern, mode->name(), TemplateInitial);

                     matchPattern = matchPattern->typeCheck(patternContext, CommonSequenceTypes::ZeroOrMoreItems);
                     matchPattern = matchPattern->compress(patternContext);
                     pattern->setMatchPattern(matchPattern);

                     if(currentTemplateID == -1 && hasDoneItOnce)
                     {
                         currentTemplateID = pattern->id();
                         continue;
                     }
                     else if(currentTemplateID == pattern->id() && hasDoneItOnce)
                     {
                         hasDoneItOnce = false;
                         continue;
                     }

                     hasDoneItOnce = true;
                     currentTemplateID = pattern->id();
                     Expression::Ptr body(pattern->templateTarget()->body);

                     /* Patterns for a new template has started, we must
                      * deal with the body & parameters. */
                     {
                         /* TODO type is wrong, it has to be the union of all
                          * patterns. */
                         const StaticContext::Ptr focusContext(new StaticFocusContext(matchPattern->staticType()->itemType(),
                                                                                      context));
                         body = body->typeCheck(focusContext, CommonSequenceTypes::ZeroOrMoreItems);

                         pattern->templateTarget()->compileParameters(focusContext);
                     }

                     processTemplateRule(body, pattern, mode->name(), TemplateTypeCheck);

                     body = body->compress(context);

                     pattern->templateTarget()->body = body;
                     processTemplateRule(body, pattern, mode->name(), TemplateCompress);
                 }

                 mode->finalize();
             }
         }

         /* Add templates in mode #all to all other modes.
          *
          * We do this after the templates has been typechecked and compressed,
          * since otherwise it will be done N times for the built-in templates,
          * where N is the count of different templates, instead of once. */
         {
             const QXmlName nameModeAll(QXmlName(StandardNamespaces::InternalXSLT,
                                                 StandardLocalNames::all));
             const TemplateMode::Ptr &modeAll = info->templateRules[nameModeAll];

             Q_ASSERT_X(modeAll, Q_FUNC_INFO,
                        "We should at least have the builtin templates.");
             for (auto it = info->templateRules.cbegin(), end = info->templateRules.cend(); it != end; ++it) {
                 /* Don't add mode #all to mode #all. */
                 if(it.key()  == nameModeAll)
                     continue;

                 it.value()->addMode(modeAll);
             }
         }
     }

     /* Type check and compress the query body. */
     {
         pDebug() << "----- Initial AST build. -----";
         processTreePass(result, QueryBodyInitial);
         pDebug() << "------------------------------";

         pDebug() << "-----     Type Check     -----";
         registerLastPath(result);
         result->rewrite(result, result->typeCheck(context, requiredType), context);
         processTreePass(result, QueryBodyTypeCheck);
         pDebug() << "------------------------------";

         pDebug() << "-----      Compress      -----";
         result->rewrite(result, result->compress(context), context);
         processTreePass(result, QueryBodyCompression);
         pDebug() << "------------------------------";
     }

     return result;
 }

 void ExpressionFactory::registerLastPath(const Expression::Ptr &operand)
 {
     OperandsIterator it(operand, OperandsIterator::IncludeParent);
     Expression::Ptr next(it.next());

     while(next)
     {
         if(next->is(Expression::IDPath))
         {
             next->as<Path>()->setLast();
             next = it.skipOperands();
         }
         else
             next = it.next();
     }
 }

 void ExpressionFactory::processTreePass(const Expression::Ptr &,
                                         const CompilationStage)
 {
 }

 void ExpressionFactory::processTemplateRule(const Expression::Ptr &body,
                                             const TemplatePattern::Ptr &pattern,
                                             const QXmlName &mode,
                                             const TemplateCompilationStage stage)
 {
     Q_UNUSED(body);
     Q_UNUSED(pattern);
     Q_UNUSED(mode);
     Q_UNUSED(stage);
 }

 void ExpressionFactory::processNamedTemplate(const QXmlName &name,
                                              const Expression::Ptr &tree,
                                              const TemplateCompilationStage stage)
 {
     Q_UNUSED(name);
     Q_UNUSED(tree);
     Q_UNUSED(stage);
 }

 } // namespace QPatternist

 QT_END_NAMESPACE
	/****************************************************************************
	**
	** Copyright (C) 2016 The Qt Company Ltd.
	** Contact: https://www.qt.io/licensing/
	**
	** This file is part of the QtXmlPatterns module of the Qt Toolkit.
	**
	** $QT_BEGIN_LICENSE:LGPL$
	** Commercial License Usage
	** Licensees holding valid commercial Qt licenses may use this file in
	** accordance with the commercial license agreement provided with the
	** Software or, alternatively, in accordance with the terms contained in
	** a written agreement between you and The Qt Company. For licensing terms
	** and conditions see https://www.qt.io/terms-conditions. For further
	** information use the contact form at https://www.qt.io/contact-us.
	**
	** GNU Lesser General Public License Usage
	** Alternatively, this file may be used under the terms of the GNU Lesser
	** General Public License version 3 as published by the Free Software
	** Foundation and appearing in the file LICENSE.LGPL3 included in the
	** packaging of this file. Please review the following information to
	** ensure the GNU Lesser General Public License version 3 requirements
	** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
	**
	** GNU General Public License Usage
	** Alternatively, this file may be used under the terms of the GNU
	** General Public License version 2.0 or (at your option) the GNU General
	** Public license version 3 or any later version approved by the KDE Free
	** Qt Foundation. The licenses are as published by the Free Software
	** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
	** included in the packaging of this file. Please review the following
	** information to ensure the GNU General Public License requirements will
	** be met: https://www.gnu.org/licenses/gpl-2.0.html and
	** https://www.gnu.org/licenses/gpl-3.0.html.
	**
	** $QT_END_LICENSE$
	**
	****************************************************************************/

	#include <QBuffer>
	#include <QByteArray>

	#include "qcalltemplate_p.h"
	#include "qcommonsequencetypes_p.h"
	#include "qxmldebug_p.h"
	#include "qexpression_p.h"
	#include "qgenericstaticcontext_p.h"
	#include "qoperandsiterator_p.h"
	#include "qoptimizationpasses_p.h"
	#include "qparsercontext_p.h"
	#include "qpath_p.h"
	#include "qquerytransformparser_p.h"
	#include "qstaticfocuscontext_p.h"
	#include "qtokenrevealer_p.h"
	#include "qxquerytokenizer_p.h"
	#include "qxslttokenizer_p.h"

	#include "qexpressionfactory_p.h"

	QT_BEGIN_NAMESPACE

	namespace QPatternist {

	/**
	* @short The entry point to the parser.
	*
	* @param info supplies the information the parser & scanner
	* needs to create expressions. The created expression, if everything
	* succeeds, can be retrieved via the object @p info points to.
	* @returns non-negative if the parser fails.
	* @see ExpressionFactory::createExpression()
	*/
	extern int XPathparse(QPatternist::ParserContext *const info);

	Expression::Ptr ExpressionFactory::createExpression(const QString &expr,
	const StaticContext::Ptr &context,
	const QXmlQuery::QueryLanguage lang,
	const SequenceType::Ptr &requiredType,
	const QUrl &queryURI,
	const QXmlName &initialTemplateName)
	{
	if(lang == QXmlQuery::XSLT20)
	{
	QByteArray query(expr.toUtf8());
	QBuffer buffer(&query);
	buffer.open(QIODevice::ReadOnly);

	return createExpression(&buffer,
	context,
	lang,
	requiredType,
	queryURI,
	initialTemplateName);
	}
	else
	{
	return createExpression(Tokenizer::Ptr(new XQueryTokenizer(expr, queryURI)),
	context,
	lang,
	requiredType,
	queryURI,
	initialTemplateName);
	}
	}

	Expression::Ptr ExpressionFactory::createExpression(QIODevice *const device,
	const StaticContext::Ptr &context,
	const QXmlQuery::QueryLanguage lang,
	const SequenceType::Ptr &requiredType,
	const QUrl &queryURI,
	const QXmlName &initialTemplateName)
	{
	Q_ASSERT(device);
	Q_ASSERT(device->isReadable());

	Tokenizer::Ptr tokenizer;

	if(lang == QXmlQuery::XSLT20)
	tokenizer = Tokenizer::Ptr(new XSLTTokenizer(device, queryURI, context, context->namePool()));
	else
	tokenizer = Tokenizer::Ptr(new XQueryTokenizer(QString::fromUtf8(device->readAll()), queryURI));

	return createExpression(tokenizer, context, lang, requiredType, queryURI, initialTemplateName);
	}

	Expression::Ptr ExpressionFactory::createExpression(const Tokenizer::Ptr &tokenizer,
	const StaticContext::Ptr &context,
	const QXmlQuery::QueryLanguage lang,
	const SequenceType::Ptr &requiredType,
	const QUrl &queryURI,
	const QXmlName &initialTemplateName)
	{
	Q_ASSERT(context);
	Q_ASSERT(requiredType);
	Q_ASSERT(queryURI.isValid());

	Tokenizer::Ptr effectiveTokenizer(tokenizer);
	#ifdef Patternist_DEBUG
	effectiveTokenizer = Tokenizer::Ptr(new TokenRevealer(queryURI, tokenizer));
	#endif

	OptimizationPasses::Coordinator::init();

	const ParserContext::Ptr info(new ParserContext(context, lang, effectiveTokenizer.data()));
	info->initialTemplateName = initialTemplateName;

	effectiveTokenizer->setParserContext(info);

	const int bisonRetval = QPatternist::XPathparse(info.data());

	Q_ASSERT_X(bisonRetval == 0, Q_FUNC_INFO,
	"We shouldn't be able to get an error, because we throw exceptions.");
	Q_UNUSED(bisonRetval); /* Needed when not compiled in debug mode, since bisonRetval won't
	* be used in the Q_ASSERT_X above. */

	Expression::Ptr result(info->queryBody);

	if(!result)
	{
	context->error(QtXmlPatterns::tr("A library module cannot be evaluated "
	"directly. It must be imported from a "
	"main module."),
	ReportContext::XPST0003,
	QSourceLocation(queryURI, 1, 1));
	}

	/* Optimization: I think many things are done in the wrong order below. We
	* probably want everything typechecked before compressing, since we can
	* have references all over the place(variable references, template
	* invocations, function callsites). This could even be a source to bugs.
	*/

	/* Here, we type check user declared functions and global variables. This
	* means that variables and functions that are not used are type
	* checked(which they otherwise wouldn't have been), and those which are
	* used, are type-checked twice, unfortunately. */

	const bool hasExternalFocus = context->contextItemType();

	if(lang == QXmlQuery::XSLT20)
	{
	/* Bind xsl:call-template instructions to their template bodies.
	*
	* We do this before type checking and compressing them, because a
	* CallTemplate obviously needs its template before being compressed.
	*
	* Also, we do this before type checking and compressing user
	* functions, since they can contain template call sites.
	*/
	for(int i = 0; i < info->templateCalls.count(); ++i)
	{
	CallTemplate *const site = info->templateCalls.at(i)->as<CallTemplate>();
	const QXmlName targetName(site->name());
	const Template::Ptr t(info->namedTemplates.value(targetName));

	if(t)
	site->setTemplate(t);
	else
	{
	context->error(QtXmlPatterns::tr("No template by name %1 exists.").arg(formatKeyword(context->namePool(), targetName)),
	ReportContext::XTSE0650,
	site);
	}
	}
	}

	/* Type check and compress user functions. */
	{
	const UserFunction::List::const_iterator end(info->userFunctions.constEnd());
	UserFunction::List::const_iterator it(info->userFunctions.constBegin());

	/* If the query has a focus(which is common, in the case of a
	* stylesheet), we must ensure that the focus isn't visible in the
	* function body. */
	StaticContext::Ptr effectiveContext;

	if(hasExternalFocus)
	{
	effectiveContext = StaticContext::Ptr(new StaticFocusContext(ItemType::Ptr(),
	context));
	}
	else
	effectiveContext = context;

	for(; it != end; ++it)
	{
	pDebug() << "----- User Function Typecheck -----";
	registerLastPath((*it)->body());

	/* We will most likely call body()->typeCheck() again, once for
	* each callsite. That is, it will be called from
	* UserFunctionCallsite::typeCheck(), which will be called
	* indirectly when we check the query body. */
	const Expression::Ptr typeCheck((*it)->body()->typeCheck(effectiveContext,
	(*it)->signature()->returnType()));
	/* We don't have to call (*it)->setBody(typeCheck) here since it's
	* only used directly below. */
	processTreePass(typeCheck, UserFunctionTypeCheck);
	pDebug() << "------------------------------";

	pDebug() << "----- User Function Compress -----";
	const Expression::Ptr comp(typeCheck->compress(effectiveContext));
	(*it)->setBody(comp);
	processTreePass(comp, UserFunctionCompression);
	pDebug() << "------------------------------";
	}
	}

	/* Type check and compress global variables. */
	{
	const VariableDeclaration::Stack::const_iterator vend(info->variables.constEnd());
	VariableDeclaration::Stack::const_iterator vit(info->variables.constBegin());
	for(; vit != vend; ++vit)
	{
	Q_ASSERT(*vit);
	/* This is a bit murky, the global variable will have it
	* Expression::typeCheck() function called from all its references,
	* but we also want to check it here globally, so we do
	* typechecking using a proper focus. */
	if((*vit)->type == VariableDeclaration::ExternalVariable)
	continue;

	pDebug() << "----- Global Variable Typecheck -----";
	Q_ASSERT((*vit)->expression());
	/* We supply ZeroOrMoreItems, meaning the variable can evaluate to anything. */
	// FIXME which is a source to bugs
	// TODO What about compressing variables?
	const Expression::Ptr
	nev((*vit)->expression()->typeCheck(context, CommonSequenceTypes::ZeroOrMoreItems));
	processTreePass(nev, GlobalVariableTypeCheck);
	pDebug() << "------------------------------";
	}
	}

	/* Do all tests specific to XSL-T. */
	if(lang == QXmlQuery::XSLT20)
	{
	/* Type check and compress named templates. */
	{
	pDebug() << "Have " << info->namedTemplates.count() << "named templates";

	for (auto it = info->namedTemplates.cbegin(), end = info->namedTemplates.cend(); it != end; ++it) {
	processNamedTemplate(it.key(), it.value()->body, TemplateInitial);

	it.value()->body = it.value()->body->typeCheck(context, CommonSequenceTypes::ZeroOrMoreItems);
	processNamedTemplate(it.key(), it.value()->body, TemplateTypeCheck);

	it.value()->body = it.value()->body->compress(context);
	processNamedTemplate(it.key(), it.value()->body, TemplateCompress);

	it.value()->compileParameters(context);
	}
	}

	/* Type check and compress template rules. */
	{

	/* Since a pattern can exist of AxisStep, its typeCheck() stage
	* requires a focus. In the case that we're invoked with a name but
	* no focus, this will yield a compile error, unless we declare a
	* focus manually. This only needs to be done for the pattern
	* expression, since the static type of the pattern is used as the
	* static type for the focus of the template body. */
	StaticContext::Ptr patternContext;
	if(hasExternalFocus)
	patternContext = context;
	else
	patternContext = StaticContext::Ptr(new StaticFocusContext(BuiltinTypes::node, context));

	/* For each template pattern. */
	for (auto it = info->templateRules.cbegin(), end = info->templateRules.cend(); it != end; ++it) {
	const TemplateMode::Ptr &mode = it.value();
	const int len = mode->templatePatterns.count();
	TemplatePattern::ID currentTemplateID = -1;
	bool hasDoneItOnce = false;

	/* For each template pattern. */
	for(int i = 0; i < len; ++i)
	{
	/* We can't use references for these two members, since we
	* assign to them. */
	const TemplatePattern::Ptr &pattern = mode->templatePatterns.at(i);
	Expression::Ptr matchPattern(pattern->matchPattern());

	processTemplateRule(pattern->templateTarget()->body,
	pattern, mode->name(), TemplateInitial);

	matchPattern = matchPattern->typeCheck(patternContext, CommonSequenceTypes::ZeroOrMoreItems);
	matchPattern = matchPattern->compress(patternContext);
	pattern->setMatchPattern(matchPattern);

	if(currentTemplateID == -1 && hasDoneItOnce)
	{
	currentTemplateID = pattern->id();
	continue;
	}
	else if(currentTemplateID == pattern->id() && hasDoneItOnce)
	{
	hasDoneItOnce = false;
	continue;
	}

	hasDoneItOnce = true;
	currentTemplateID = pattern->id();
	Expression::Ptr body(pattern->templateTarget()->body);

	/* Patterns for a new template has started, we must
	* deal with the body & parameters. */
	{
	/* TODO type is wrong, it has to be the union of all
	* patterns. */
	const StaticContext::Ptr focusContext(new StaticFocusContext(matchPattern->staticType()->itemType(),
	context));
	body = body->typeCheck(focusContext, CommonSequenceTypes::ZeroOrMoreItems);

	pattern->templateTarget()->compileParameters(focusContext);
	}

	processTemplateRule(body, pattern, mode->name(), TemplateTypeCheck);

	body = body->compress(context);

	pattern->templateTarget()->body = body;
	processTemplateRule(body, pattern, mode->name(), TemplateCompress);
	}

	mode->finalize();
	}
	}

	/* Add templates in mode #all to all other modes.
	*
	* We do this after the templates has been typechecked and compressed,
	* since otherwise it will be done N times for the built-in templates,
	* where N is the count of different templates, instead of once. */
	{
	const QXmlName nameModeAll(QXmlName(StandardNamespaces::InternalXSLT,
	StandardLocalNames::all));
	const TemplateMode::Ptr &modeAll = info->templateRules[nameModeAll];

	Q_ASSERT_X(modeAll, Q_FUNC_INFO,
	"We should at least have the builtin templates.");
	for (auto it = info->templateRules.cbegin(), end = info->templateRules.cend(); it != end; ++it) {
	/* Don't add mode #all to mode #all. */
	if(it.key() == nameModeAll)
	continue;

	it.value()->addMode(modeAll);
	}
	}
	}

	/* Type check and compress the query body. */
	{
	pDebug() << "----- Initial AST build. -----";
	processTreePass(result, QueryBodyInitial);
	pDebug() << "------------------------------";

	pDebug() << "----- Type Check -----";
	registerLastPath(result);
	result->rewrite(result, result->typeCheck(context, requiredType), context);
	processTreePass(result, QueryBodyTypeCheck);
	pDebug() << "------------------------------";

	pDebug() << "----- Compress -----";
	result->rewrite(result, result->compress(context), context);
	processTreePass(result, QueryBodyCompression);
	pDebug() << "------------------------------";
	}

	return result;
	}

	void ExpressionFactory::registerLastPath(const Expression::Ptr &operand)
	{
	OperandsIterator it(operand, OperandsIterator::IncludeParent);
	Expression::Ptr next(it.next());

	while(next)
	{
	if(next->is(Expression::IDPath))
	{
	next->as<Path>()->setLast();
	next = it.skipOperands();
	}
	else
	next = it.next();
	}
	}

	void ExpressionFactory::processTreePass(const Expression::Ptr &,
	const CompilationStage)
	{
	}

	void ExpressionFactory::processTemplateRule(const Expression::Ptr &body,
	const TemplatePattern::Ptr &pattern,
	const QXmlName &mode,
	const TemplateCompilationStage stage)
	{
	Q_UNUSED(body);
	Q_UNUSED(pattern);
	Q_UNUSED(mode);
	Q_UNUSED(stage);
	}

	void ExpressionFactory::processNamedTemplate(const QXmlName &name,
	const Expression::Ptr &tree,
	const TemplateCompilationStage stage)
	{
	Q_UNUSED(name);
	Q_UNUSED(tree);
	Q_UNUSED(stage);
	}

	} // namespace QPatternist

	QT_END_NAMESPACE