The central entry point for compiling expressions. More...

#include <qexpressionfactory_p.h>

Inheritance diagram for QPatternist::ExpressionFactory:

Public Types
enum	CompilationStage { QueryBodyInitial = 1, QueryBodyTypeCheck = 1 << 1, QueryBodyCompression = 1 << 2, UserFunctionTypeCheck = 1 << 3, UserFunctionCompression = 1 << 4, GlobalVariableTypeCheck = 1 << 5 }

typedef QExplicitlySharedDataPointer< ExpressionFactory >	Ptr

Public Functions
virtual Expression::Ptr	createExpression (const QString &expr, const StaticContext::Ptr &context, const QXmlQuery::QueryLanguage lang, const SequenceType::Ptr &requiredType, const QUrl &queryURI, const QXmlName &initialTemplateName)

virtual Expression::Ptr	createExpression (QIODevice *const device, const StaticContext::Ptr &context, const QXmlQuery::QueryLanguage lang, const SequenceType::Ptr &requiredType, const QUrl &queryURI, const QXmlName &initialTemplateName)

	ExpressionFactory ()
	This constructor cannot be synthesized since we use the Q_DISABLE_COPY macro. More...

virtual	~ExpressionFactory ()

Public Functions inherited from QSharedData
	QSharedData ()
	Constructs a QSharedData object with a reference count of 0. More...

	QSharedData (const QSharedData &)
	Constructs a QSharedData object with reference count 0. More...

Static Public Functions
static void	registerLastPath (const Expression::Ptr &operand)

Protected Types
enum	TemplateCompilationStage { TemplateInitial = 1, TemplateTypeCheck = 1 << 1, TemplateCompress = 1 << 2 }

Protected Functions
Expression::Ptr	createExpression (const Tokenizer::Ptr &tokenizer, const StaticContext::Ptr &context, const QXmlQuery::QueryLanguage lang, const SequenceType::Ptr &requiredType, const QUrl &queryURI, const QXmlName &initialTemplateName)

virtual void	processNamedTemplate (const QXmlName &name, const Expression::Ptr &tree, const TemplateCompilationStage stage)

virtual void	processTemplateRule (const Expression::Ptr &body, const TemplatePattern::Ptr &pattern, const QXmlName &mode, const TemplateCompilationStage stage)

virtual void	processTreePass (const Expression::Ptr &tree, const CompilationStage stage)

Additional Inherited Members
Public Variables inherited from QSharedData
QAtomicInt	ref

Detailed Description

The central entry point for compiling expressions.

Author: Frans Englich frans.nosp@m..eng.nosp@m.lich@.nosp@m.noki.nosp@m.a.com

Definition at line 77 of file qexpressionfactory_p.h.

Typedefs

◆ Ptr

typedef QExplicitlySharedDataPointer<ExpressionFactory> QPatternist::ExpressionFactory::Ptr

Definition at line 80 of file qexpressionfactory_p.h.

Enumerations

◆ CompilationStage

enum QPatternist::ExpressionFactory::CompilationStage

Enumerator
QueryBodyInitial
QueryBodyTypeCheck
QueryBodyCompression
UserFunctionTypeCheck
UserFunctionCompression
GlobalVariableTypeCheck

Definition at line 94 of file qexpressionfactory_p.h.

         {
             QueryBodyInitial        = 1,
             QueryBodyTypeCheck      = 1 << 1,
             QueryBodyCompression    = 1 << 2,
             UserFunctionTypeCheck   = 1 << 3,
             UserFunctionCompression = 1 << 4,
             GlobalVariableTypeCheck = 1 << 5
         };

◆ TemplateCompilationStage

enum QPatternist::ExpressionFactory::TemplateCompilationStage

protected

Enumerator
TemplateInitial
TemplateTypeCheck
TemplateCompress

Definition at line 142 of file qexpressionfactory_p.h.

         {
             TemplateInitial         = 1,
             TemplateTypeCheck       = 1 << 1,
             TemplateCompress        = 1 << 2
         };

Constructors and Destructors

◆ ExpressionFactory()

QPatternist::ExpressionFactory::ExpressionFactory ( )

inline

This constructor cannot be synthesized since we use the Q_DISABLE_COPY macro.

Definition at line 86 of file qexpressionfactory_p.h.

87 {

88 }

◆ ~ExpressionFactory()

virtual QPatternist::ExpressionFactory::~ExpressionFactory ( )

inlinevirtual

Definition at line 90 of file qexpressionfactory_p.h.

91 {

92 }

Functions

◆ createExpression() [1/3]

Expression::Ptr QPatternist::ExpressionFactory::createExpression	(	const QString &	expr,
		const StaticContext::Ptr &	context,
		const QXmlQuery::QueryLanguage	lang,
		const SequenceType::Ptr &	requiredType,
		const QUrl &	queryURI,
		const QXmlName &	initialTemplateName
	)

virtual

