Base class for all AST nodes in an XPath/XQuery/XSL-T expression. More...

#include <qexpression_p.h>

Inheritance diagram for QPatternist::Expression:

Public Types
typedef QExplicitlySharedDataPointer< const Expression >	ConstPtr
	A smart pointer wrapping `const` Expression instances. More...

enum	ID { IDBooleanValue = 1, IDCountFN, IDEmptyFN, IDExistsFN, IDExpressionSequence, IDGeneralComparison, IDIfThenClause, IDIgnorableExpression, IDIntegerValue, IDPositionFN, IDStringValue, IDValueComparison, IDRangeVariableReference, IDContextItem, IDUserFunctionCallsite, IDExpressionVariableReference, IDAttributeConstructor, IDUpperCaseFN, IDLowerCaseFN, IDFirstItemPredicate, IDEmptySequence, IDReturnOrderBy, IDLetClause, IDForClause, IDPath, IDNamespaceConstructor, IDArgumentReference, IDGenericPredicate, IDAxisStep, IDFloat, IDCombineNodes, IDUnresolvedVariableReference, IDCardinalityVerifier }

typedef QList< Expression::Ptr >	List

typedef QFlags< Property >	Properties

enum	Property { UseContextItem = 1, DisableElimination = 1 << 1, IsEvaluated = 1 << 2, DisableTypingDeduction = 1 << 3, EmptynessFollowsChild = 1 << 4, RewriteToEmptyOnEmpty = 1 << 5, RequiresFocus = 1 << 6, AffectsOrderOnly = 1 << 7, RequiresContextItem = (1 << 8) \| RequiresFocus, CreatesFocusForLast = 1 << 9, LastOperandIsCollation = 1 << 10, DependsOnLocalVariable = (1 << 11) \| DisableElimination, EvaluationCacheRedundant = (1 << 12), IsNodeConstructor = 1 << 13, RequiresCurrentItem = 1 << 14 }

typedef QExplicitlySharedDataPointer< Expression >	Ptr
	A smart pointer wrapping mutable Expression instances. More...

typedef ::QAbstractXmlForwardIterator< Expression::Ptr >	QAbstractXmlForwardIterator

typedef QVector< Expression::Ptr >	Vector

Public Functions
virtual ExpressionVisitorResult::Ptr	accept (const ExpressionVisitor::Ptr &visitor) const =0

virtual const SourceLocationReflection *	actualReflection () const
	Returns `this`. More...

virtual void	announceFocusType (const ItemType::Ptr &itemType)

virtual Expression::Ptr	compress (const StaticContext::Ptr &context)

Properties	deepProperties () const
	Computes the union of properties for this Expression and all its descending children. More...

virtual Properties	dependencies () const

virtual QString	description () const

virtual bool	evaluateEBV (const DynamicContext::Ptr &context) const

virtual Item::Iterator::Ptr	evaluateSequence (const DynamicContext::Ptr &context) const

virtual Item	evaluateSingleton (const DynamicContext::Ptr &context) const

virtual void	evaluateToSequenceReceiver (const DynamicContext::Ptr &context) const

virtual ItemType::Ptr	expectedContextItemType () const

virtual SequenceType::List	expectedOperandTypes () const =0

	Expression ()

bool	has (const Property prop) const

bool	hasDependency (const Property prop) const

virtual ID	id () const

bool	is (const ID id) const

bool	isEvaluated () const

virtual ItemType::Ptr	newFocusType () const

virtual Expression::List	operands () const =0

virtual QList< QExplicitlySharedDataPointer< OptimizationPass > >	optimizationPasses () const

virtual PatternPriority	patternPriority () const

virtual Properties	properties () const

const Expression::Ptr &	rewrite (const Expression::Ptr &to, const StaticContext::Ptr &context) const
	Rewrites this Expression to `to`, and return `to`. More...

virtual void	setOperands (const Expression::List &operands)=0

virtual SequenceType::Ptr	staticType () const =0

virtual Expression::Ptr	typeCheck (const StaticContext::Ptr &context, const SequenceType::Ptr &reqType)

virtual	~Expression ()

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...

Public Functions inherited from QPatternist::CppCastingHelper< Expression >
const TCastTarget *	as () const

TCastTarget *	as ()

Public Functions inherited from QPatternist::SourceLocationReflection
virtual QSourceLocation	sourceLocation () const

	SourceLocationReflection ()

virtual	~SourceLocationReflection ()

Static Public Functions
static void	rewrite (Expression::Ptr &old, const Expression::Ptr &New, const StaticContext::Ptr &context)

Protected Functions
virtual bool	compressOperands (const StaticContext::Ptr &)=0

void	typeCheckOperands (const StaticContext::Ptr &context)

Protected Functions inherited from QPatternist::CppCastingHelper< Expression >
	CppCastingHelper ()

Private Functions
Expression::Ptr	constantPropagate (const StaticContext::Ptr &context) const
	Performs constant propagation, also called constant folding, on this expression. More...

StaticContext::Ptr	finalizeStaticContext (const StaticContext::Ptr &context) const

Static Private Functions
static Expression::Ptr	invokeOptimizers (const Expression::Ptr &expr, const StaticContext::Ptr &context)

Additional Inherited Members
Public Variables inherited from QSharedData
QAtomicInt	ref

Detailed Description

Base class for all AST nodes in an XPath/XQuery/XSL-T expression.

Expression Compilation

The process of creating an Expression

The initial step of creating an internal representation(in some circles called an IR tree) of the XPath string follows classic compiler design: a scanner is invoked, resulting in tokens, which sub-sequently are consumed by a parser which groups the tokens into rules, resulting in the creation of Abstract Syntax Tree(AST) nodes that are arranged in a hierarchical structure similar to the EBNF.

More specifically, ExpressionFactory::createExpression() is called with a pointer to a static context, and the string for the expression. This is subsequently tokenized by a Flex scanner. Mistakes detected at this stage is syntax errors, as well as a few semantical errors. Syntax errors can be divided in two types:

- The scanner detects it. An example is the expression "23Eb3" which
is not a valid number literal, or "1prefix:my-element" which is not a
valid QName.
- The parser detects it. This means a syntax error at a
higher level, that a group of tokens couldn't be reduced to a
rule(expression). An example is the expression "if(a = b) 'match' else
'no match'"; the tokenizer would handle it fine, but the parser would
fail because the tokens could not be reduced to a rule due to the token
for the "then" word was missing.

Apart from the syntax errors, the actions in the parser also detects errors when creating the corresponding expressions. This is for example that no namespace binding for a prefix could be found, or that a function call was used which no function implementation could be found for.

When the parser has finished, the result is an AST. That is, a hierarchical structure consisting of Expression sub-classes. The individual expressions haven't at this point done anything beyond receiving their child-expressions(if any), and hence reminds of a "construction scaffold". In other words, a tree for the expression 'string' + 1 and xs:date('2001-03-13') could have been created, even if that expression contains errors(one can't add a xs:integer to a xs:string, and the Effective Boolean Value cannot be extracted for date types).