Creates a compiled representation of the XPath expression expr, with Static Context information supplied via context. This is for example whether the expression is an XPath 1.0 or XPath 2.0 expression, or what functions that are available.

requiredType specifies what type results of the evaluating the expression must match. Passing CommonValues::ZeroOrMoreItems allows anything as result, while passing CommonSequenceTypes::EBV means anything but an Effective Boolean Value extractable result is a type error, for example.

Note: An empty expr is an invalid XPath expression. It will be reported as such, but it is neverthless the caller's resonsibility to ensure that it's not that(since it is likely invalid already in the medium it was stored).

Definition at line 77 of file qexpressionfactory.cpp.

 {
     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);
     }
 }

◆ createExpression() [2/3]

Expression::Ptr QPatternist::ExpressionFactory::createExpression	(	QIODevice *const	device,
		const StaticContext::Ptr &	context,
		const QXmlQuery::QueryLanguage	lang,
		const SequenceType::Ptr &	requiredType,
		const QUrl &	queryURI,
		const QXmlName &	initialTemplateName
	)

virtual

Definition at line 108 of file qexpressionfactory.cpp.

Referenced by createExpression().

 {
     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);
 }

◆ createExpression() [3/3]

Expression::Ptr QPatternist::ExpressionFactory::createExpression	(	const Tokenizer::Ptr &	tokenizer,
		const StaticContext::Ptr &	context,
		const QXmlQuery::QueryLanguage	lang,
		const SequenceType::Ptr &	requiredType,
		const QUrl &	queryURI,
		const QXmlName &	initialTemplateName
	)

protected

Definition at line 128 of file qexpressionfactory.cpp.

 {
     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 = 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";
 
             QMutableHashIterator<QXmlName, Template::Ptr> it(info->namedTemplates);
 
             while(it.hasNext())
             {
                 it.next();
                 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. */
         {
             QHashIterator<QXmlName, TemplateMode::Ptr> it(info->templateRules);
 
             /* 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. */
             while(it.hasNext())
             {
                 it.next();
                 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.");
             QHashIterator<QXmlName, TemplateMode::Ptr> it(info->templateRules);
 
             while(it.hasNext())
             {
                 it.next();
 
                 /* 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;
 }

◆ processNamedTemplate()

void QPatternist::ExpressionFactory::processNamedTemplate	(	const QXmlName &	name,
		const Expression::Ptr &	tree,
		const TemplateCompilationStage	stage
	)

protectedvirtual

Definition at line 461 of file qexpressionfactory.cpp.

Referenced by createExpression().

 {
     Q_UNUSED(name);
     Q_UNUSED(tree);
     Q_UNUSED(stage);
 }

◆ processTemplateRule()

void QPatternist::ExpressionFactory::processTemplateRule	(	const Expression::Ptr &	body,
		const TemplatePattern::Ptr &	pattern,
		const QXmlName &	mode,
		const TemplateCompilationStage	stage
	)

protectedvirtual

Definition at line 450 of file qexpressionfactory.cpp.

Referenced by createExpression().

 {
     Q_UNUSED(body);
     Q_UNUSED(pattern);
     Q_UNUSED(mode);
     Q_UNUSED(stage);
 }

◆ processTreePass()

void QPatternist::ExpressionFactory::processTreePass	(	const Expression::Ptr &	tree,
		const CompilationStage	stage
	)

protectedvirtual

This function is called by createExpression() each time after a pass on the AST has been completed. Under a typical compilation this function is thus called three times: after the initial build, after the Expression::typeCheck() stage, and after Expression::compress(). tree is the AST after each pass.

This mechanism is currently used for debugging, since it provides a way of introspecting what the compilation process do to the tree. The current implementation do nothing.

Definition at line 445 of file qexpressionfactory.cpp.

Referenced by createExpression().

447 {

448 }

◆ registerLastPath()

void QPatternist::ExpressionFactory::registerLastPath ( const Expression::Ptr & operand )

static

Finds the last paths of a set of paths(if any) and tells the Path so, such that it can generate the code for checking XPTY0018.

Must be called before typeCheck() is called on the operand, since the typeCheck() uses the information for type checking.

Definition at line 428 of file qexpressionfactory.cpp.

Referenced by createExpression(), and QPatternist::yyparse().

 {
     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();
     }
 }

The documentation for this class was generated from the following files:

/src/xmlpatterns/expr/qexpressionfactory_p.h
/src/xmlpatterns/expr/qexpressionfactory.cpp

Public Types

Public Functions

Static Public Functions

Protected Types

Protected Functions

Additional Inherited Members

Detailed Description

Typedefs

◆ Ptr

Enumerations

◆ CompilationStage

◆ TemplateCompilationStage

Constructors and Destructors

◆ ExpressionFactory()

◆ ~ExpressionFactory()

Functions

◆ createExpression() [1/3]

◆ createExpression() [2/3]

◆ createExpression() [3/3]

◆ processNamedTemplate()

◆ processTemplateRule()

◆ processTreePass()

◆ registerLastPath()