Type Checking

After the AST creation, ExpressionFactory::createExpression continues with calling the AST node(which is an Expression instance)'s typeCheck() function. This step ensures that the static types of the operands matches the operators, and in the cases where it doesn't, modifies the AST such that the necessary conversions are done – if possible, otherwise the result is a type error.

This step corresponds roughly to what 2.2.3.1 Static Analysis Phase labels operation tree normalization; step SQ5.

Compressing -- Optimization and Fixup

The last step is calling compress(). This function is not called 'optimize', 'simplify' or the like, because although it performs all optimization, it also involves mandatory stages.

One such is const folding, which while being an efficient optimization, also is a necessity for many XSL-T constructs. Another important step is that functions which had an evaluation dependency on the static context(as opposed to the dynamic) performs their "fixup".

In other words, this stage potentially performs AST re-writes. For example, the expression 3 + 3, concat('foo', '-', 'bar'), true() and false() would result in an AST corresponding to 6, 'foo-bar', false(). This process is done backwards; each expression asks its operands to compress before it performs its own compression(and so forth, until the root expression's call returns to the caller).

See also: XML Path Language (XPath) 2.0, 2.3.4 Errors and Optimization; XML Path Language (XPath) 2.0, 2.2.3 Expression Processing; Building a Tokenizer for XPath or XQuery; ExpressionFactory

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

Definition at line 165 of file qexpression_p.h.

Typedefs

◆ ConstPtr

typedef QExplicitlySharedDataPointer<const Expression> QPatternist::Expression::ConstPtr

A smart pointer wrapping const Expression instances.

Definition at line 178 of file qexpression_p.h.

◆ List

typedef QList<Expression::Ptr> QPatternist::Expression::List

A list of Expression instances, each wrapped in a smart pointer.

Definition at line 183 of file qexpression_p.h.

◆ Properties

typedef QFlags<Property> QPatternist::Expression::Properties

A QFlags template for type-safe handling of ExpressionProperty values. If Expression::Property flags needs to be stored in a class, declared the variable to be of type Expression::Properties.

See also: QFlags

Definition at line 358 of file qexpression_p.h.

◆ Ptr

typedef QExplicitlySharedDataPointer<Expression> QPatternist::Expression::Ptr

A smart pointer wrapping mutable Expression instances.

Definition at line 173 of file qexpression_p.h.

◆ QAbstractXmlForwardIterator

typedef :: QAbstractXmlForwardIterator<Expression::Ptr> QPatternist::Expression::QAbstractXmlForwardIterator

Definition at line 191 of file qexpression_p.h.

◆ Vector

typedef QVector<Expression::Ptr> QPatternist::Expression::Vector

A vector of Expression instances, each wrapped in a smart pointer.

Definition at line 188 of file qexpression_p.h.

Enumerations

◆ ID

enum QPatternist::Expression::ID

Enumerators that identifies Expression sub-classes.

See also: id()

Enumerator
IDBooleanValue	Identifies Boolean.
IDCountFN	Identifies CountFN.
IDEmptyFN	Identifies EmptyFN.
IDExistsFN	Identifies ExistsFN.
IDExpressionSequence	Identifies ExpressionSequence and LiteralSequence.
IDGeneralComparison	Identifies GeneralComparison.
IDIfThenClause	Identifies IfThenClause.
IDIgnorableExpression	Identifies nothing in particular. The default implementation of id() returns this, which is suitable for Expression instances which never needs to be identified in this aspect.
IDIntegerValue	Identifies Integer.
IDPositionFN	Identifies PositionFN.
IDStringValue	Identifies AtomicString, AnyURI, and UntypedAtomic.
IDValueComparison	Identifies ValueComparison.
IDRangeVariableReference	Identifies VariableReference.
IDContextItem	Identifies ContextItem.
IDUserFunctionCallsite	Identifies UserFunctionCallsite.
IDExpressionVariableReference	Identifies ExpressionVariableReference.
IDAttributeConstructor	Identifies ExpressionVariableReference.
IDUpperCaseFN	Identifies UpperCaseFN.
IDLowerCaseFN	Identifies LowerCaseFN.
IDFirstItemPredicate	Identifies FirstItemPredicate.
IDEmptySequence
IDReturnOrderBy
IDLetClause
IDForClause
IDPath
IDNamespaceConstructor
IDArgumentReference
IDGenericPredicate
IDAxisStep
IDFloat	A literal which is either `xs:float` or `xs:double`.
IDCombineNodes
IDUnresolvedVariableReference
IDCardinalityVerifier

Definition at line 365 of file qexpression_p.h.

         {
             IDBooleanValue = 1,
 
             IDCountFN,
 
             IDEmptyFN,
 
             IDExistsFN,
 
             IDExpressionSequence,
 
             IDGeneralComparison,
 
             IDIfThenClause,
 
             IDIgnorableExpression,
 
             IDIntegerValue,
 
             IDPositionFN,
 
             IDStringValue,
 
             IDValueComparison,
 
             IDRangeVariableReference,
 
             IDContextItem,
 
             IDUserFunctionCallsite,
 
             IDExpressionVariableReference,
 
             IDAttributeConstructor,
 
             IDUpperCaseFN,
 
             IDLowerCaseFN,
 
             IDFirstItemPredicate,
             IDEmptySequence,
             IDReturnOrderBy,
             IDLetClause,
             IDForClause,
             IDPath,
             IDNamespaceConstructor,
             IDArgumentReference,
             IDGenericPredicate,
             IDAxisStep,
 
             IDFloat,
 
             IDCombineNodes,
             IDUnresolvedVariableReference,
             IDCardinalityVerifier
         };

◆ Property

enum QPatternist::Expression::Property

Enum flags describing the characteristics of the expression.

See also: Expression::properties()

Enumerator
UseContextItem	This flag applies for functions, and results in the expression `.` being appended to its operands if its operand count is lower than the maximum amount of arguments. In effect, it result in a modification of the function's arguments to have appended the context item. One function which has this property is `fn:number()`. See also ContextItem XQuery 1.0 and XPath 2.0 Functions and Operators, 1.3 Function Signatures and Descriptions
DisableElimination	Disables compression(evaluation at compile time), such that the Expression isn't const-folded, but ensured to be run at runtime. The operands are still attempted to be compressed, unless they override compression as well. See also compress()
IsEvaluated	Signals that the expression is already evaluated and can be considered a constant value. For example, atomic values return this flag in their implementations of the properties() functions. See also isEvaluated()
DisableTypingDeduction	Signals that the expression cannot be optimized away by judging its static type. This is currently used for properly handling the `none` type, in the `fn:error()` function. In type operations, the none type doesn't show up and that can make expressions, such as InstanceOf, believe it is safe to const fold, while it in fact is not.
EmptynessFollowsChild	This property affects the static type – staticType() – of an expression. It is implemented in FunctionCall::staticType() and therefore only work for FunctionCall sub-classes and when that function is not re-implemented in an inhibiting way. When set, the cardinality of the static type is zero if the Expression's first operand allows an empty sequence, otherwise it is the cardinality of the Expression's static type modulo Cardinality::empty(). This is used for specifying proper static type inference for functions that have "If $arg is the empty sequence, the empty sequence is returned." However, before setting this property one must be aware that no other conditions can lead to the empty sequence, since otherwise the static type would be wrong.
RewriteToEmptyOnEmpty	This is similar to EmptynessFollowsChild, and also implemented in FunctionCall. When set, it makes FunctionCall::typeCheck() rewrite itself into an empty sequence if the first operand is the empty sequence. This property is often used together with EmptynessFollowsChild.
RequiresFocus	When set, it signals that the focus cannot be undefined. For example, the `fn:position()` function extracts information from the focus. Setting this flag ensures type checking is carried out appropriately. However, setting RequiresFocus does not imply this Expression requires the context item to be defined. It only means the focus, of somekind, needs to be defined. See also RequiresContextItem
AffectsOrderOnly	An Expression with this Property set, signals that it only affects the order of its return value.
RequiresContextItem	When set, signals that the context item, must be defined for this Expression. When setting this property, expectedContextItemType() must be re-implemented. Setting this property also sets RequiresFocus. See also DynamicContext::contextItem()
CreatesFocusForLast	When set, signals that this expression creates a focus for its last operand. When set, newFocusType() must be overridden to return the static type of the context item. See also announceFocusType() newFocusType()
LastOperandIsCollation	Signals that the last operand is a collation argument. This ensures that the necessary code is generated for checking that the collation is supported. This only applies to sub-classes of FunctionCall.
DependsOnLocalVariable	When set, the Expression depends on local variables such as those found in `for` expressions. However, this does not include let bindings.
EvaluationCacheRedundant	When set, it signals that the Expression does not need an evaluation cache, despite what other flags might imply.
IsNodeConstructor	Signals that the Expression constructs nodes, either directly or computationally. For example, AttributeConstructor has this property set. Since node constructors constructs nodes which have node identities, node constructors are considered creative on evaluation.
RequiresCurrentItem	Whether this expression requires the current item, as returned from `fn:current()`. CurrentFN uses this flag.

Definition at line 198 of file qexpression_p.h.

         {
             UseContextItem              = 1,
 
             DisableElimination          = 1 << 1,
 
             IsEvaluated                 = 1 << 2,
 
             DisableTypingDeduction      = 1 << 3,
 
             EmptynessFollowsChild       = 1 << 4,
 
             RewriteToEmptyOnEmpty       = 1 << 5,
 
             RequiresFocus               = 1 << 6,
 
             AffectsOrderOnly            = 1 << 7,
 
             RequiresContextItem         = (1 << 8) | RequiresFocus,
 
             CreatesFocusForLast         = 1 << 9,
 
             LastOperandIsCollation      = 1 << 10,
 
             DependsOnLocalVariable      = (1 << 11) | DisableElimination,
 
             EvaluationCacheRedundant       = (1 << 12),
 
             IsNodeConstructor           = 1 << 13,
 
             RequiresCurrentItem         = 1 << 14
         };

Constructors and Destructors

◆ Expression()

QPatternist::Expression::Expression ( )

inline

Definition at line 489 of file qexpression_p.h.

490 {

491 }

◆ ~Expression()

Expression::~Expression ( )

virtual

Definition at line 58 of file qexpression.cpp.

59 {

60 }

Functions

◆ accept()

virtual ExpressionVisitorResult::Ptr QPatternist::Expression::accept ( const ExpressionVisitor::Ptr & visitor ) const

pure virtual

◆ actualReflection()

const SourceLocationReflection * Expression::actualReflection ( ) const

virtual

Returns this.

Implements QPatternist::SourceLocationReflection.

Reimplemented in QPatternist::QNameConstructor, QPatternist::EvaluationCache< IsForGlobal >, QPatternist::ContextItem, QPatternist::UntypedAtomicConverter, QPatternist::CardinalityVerifier, DelegatingReflectionExpression, QPatternist::CurrentItemStore, QPatternist::Atomizer, QPatternist::ItemVerifier, QPatternist::DynamicContextStore, and QPatternist::EBVExtractor.

Definition at line 399 of file qexpression.cpp.

Referenced by QPatternist::EBVExtractor::actualReflection(), QPatternist::DynamicContextStore::actualReflection(), QPatternist::ItemVerifier::actualReflection(), QPatternist::Atomizer::actualReflection(), QPatternist::CurrentItemStore::actualReflection(), and QPatternist::CardinalityVerifier::actualReflection().

 {
     return this;
 }

◆ announceFocusType()

void Expression::announceFocusType ( const ItemType::Ptr & itemType )

virtual

When this function is called, it signals that the parent will create a focus of type itemType.

This type can also be retrieved through StaticContext::contextItemType() when inside typeCheck(), but in some cases this is too late. For instance, a parent needs to have the static type of its child properly reported before it calls its typeCheck()(and the child's type is inferred from the focus).

The default implementation delegates the call on to the children.

This function may be called at arbitrary times, in arbitrary amounts.

If the AST node overriding this call has children, it should be considered whether the default implementation should be called, such that they type is announced to them too.

The caller guarantees that itemType is not null.

Reimplemented in QPatternist::ContextItem.

Definition at line 361 of file qexpression.cpp.

Referenced by announceFocusType(), and QPatternist::Path::typeCheck().

 {
     const Expression::List ops(operands());
     const int len = ops.count();
 
     for(int i = 0; i < len; ++i)
         ops.at(i)->announceFocusType(itemType);
 }

◆ compress()

Expression::Ptr Expression::compress ( const StaticContext::Ptr & context )

virtual

compress() is the last stage performs in compiling an expression, done after the initial AST build and calling typeCheck(). compress() performs crucial simplifications, either by having drastic performance implications or that some expressions depend on it for proper behavior.

The default implementation performs a sparse conditional constant propagation. In short, a recursive process is performed in the AST which examines if the Expression's operands are constant values, and if so, performs a const fold(AST rewrite) into the result of evaluating the expression in question. This default behavior can be disabled by letting properties() return DisableElimination.

This compress() stage can be relative effective due to the design of XPath, in part because intrinsic functions are heavily used. Many Expressions override compress() and do optimizations specific to what they do. Also, many Expressions performs optimizations in their typeCheck().

Parameters

context the static context. Supplies compile time information, and is the channel for communicating error messages.

See also: Wikipedia, the free encyclopedia, Sparse conditional constant propagation; Wikipedia, the free encyclopedia, Intrinsic function; Wikipedia, the free encyclopedia, Compiler optimization

Reimplemented in QPatternist::SubsequenceFN, QPatternist::NormalizeUnicodeFN, QPatternist::OrderBy, QPatternist::Existence< Id >, QPatternist::Path, QPatternist::CastAs, QPatternist::ApplyTemplate, QPatternist::GeneralComparison, QPatternist::PatternPlatform, QPatternist::ValueComparison, QPatternist::EvaluationCache< IsForGlobal >, QPatternist::CopyOf, QPatternist::ExpressionSequence, QPatternist::ForClause, QPatternist::StringJoinFN, QPatternist::FirstItemPredicate, QPatternist::CountFN, QPatternist::ReplaceFN, QPatternist::UserFunctionCallsite, QPatternist::ContextItem, QPatternist::CardinalityVerifier, QPatternist::NodeComparison, QPatternist::CastableAs, QPatternist::ReturnOrderBy, QPatternist::AndExpression, QPatternist::IfThenClause, QPatternist::InstanceOf, QPatternist::SimpleContentConstructor, QPatternist::TemplateInvoker, QPatternist::CurrentItemStore, QPatternist::OrExpression, QPatternist::NodeSortExpression, QPatternist::ComparesCaseAware, and QPatternist::CurrentFN.

Definition at line 241 of file qexpression.cpp.

 {
     if(!compressOperands(context))
     {
         /* At least one of the operands cannot be evaluated at compile, so
          * 'this' Expression cannot const fold. */
         return invokeOptimizers(Expression::Ptr(this), context);
     }
 
     Expression::Ptr retval;
 
     if(hasDependency(DisableElimination))
         retval = Expression::Ptr(this);
     else
         retval = constantPropagate(context);
 
     return invokeOptimizers(retval, context);
 }

◆ compressOperands()

virtual bool QPatternist::Expression::compressOperands ( const StaticContext::Ptr & )

protectedpure virtual

Returns: true if all operands are constant values of somekind, and are already evaluated. A string literal, is a typical example.

Implemented in QPatternist::EmptyContainer, QPatternist::UnlimitedContainer, QPatternist::PairContainer, QPatternist::SingleContainer, and QPatternist::TripleContainer.

Referenced by compress().

◆ constantPropagate()

Expression::Ptr Expression::constantPropagate ( const StaticContext::Ptr & context ) const

private

Performs constant propagation, also called constant folding, on this expression.

This means that it attempts to evaluate this expression at compile and returns the result value appropriately as an Expression. For example, for the XPath expression 1 + 3 would an Integer of value 4 would be returned.

It is not checked whether constant propagation is possible, the caller is responsible for this.

See also: Constant folding, From Wikipedia, the free encyclopedia

Definition at line 260 of file qexpression.cpp.

Referenced by compress().

 {
     Q_ASSERT(context);
 
     /* Optimization: We rewrite literals to literals here, which is pointless.
      * Maybe we should have a property which says "doesn't disable elimination
      * but don't eliminate me." */
     if(staticType()->cardinality().allowsMany())
     {
         Item::Iterator::Ptr it(evaluateSequence(context->dynamicContext()));
         Item::List result;
         Item item(it->next());
 
         while(item)
         {
             result.append(item);
             item = it->next();
         }
 
         switch(result.count())
         {
             case 0:
                 return EmptySequence::create(this, context);
             case 1:
                 return rewrite(Expression::Ptr(new Literal(result.first())), context);
             default:
                 return rewrite(Expression::Ptr(new LiteralSequence(result)), context);
         }
     }
     else
     {
         const Item item(evaluateSingleton(context->dynamicContext()));
 
         if(item)
             return rewrite(Expression::Ptr(new Literal(item)), context);
         else
             return EmptySequence::create(this, context);
     }
 }

◆ deepProperties()

Expression::Properties Expression::deepProperties ( ) const

Computes the union of properties for this Expression and all its descending children.

See also: properties()

Definition at line 370 of file qexpression.cpp.

Referenced by QPatternist::CurrentItemStore::compress(), deepProperties(), and QPatternist::LetClause::typeCheck().

 {
     Properties props(properties());
     const Expression::List ops(operands());
     const int len = ops.count();
 
     for(int i = 0; i < len; ++i)
         props |= ops.at(i)->deepProperties();
 
     return props;
 }

◆ dependencies()

Expression::Properties Expression::dependencies ( ) const

virtual

Recursively computes through all descendants until a Property is encount

Reimplemented in QPatternist::CallTemplate.

Definition at line 345 of file qexpression.cpp.

Referenced by QPatternist::Template::dependencies().

 {
     OperandsIterator it(Ptr(const_cast<Expression *>(this)), OperandsIterator::ExcludeParent);
     Expression::Ptr next(it.next());
 
     Properties dependencies(properties());
 
     while(next)
     {
         dependencies |= next->dependencies();
         next = it.next();
     }
 
     return dependencies & (Expression::RequiresFocus | Expression::IsEvaluated | Expression::DisableElimination);
 }

◆ description()

QString Expression::description ( ) const

virtual

Reimplementation of SourceLocationReflection::description().

Reimplemented from QPatternist::SourceLocationReflection.

Reimplemented in QPatternist::GenericPredicate, and QPatternist::Literal.

Definition at line 404 of file qexpression.cpp.

 {
     return QString::fromLatin1("Expression, id: %1").arg(QString::number(id()));
 }

◆ evaluateEBV()

bool Expression::evaluateEBV ( const DynamicContext::Ptr & context ) const

virtual

Determines the Effective Boolean Value of the expression.

The Effective Boolean Value of a value is not necessarily the same as converting the value to a new value of type xs:boolean.

Note that this function cannot return the empty sequence, evaluateSingleton() must be overridden in order to be able to do that.

The default implementation results in a type error. Hence, this function must be overridden if such behavior is not of interest.

See also: XML Path Language (XPath) 2.0, 2.4.3 Effective Boolean Value

Reimplemented in QPatternist::DocAvailableFN, QPatternist::Existence< Id >, QPatternist::EmptySequence, QPatternist::NotFN, QPatternist::FalseFN, QPatternist::CombineNodes, QPatternist::GeneralComparison, QPatternist::LetClause, QPatternist::UserFunctionCallsite, QPatternist::BooleanFN, QPatternist::Literal, QPatternist::QuantifiedExpression, QPatternist::ReturnOrderBy, QPatternist::PositionalVariableReference, QPatternist::TrueFN, QPatternist::ExpressionVariableReference, QPatternist::ExternalVariableReference, QPatternist::AndExpression, QPatternist::CallTemplate, QPatternist::CastableAs, QPatternist::NodeComparison, QPatternist::RangeVariableReference, QPatternist::InstanceOf, QPatternist::DeepEqualFN, QPatternist::EBVExtractor, QPatternist::ArgumentReference, QPatternist::IfThenClause, QPatternist::OrExpression, QPatternist::CurrentItemStore, QPatternist::DynamicContextStore, QPatternist::TemplateParameterReference, QPatternist::ElementAvailableFN, and QPatternist::UnparsedTextAvailableFN.

Definition at line 315 of file qexpression.cpp.

 {
     return Boolean::evaluateEBV(evaluateSequence(context), context);
 }

◆ evaluateSequence()

Item::Iterator::Ptr Expression::evaluateSequence ( const DynamicContext::Ptr & context ) const

virtual

Evaluate this Expression by iterating over it. This is a central function for evaluating expressions.

Expressions must always always return a valid QAbstractXmlForwardIterator and may never return 0. If an empty result is of interest to be returned, the EmptyIterator should be returned.

The default implementation returns a SingletonIterator over the item returned from evaluateSingleton().

Note: This function may raise an exception when calling, not only when QAbstractXmlForwardIterator::next() is called on the return value. This is because in some cases evaluateSingleton() is called directly.

Reimplemented in QPatternist::SubsequenceFN, QPatternist::ReverseFN, QPatternist::RemoveFN, QPatternist::InsertBeforeFN, QPatternist::DistinctValuesFN, QPatternist::CollectionFN, QPatternist::InScopePrefixesFN, QPatternist::OrderBy, QPatternist::TokenizeFN, QPatternist::IndexOfFN, QPatternist::IdrefFN, QPatternist::EvaluationCache< IsForGlobal >, QPatternist::Path, QPatternist::EmptySequence, QPatternist::GenericPredicate, QPatternist::ApplyTemplate, QPatternist::StringToCodepointsFN, QPatternist::UntypedAtomicConverter, QPatternist::UserFunctionCallsite, QPatternist::CombineNodes, QPatternist::LiteralSequence, QPatternist::IdFN, QPatternist::ArgumentConverter, QPatternist::LetClause, QPatternist::ExpressionSequence, QPatternist::ExpressionVariableReference, QPatternist::ForClause, QPatternist::Atomizer, QPatternist::ArgumentReference, QPatternist::ExternalVariableReference, QPatternist::RangeExpression, QPatternist::ItemVerifier, QPatternist::CallTemplate, QPatternist::IfThenClause, QPatternist::CardinalityVerifier, QPatternist::AxisStep, QPatternist::CurrentItemStore, QPatternist::DynamicContextStore, QPatternist::TemplateParameterReference, QPatternist::NodeSortExpression, and QPatternist::TraceFN.

Definition at line 300 of file qexpression.cpp.

 {
     const Item item(evaluateSingleton(context));
 
     if(item)
         return makeSingletonIterator(item);
     else
         return CommonValues::emptyIterator;
 }

◆ evaluateSingleton()

Item Expression::evaluateSingleton ( const DynamicContext::Ptr & context ) const

virtual

Definition at line 310 of file qexpression.cpp.

 {
     return Boolean::fromValue(evaluateEBV(context));
 }

◆ evaluateToSequenceReceiver()

void Expression::evaluateToSequenceReceiver ( const DynamicContext::Ptr & context ) const

virtual

Evaluates this Expression by sending its output to DynamicContext::outputReceiver().

Reimplemented in QPatternist::EmptySequence, QPatternist::Path, QPatternist::UserFunctionCallsite, QPatternist::ExpressionSequence, QPatternist::LetClause, QPatternist::CopyOf, QPatternist::Literal, QPatternist::ForClause, QPatternist::ElementConstructor, QPatternist::CallTemplate, QPatternist::IfThenClause, QPatternist::DocumentConstructor, QPatternist::AttributeConstructor, QPatternist::ProcessingInstructionConstructor, QPatternist::CommentConstructor, QPatternist::TextNodeConstructor, QPatternist::ComputedNamespaceConstructor, and QPatternist::NamespaceConstructor.

Definition at line 320 of file qexpression.cpp.

 {
     QAbstractXmlReceiver *const receiver = context->outputReceiver();
     const Item::Iterator::Ptr it(evaluateSequence(context));
     Item next(it->next());
 
     while(next)
     {
         receiver->item(next);
         next = it->next();
     }
 }

◆ expectedContextItemType()

ItemType::Ptr Expression::expectedContextItemType ( ) const

virtual

Returns the required type the context item must be an instance of.

If this Expression requires a focus, meaning its properties() function returns RequiresContextItem, it must return a type from this function. If any type is ok, BuiltinTypes::item should be returned.

In other words, this function must only be re-implemented if the focus is used. The default implementation performs an assert crash.

Reimplemented in QPatternist::ContextItem, QPatternist::CopyOf, QPatternist::AxisStep, and QPatternist::ParentNodeAxis.

Definition at line 333 of file qexpression.cpp.

Referenced by QPatternist::CopyOf::expectedContextItemType(), and QPatternist::TypeChecker::verifyType().

 {
     Q_ASSERT_X(false, Q_FUNC_INFO,
                "expectedContextItemType() must be overridden when RequiresContextItem is set.");
     return ItemType::Ptr();
 }

◆ expectedOperandTypes()

virtual SequenceType::List QPatternist::Expression::expectedOperandTypes ( ) const

pure virtual

Returns a list of Sequence Types, describing the type of each of the expression's operands. Hence, this function has a relationship to the operands() function:

- The lengths of the lists returned by expectedOperandTypes()
and operands() should always be equal in length, since one
cannot describe the type of a non-existent operand(and all
operands must have type information).
- A significant difference between the two functions is that while
the type of objects in the list returned by operands() may vary
between compilations/static context, simply because the particular
Expression is part of different XPath expressions, the
types in the list returned by expectedOperandTypes is always the same
since the function/operator signature never changes.

This function should not be confused with staticType(), which returns the static type of the expression itself, not its operands. The function call is an expression where this is clear: the type of the return value is not the same as the arguments' types. The static type of the operands supplied to the expression can be determined via the staticType() function of the instances returned by operands().

If the expression has no operands, an empty list should be returned.

Referenced by typeCheckOperands().

◆ finalizeStaticContext()

StaticContext::Ptr Expression::finalizeStaticContext ( const StaticContext::Ptr & context ) const

inlineprivate

Returns: a StaticContext that has adopted the context item type properly for this Expression.

Definition at line 62 of file qexpression.cpp.

Referenced by typeCheckOperands().

 {
     Q_ASSERT(context);
     const ItemType::Ptr focusType(newFocusType());
     Q_ASSERT(focusType);
     return StaticContext::Ptr(new StaticFocusContext(focusType, context));
 }

◆ has()

bool QPatternist::Expression::has ( const Property prop ) const

inline

Determines whether this Expression has Property prop set.

Calling expr->has(MyProperty) is semantically equivalent to expr->properties().testFlag(MyProperty). In other words, has(), as well as is(), provides syntacti sugar and makes code more readable.

Note: Do not attempt to re-implement this function. Instead, return the appropriate flag by re-implementing the properties() function.

Definition at line 866 of file qexpression_p.h.

Referenced by QPatternist::InstanceOf::compress(), QPatternist::FunctionCall::staticType(), QPatternist::FunctionCall::typeCheck(), and typeCheckOperands().

     {
         return properties().testFlag(prop);
     }

◆ hasDependency()

bool QPatternist::Expression::hasDependency ( const Property prop ) const

inline

Definition at line 871 of file qexpression_p.h.

Referenced by compress().

     {
         return dependencies().testFlag(prop);
     }

◆ id()

Expression::ID Expression::id ( ) const

virtual

This property, which has no setter, returns an enum value that uniquely identifies this Expression. Patternist makes no use of C++'s dynamic_cast feature, but uses this polymorphic function instead.

Returns: always IgnorableExpression.

Reimplemented in QPatternist::AxisStep, QPatternist::Path, QPatternist::EmptySequence, QPatternist::ExpressionSequence, QPatternist::UserFunctionCallsite, QPatternist::GenericPredicate, QPatternist::CardinalityVerifier, QPatternist::ContextItem, QPatternist::FirstItemPredicate, QPatternist::GeneralComparison, QPatternist::ValueComparison, QPatternist::NamespaceConstructor, QPatternist::ForClause, QPatternist::LetClause, QPatternist::CombineNodes, QPatternist::AttributeConstructor, QPatternist::IfThenClause, QPatternist::LiteralSequence, QPatternist::FunctionCall, QPatternist::Literal, QPatternist::ReturnOrderBy, QPatternist::ExpressionVariableReference, QPatternist::RangeVariableReference, QPatternist::ArgumentReference, and QPatternist::UnresolvedVariableReference.

Definition at line 382 of file qexpression.cpp.

Referenced by QPatternist::findAxisStep(), QPatternist::ValueComparison::isCaseInsensitiveCompare(), QPatternist::ComparisonIdentifier::matches(), QPatternist::ElementConstructor::typeCheck(), and QPatternist::TypeChecker::verifyType().

 {
     return IDIgnorableExpression;
 }

◆ invokeOptimizers()

Expression::Ptr Expression::invokeOptimizers	(	const Expression::Ptr &	expr,
		const StaticContext::Ptr &	context
	)

staticprivate

Definition at line 126 of file qexpression.cpp.

Referenced by compress().

 {
     Q_ASSERT(expr);
 
     const OptimizationPass::List opts(expr->optimizationPasses());
 
     if(opts.isEmpty()) /* Early exit. */
     {
         return expr;
     }
 
     const OptimizationPass::List::const_iterator passEnd(opts.constEnd());
     const OptimizationPass::List::const_iterator end(opts.constEnd());
     OptimizationPass::List::const_iterator passIt(opts.constBegin());
 
     for(; passIt != passEnd; ++passIt) /* Invoke each optimization pass. */
     {
         const OptimizationPass::Ptr pass(*passIt); /* Alias, for readability. */
         OptimizationPass::ExpressionMarker sourceMarker(pass->sourceExpression);
 
         if(pass->startIdentifier && !pass->startIdentifier->matches(expr))
         {
             /* This pass specified a start identifier and it did
              * not match -- let's try the next OptimizationPass. */
             continue;
         }
 
         const ExpressionIdentifier::List::const_iterator idEnd(pass->operandIdentifiers.constEnd());
         ExpressionIdentifier::List::const_iterator idIt(pass->operandIdentifiers.constBegin());
         const Expression::List ops(expr->operands());
         const Expression::List::const_iterator opEnd(ops.constEnd());
         Expression::List::const_iterator opIt(ops.constBegin());
 
         switch(pass->operandsMatchMethod)
         {
             case OptimizationPass::Sequential:
             {
                 for(; opIt != opEnd; ++opIt)
                 {
                     const Expression::Ptr operand(*opIt); /* Alias, for readability. */
                     const ExpressionIdentifier::Ptr opIdentifier(*idIt); /* Alias, for readability. */
                     if(opIdentifier && !opIdentifier->matches(operand))
                     {
                         break;
                     }
 
                     ++idIt;
                 }
 
                 if(opIt == opEnd)
                     break; /* All operands matched, so this pass matched. */
                 else
                 {
                     /* The loop above did not finish which means all operands did not match.
                        Therefore, this OptimizationPass did not match -- let's try the next one. */
                     continue;
                 }
             }
             case OptimizationPass::AnyOrder:
             {
                 Q_ASSERT_X(ops.count() == 2, Q_FUNC_INFO,
                            "AnyOrder is currently only supported for Expressions with two operands.");
                 if(pass->operandIdentifiers.first()->matches(ops.first()) &&
                    pass->operandIdentifiers.last()->matches(ops.last()))
                 {
                     break;
                 }
                 else if(pass->operandIdentifiers.first()->matches(ops.last()) &&
                         pass->operandIdentifiers.last()->matches(ops.first()))
                 {
                     sourceMarker.first() = 1;
                     sourceMarker[1] = 0;
                     break; /* This pass matched. */
                 }
                 else
                     continue; /* This pass didn't match, let's loop through the next pass. */
             }
         }
 
         /* Figure out the source Expression, if any. */
         Expression::List operands;
         Expression::Ptr sourceExpr;
 
         if(!sourceMarker.isEmpty())
         {
             const OptimizationPass::ExpressionMarker::const_iterator mEnd(sourceMarker.constEnd());
             OptimizationPass::ExpressionMarker::const_iterator mIt(sourceMarker.constBegin());
             sourceExpr = expr;
 
             for(; mIt != mEnd; ++mIt)
             {
                 Q_ASSERT(*mIt >= 0);
                 sourceExpr = sourceExpr->operands().at(*mIt);
             }
 
             operands.append(sourceExpr);
         }
 
         if(operands.isEmpty())
         {
             Q_ASSERT(pass->resultCreator);
             return pass->resultCreator->create(Expression::List(), context, expr.data())->compress(context);
         }
         else if(pass->resultCreator)
             return pass->resultCreator->create(operands, context, expr.data())->compress(context);
         else
         {
             return sourceExpr;
         }
     }
 
     return expr;
 }

◆ is()

bool QPatternist::Expression::is ( const ID id ) const

inline

This function is a utility function, syntactic sugar for determining whether this Expression is id. For example, calling is(IDIfThenClause) is equivalent to id() == IDIfThenClause

Note: Do not attempt to re-implement this function. Instead, return the appropriate flag in the virtual id() function.

Definition at line 856 of file qexpression_p.h.

Referenced by QPatternist::CallTargetDescription::checkCallsiteCircularity(), QPatternist::ReplaceFN::compress(), QPatternist::FirstItemPredicate::compress(), QPatternist::StringJoinFN::compress(), QPatternist::PatternPlatform::compress(), QPatternist::Path::compress(), QPatternist::NormalizeUnicodeFN::compress(), QPatternist::GenericPredicate::create(), QPatternist::findAxisStep(), QPatternist::ByIDIdentifier::matches(), QPatternist::IntegerIdentifier::matches(), QPatternist::BooleanIdentifier::matches(), QPatternist::UserFunctionCallsite::setSource(), QPatternist::RangeExpression::staticType(), QPatternist::CastableAs::typeCheck(), QPatternist::ElementConstructor::typeCheck(), QPatternist::CastAs::typeCheck(), and QPatternist::TypeChecker::verifyType().

     {
         return id() == i;
     }

◆ isEvaluated()

bool QPatternist::Expression::isEvaluated ( ) const

inline

This function is a utility function, which performs bitwise logic on properties() in order to find out whether the Expression::IsEvaluated flag is set.

Note: Do not attempt to re-implement this function. Instead, return the IsEvaluated flag by re-implementing the properties() function.

Definition at line 861 of file qexpression_p.h.

Referenced by QPatternist::OrExpression::compress(), QPatternist::IfThenClause::compress(), QPatternist::AndExpression::compress(), QPatternist::SingleContainer::compressOperands(), QPatternist::PairContainer::compressOperands(), QPatternist::TripleContainer::compressOperands(), and QPatternist::SubsequenceFN::staticType().

     {
         return has(IsEvaluated);
     }

◆ newFocusType()

ItemType::Ptr Expression::newFocusType ( ) const

virtual

If an Expression creates a focus because it has set the property CreatesFocusForLast, it should override this function and make it return the ItemType that the context item in the focus has.

Returns: never null.

See also: announceFocusType()

Reimplemented in QPatternist::GenericPredicate, and QPatternist::Path.

Definition at line 392 of file qexpression.cpp.

Referenced by finalizeStaticContext().

 {
     Q_ASSERT_X(false, Q_FUNC_INFO,
                "This function must be overridden when CreatesFocusForLast is set.");
     return ItemType::Ptr();
 }

◆ operands()

virtual Expression::List QPatternist::Expression::operands ( ) const

pure virtual

Returns: the expression's child expressions. For example, a function's arguments is returned here.

If this Expression has no operands, an empty list should be returned.

Implemented in QPatternist::UnlimitedContainer, QPatternist::EmptyContainer, QPatternist::PairContainer, QPatternist::SingleContainer, and QPatternist::TripleContainer.

Referenced by announceFocusType(), QPatternist::CallTargetDescription::checkArgumentsCircularity(), QPatternist::FirstItemPredicate::compress(), deepProperties(), QPatternist::findAxisStep(), invokeOptimizers(), QPatternist::ValueComparison::isCaseInsensitiveCompare(), QPatternist::ElementConstructor::typeCheck(), typeCheckOperands(), and QPatternist::TypeChecker::verifyType().

◆ optimizationPasses()

OptimizationPass::List Expression::optimizationPasses ( ) const

virtual

Returns the OptimizationPasses that applies for this Expression. The default implementation returns an empty list. Sub-classes can re-implement this function and return actual OptimizationPasses.

Returns: always an empty list.

Reimplemented in QPatternist::NotFN, QPatternist::ValueComparison, QPatternist::GeneralComparison, QPatternist::ForClause, and QPatternist::IfThenClause.

Definition at line 387 of file qexpression.cpp.

Referenced by invokeOptimizers().

 {
     return OptimizationPass::List();
 }

◆ patternPriority()

PatternPriority Expression::patternPriority ( ) const

virtual

By default 0.5 is returned.

Reimplemented in QPatternist::AxisStep.

Definition at line 409 of file qexpression.cpp.

 {
     return 0.5;
 }

◆ properties()

Expression::Properties Expression::properties ( ) const

virtual

Returns: a bitwise OR'd value of properties, describing the characteristics of the expression. These properties affects how this Expression is treated in for example type checking stages.

The default implementation returns 0. Override and let the function return a different value, if that's of interest.

An important decision when re-implementing properties() is whether to OR in the properties() of ones operands. For instance, if an operand has RequiresFocus set, that flag nost likely applies to the apparent as well, since it depends on its operand.

See also: deepProperties()

Returns: Expression::None, meaning no special properties

Definition at line 340 of file qexpression.cpp.

Referenced by deepProperties(), dependencies(), QPatternist::CurrentItemStore::properties(), QPatternist::CopyOf::properties(), QPatternist::Path::properties(), QPatternist::Template::properties(), QPatternist::OrderBy::properties(), and QPatternist::TypeChecker::verifyType().

 {
     return Properties();
 }

◆ rewrite() [1/2]

void QPatternist::Expression::rewrite	(	Expression::Ptr &	old,
		const Expression::Ptr &	New,
		const StaticContext::Ptr &	context
	)

inlinestatic

This function take the two Expression pointers old and New, and in a safe way, by handling reference counting and being aware of whether the two pointers actually are different, switches the two. When compiling in debug mode, informative debug messages are printed.

This function is conceptually similar to Qt's qSwap(), but has debugging functionality and also handles source locations.

Definition at line 876 of file qexpression_p.h.

Referenced by QPatternist::UserFunctionCallsite::compress(), QPatternist::PairContainer::compressOperands(), QPatternist::SingleContainer::compressOperands(), QPatternist::TripleContainer::compressOperands(), QPatternist::UnlimitedContainer::compressOperands(), constantPropagate(), QPatternist::GeneralComparison::typeCheck(), QPatternist::AxisStep::typeCheck(), and QPatternist::DocumentFN::typeCheck().

     {
         Q_ASSERT(old);
         Q_ASSERT(New);
 
         if(old != New)
         {
             pDebug() << "AST REWRITE:" << old.data() << "to" << New.data()
                      << '(' << old->actualReflection() << "to" << New->actualReflection() << ", "
                      << old->description() << "to" << New->description() << ')';
 
             /* The order of these two lines is significant.. */
             context->addLocation(New.data(), context->locationFor(old->actualReflection()));
             old = New;
         }
     }

◆ rewrite() [2/2]

const Expression::Ptr & QPatternist::Expression::rewrite	(	const Expression::Ptr &	to,
		const StaticContext::Ptr &	context
	)		const

inline

Rewrites this Expression to to, and return to.

Source location annotations are adjusted appropriately.

Definition at line 895 of file qexpression_p.h.

     {
         context->addLocation(to.data(), context->locationFor(this));
         return to;
     }

◆ setOperands()

virtual void QPatternist::Expression::setOperands ( const Expression::List & operands )

pure virtual

Implemented in QPatternist::EmptyContainer, QPatternist::UnlimitedContainer, QPatternist::PairContainer, QPatternist::SingleContainer, and QPatternist::TripleContainer.

Referenced by QPatternist::XSLT20CoreFunctions::retrieveExpression(), QPatternist::XPath10CoreFunctions::retrieveExpression(), QPatternist::XPath20CoreFunctions::retrieveExpression(), and typeCheckOperands().

◆ staticType()

virtual SequenceType::Ptr QPatternist::Expression::staticType ( ) const

pure virtual

Returns: the static type of this Expression. For example, an 'and' expression have as static type xs:boolean

◆ typeCheck()

Expression::Ptr Expression::typeCheck	(	const StaticContext::Ptr &	context,
		const SequenceType::Ptr &	reqType
	)

virtual

This implementation guarantees to never rewrite away this Expression, but at most rewrite it as a child of another expression(that presumably have a type checking role). It is therefore always safe to override this function and call this implementation and not worry about that this Expression becomes deleted.

Many Expressions override typeCheck() and performs optimizations, as opposed to doing it in the compress() stage. This is due to that the design of those Expressions often are tied to that certain simplifications are done at the typeCheck() stage of the compilation process or that it in some other way is related to what the typeCheck() do. Also, the earlier the AST can be simplified, the better the chances are for subsequent optimizations.

It is important that the super class's typeCheck() is called before doing any custom type checking, since the call can change the children(notably, the childrens' static types). For example, if the Expression, MyExpression in the example, does not match the required type, typeCheck returns the Expression wrapped in for example ItemVerifier, CardinalityVerifier, or both.

typeCheck() may be called many times. typeCheck() must either raise an error if this Expression is an invalid expression. Thus, it is guaranteed that an Expression is valid after typeCheck() is called.

Parameters

context	supplies information, such as namespace bindings and available function signatures, that can be needed at compilation time. `context` is guaranteed by the caller to never null.
reqType	the static type that this Expression must match when evaluated. `reqType` is guaranteed by the caller to never null.

Returns: an Expression that can be this Expression, or another expression, which somehow is necessary for making this Expression conforming to reqType

Reimplemented in QPatternist::SubsequenceFN, QPatternist::ReverseFN, QPatternist::DistinctValuesFN, QPatternist::StaticBaseURIFN, QPatternist::DefaultCollationFN, QPatternist::OrderBy, QPatternist::SumFN, QPatternist::DocFN, QPatternist::NumberFN, QPatternist::AvgFN, QPatternist::EvaluationCache< IsForGlobal >, QPatternist::DocumentFN, QPatternist::CastAs, QPatternist::IndexOfFN, QPatternist::AddingAggregate, QPatternist::ExpressionSequence, QPatternist::Path, QPatternist::StringFN, QPatternist::ContextItem, QPatternist::UntypedAtomicConverter, QPatternist::CallTemplate, QPatternist::TreatAs, QPatternist::ComparingAggregator< oper, result >, QPatternist::BooleanFN, QPatternist::Atomizer, QPatternist::ElementConstructor, QPatternist::CountFN, QPatternist::AxisStep, QPatternist::UserFunctionCallsite, QPatternist::StaticBaseUriContainer, QPatternist::ArithmeticExpression, QPatternist::CombineNodes, QPatternist::LetClause, QPatternist::IdFN, QPatternist::CastableAs, QPatternist::ForClause, QPatternist::GeneralComparison, QPatternist::DocumentConstructor, QPatternist::ValueComparison, QPatternist::ExpressionVariableReference, QPatternist::NCNameConstructor, QPatternist::StaticNamespacesContainer, QPatternist::FunctionCall, QPatternist::CurrentItemStore, QPatternist::EBVExtractor, QPatternist::StaticBaseURIStore, QPatternist::StaticCompatibilityStore, QPatternist::DeepEqualFN, QPatternist::FunctionAvailableFN, QPatternist::TypeAvailableFN, QPatternist::UnresolvedVariableReference, QPatternist::CurrentFN, and QPatternist::ResolveURIFN.

Definition at line 70 of file qexpression.cpp.

 {
     Q_ASSERT(reqType);
     typeCheckOperands(context);
     return TypeChecker::applyFunctionConversion(Expression::Ptr(this), reqType, context);
 }

◆ typeCheckOperands()

void Expression::typeCheckOperands ( const StaticContext::Ptr & context )

protected

Definition at line 78 of file qexpression.cpp.

Referenced by QPatternist::UserFunctionCallsite::typeCheck(), QPatternist::DocumentFN::typeCheck(), and typeCheck().

 {
     const Expression::List ops(operands());
 
     /* Check if this expression has any operands at all. */
     if(ops.isEmpty())
         return; /* We're done, early exit. */
 
     const SequenceType::List opTypes(expectedOperandTypes());
     Expression::List result;
 
     /* If we create a focus, we handle the last one specially, so avoid it in the loop. */
     const bool createsFocus = has(CreatesFocusForLast);
     const SequenceType::List::const_iterator typeEnd(createsFocus ? --opTypes.constEnd()
                                                                   : opTypes.constEnd());
     const Expression::List::const_iterator end(createsFocus ? --ops.constEnd()
                                                             : ops.constEnd());
 
     SequenceType::List::const_iterator reqType(opTypes.constBegin());
     SequenceType::Ptr t(*reqType);
     // TODO we assign twice to t here(also below in loop) when ops.size() > 1
 
     Expression::List::const_iterator it(ops.constBegin());
 
     for(; it != end; ++it)
     {
         /* This ensures that the last expectedOperandType stays, and is
          * used for all other operands. This is used for expressions that
          * have an infinite amount of operands, such as the concat() function. */
         if(reqType != typeEnd)
         {
             t = *reqType;
             ++reqType;
         }
 
          /* Let the child & its children typecheck. */
         result.append((*it)->typeCheck(context, t));
     }
 
     if(createsFocus)
     {
         const StaticContext::Ptr newContext(finalizeStaticContext(context));
         result.append(ops.last()->typeCheck(newContext, opTypes.last()));
     }
 
     setOperands(result);
 }

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

/src/xmlpatterns/expr/qexpression_p.h
/src/xmlpatterns/expr/qexpression.cpp

Public Types

Public Functions

Static Public Functions

Protected Functions

Private Functions

Static Private Functions

Additional Inherited Members

Detailed Description

Expression Compilation

The process of creating an Expression

Type Checking

Compressing -- Optimization and Fixup

Typedefs

◆ ConstPtr

◆ List

◆ Properties

◆ Ptr

◆ QAbstractXmlForwardIterator

◆ Vector

Enumerations

◆ ID

◆ Property

Constructors and Destructors

◆ Expression()

◆ ~Expression()

Functions

◆ accept()

◆ actualReflection()

◆ announceFocusType()

◆ compress()

◆ compressOperands()

◆ constantPropagate()

◆ deepProperties()

◆ dependencies()

◆ description()

◆ evaluateEBV()

◆ evaluateSequence()

◆ evaluateSingleton()

◆ evaluateToSequenceReceiver()

◆ expectedContextItemType()

◆ expectedOperandTypes()

◆ finalizeStaticContext()

◆ has()

◆ hasDependency()

◆ id()

◆ invokeOptimizers()

◆ is()

◆ isEvaluated()

◆ newFocusType()

◆ operands()

◆ optimizationPasses()

◆ patternPriority()

◆ properties()

◆ rewrite() [1/2]

◆ rewrite() [2/2]

◆ setOperands()

◆ staticType()

◆ typeCheck()

◆ typeCheckOperands()