/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the QtXmlPatterns module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists purely as an
// implementation detail. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
#ifndef Patternist_Expression_H
#define Patternist_Expression_H
#include <QFlags>
#include <QSharedData>
#include "qcppcastinghelper_p.h"
#include "qdebug_p.h"
#include "qdynamiccontext_p.h"
#include "qexpressiondispatch_p.h"
#include "qitem_p.h"
#include "qsequencetype_p.h"
#include "qsourcelocationreflection_p.h"
#include "qstaticcontext_p.h"
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
template<typename T> class QList;
template<typename T> class QVector;
namespace QPatternist
{
template<typename T, typename ListType> class ListIterator;
class OptimizationPass;
/**
* @short Base class for all AST nodes in an XPath/XQuery/XSL-T expression.
*
* @section ExpressionCreation Expression Compilation
*
* @subsection ExpressionCreationParser 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
* <tt>'string' + 1 and xs:date('2001-03-13')</tt> 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).
*
* @subsection ExpressionCreationTypeChecking 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 <a
* href="http://www.w3.org/TR/xpath20/#id-static-analysis">2.2.3.1 Static Analysis Phase</a>
* labels operation tree normalization; step SQ5.
*
* @subsection ExpressionCreationCompression 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 <tt>3 + 3, concat('foo', '-', 'bar'), true() and false()</tt> would
* result in an AST corresponding to <tt>6, 'foo-bar', false()</tt>. 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 <a href="http://www.w3.org/TR/xpath20/#id-errors-and-opt">XML Path Language
* (XPath) 2.0, 2.3.4 Errors and Optimization</a>
* @see <a href="http://www.w3.org/TR/xpath20/#id-expression-processing">XML Path
* Language (XPath) 2.0, 2.2.3 Expression Processing</a>
* @see <a href="http://www.w3.org/TR/xquery-xpath-parsing/">Building a Tokenizer
* for XPath or XQuery</a>
* @see ExpressionFactory
* @author Frans Englich <frans.englich@nokia.com>
* @ingroup Patternist_expressions
*/
class Q_AUTOTEST_EXPORT Expression : public QSharedData
, public CppCastingHelper<Expression>
, public SourceLocationReflection
{
public:
/**
* @short A smart pointer wrapping mutable Expression instances.
*/
typedef QExplicitlySharedDataPointer<Expression> Ptr;
/**
* @short A smart pointer wrapping @c const Expression instances.
*/
typedef QExplicitlySharedDataPointer<const Expression> ConstPtr;
/**
* A list of Expression instances, each wrapped in a smart pointer.
*/
typedef QList<Expression::Ptr> List;
/**
* A vector of Expression instances, each wrapped in a smart pointer.
*/
typedef QVector<Expression::Ptr> Vector;
typedef QT_PREPEND_NAMESPACE(QAbstractXmlForwardIterator<Expression::Ptr>)
QAbstractXmlForwardIterator;
/**
* Enum flags describing the characteristics of the expression.
*
* @see Expression::properties()
*/
enum Property
{
/**
* This flag applies for functions, and results in the expression <tt>.</tt>
* 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 <tt>fn:number()</tt>.
*
* @see ContextItem
* @see <a href="http://www.w3.org/TR/xpath-functions/#func-signatures">XQuery 1.0 and
* XPath 2.0 Functions and Operators, 1.3 Function Signatures and Descriptions</a>
*/
UseContextItem = 1,
/**
* 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 compress()
*/
DisableElimination = 1 << 1,
/**
* 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 isEvaluated()
*/
IsEvaluated = 1 << 2,
/**
* Signals that the expression cannot be optimized away by judging
* its static type.
*
* This is currently used for properly handling the @c none type, in
* the <tt>fn:error()</tt> 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.
*/
DisableTypingDeduction = 1 << 3,
/**
* 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.
*/
EmptynessFollowsChild = 1 << 4,
/**
* 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.
*/
RewriteToEmptyOnEmpty = 1 << 5,
/**
* When set, it signals that the focus cannot be undefined. For example,
* the <tt>fn:position()</tt> 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 RequiresContextItem
*/
RequiresFocus = 1 << 6,
/**
* An Expression with this Property set, signals that it only affects
* the order of its return value.
*/
AffectsOrderOnly = 1 << 7,
/**
* 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 DynamicContext::contextItem()
*/
RequiresContextItem = (1 << 8) | RequiresFocus,
/**
* 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 announceFocusType()
* @see newFocusType()
*/
CreatesFocusForLast = 1 << 9,
/**
* 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.
*/
LastOperandIsCollation = 1 << 10,
/**
* When set, the Expression depends on local variables such as
* those found in @c for expressions. However, this does not
* include let bindings.
*/
DependsOnLocalVariable = (1 << 11) | DisableElimination,
/**
* When set, it signals that the Expression does not need
* an evaluation cache, despite what other flags might imply.
*/
EvaluationCacheRedundant = (1 << 12),
/**
* 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.
*/
IsNodeConstructor = 1 << 13,
/**
* Whether this expression requires the current item, as returned
* from @c fn:current().
*
* CurrentFN uses this flag.
*/
RequiresCurrentItem = 1 << 14
};
/**
* 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 QFlags
*/
typedef QFlags<Property> Properties;
/**
* Enumerators that identifies Expression sub-classes.
*
* @see id()
*/
enum ID
{
/**
* Identifies Boolean.
*/
IDBooleanValue = 1,
/**
* Identifies CountFN.
*/
IDCountFN,
/**
* Identifies EmptyFN.
*/
IDEmptyFN,
/**
* Identifies ExistsFN.
*/
IDExistsFN,
/**
* Identifies ExpressionSequence and LiteralSequence.
*/
IDExpressionSequence,
/**
* Identifies GeneralComparison.
*/
IDGeneralComparison,
/**
* Identifies IfThenClause.
*/
IDIfThenClause,
/**
* 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.
*/
IDIgnorableExpression,
/**
* Identifies Integer.
*/
IDIntegerValue,
/**
* Identifies PositionFN.
*/
IDPositionFN,
/**
* Identifies AtomicString, AnyURI, and UntypedAtomic.
*/
IDStringValue,
/**
* Identifies ValueComparison.
*/
IDValueComparison,
/**
* Identifies VariableReference.
*/
IDRangeVariableReference,
/**
* Identifies ContextItem.
*/
IDContextItem,
/**
* Identifies UserFunctionCallsite.
*/
IDUserFunctionCallsite,
/**
* Identifies ExpressionVariableReference.
*/
IDExpressionVariableReference,
/**
* Identifies ExpressionVariableReference.
*/
IDAttributeConstructor,
/**
* Identifies UpperCaseFN.
*/
IDUpperCaseFN,
/**
* Identifies LowerCaseFN.
*/
IDLowerCaseFN,
/**
* Identifies FirstItemPredicate.
*/
IDFirstItemPredicate,
IDEmptySequence,
IDReturnOrderBy,
IDLetClause,
IDForClause,
IDPath,
IDNamespaceConstructor,
IDArgumentReference,
IDGenericPredicate,
IDAxisStep,
/**
* A literal which is either @c xs:float or
* @c xs:double.
*/
IDFloat,
IDCombineNodes,
IDUnresolvedVariableReference,
IDCardinalityVerifier
};
inline Expression()
{
}
virtual ~Expression();
/**
* 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.
*/
virtual Item::Iterator::Ptr evaluateSequence(const DynamicContext::Ptr &context) const;
/**
* @todo Docs
*/
virtual Item evaluateSingleton(const DynamicContext::Ptr &context) const;
/**
* 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 <a href="http://www.w3.org/TR/xpath20/#id-ebv">XML Path Language (XPath) 2.0,
* 2.4.3 Effective Boolean Value</a>
*/
virtual bool evaluateEBV(const DynamicContext::Ptr &context) const;
/**
* Evaluates this Expression by sending its output to DynamicContext::outputReceiver().
*/
virtual void evaluateToSequenceReceiver(const DynamicContext::Ptr &context) const;
/**
* @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.
*/
virtual Expression::List operands() const = 0;
virtual void setOperands(const Expression::List &operands) = 0;
/**
* @returns the static type of this Expression. For example, an 'and' expression
* have as static type xs:boolean
*/
virtual SequenceType::Ptr staticType() const = 0;
/**
* 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.
*/
virtual SequenceType::List expectedOperandTypes() const = 0;
/**
* 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.
*
* @param context supplies information, such as namespace bindings and
* available function signatures, that can be needed at compilation time. @p context is
* guaranteed by the caller to never null.
* @param reqType the static type that this Expression must match when evaluated. @p 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
* @p reqType
*/
virtual Expression::Ptr typeCheck(const StaticContext::Ptr &context,
const SequenceType::Ptr &reqType);
/**
* 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().
*
* @param context the static context. Supplies compile time information, and is
* the channel for communicating error messages.
* @see <a href="http://en.wikipedia.org/wiki/Sparse_conditional_constant_propagation">Wikipedia,
* the free encyclopedia, Sparse conditional constant propagation</a>
* @see <a href="http://en.wikipedia.org/wiki/Intrinsic_function">Wikipedia,
* the free encyclopedia, Intrinsic function</a>
* @see <a href="http://en.wikipedia.org/wiki/Compiler_optimization">Wikipedia, the
* free encyclopedia, Compiler optimization</a>
*/
virtual Expression::Ptr compress(const StaticContext::Ptr &context);
/**
* @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 deepProperties()
* @returns Expression::None, meaning no special properties
*/
virtual Properties properties() const;
/**
* Recursively computes through all descendants until a Property
* is encount
*/
virtual Properties dependencies() const;
/**
* @short Computes the union of properties for this Expression and all
* its descending children.
*
* @see properties()
*/
Properties deepProperties() const;
/**
* 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.
*/
inline bool isEvaluated() const;
/**
* This function is a utility function, syntactic sugar for determining
* whether this Expression is @p id. For example, calling <tt>is(IDIfThenClause)</tt>
* is equivalent to <tt>id() == IDIfThenClause</tt>
*
* @note Do not attempt to re-implement this function. Instead, return the
* appropriate flag in the virtual id() function.
*/
inline bool is(const ID id) const;
/**
* Determines whether this Expression has Property @p prop set.
*
* Calling <tt>expr->has(MyProperty)</tt> is semantically equivalent
* to <tt>expr->properties().testFlag(MyProperty)</tt>. 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.
*/
inline bool has(const Property prop) const;
inline bool hasDependency(const Property prop) const;
virtual ExpressionVisitorResult::Ptr accept(const ExpressionVisitor::Ptr &visitor) const = 0;
/**
* 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.
*/
virtual ID id() const;
/**
* 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.
*/
virtual QList<QExplicitlySharedDataPointer<OptimizationPass> > optimizationPasses() const;
/**
* 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.
*/
virtual ItemType::Ptr expectedContextItemType() const;
/**
* 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 @c null.
* @see announceFocusType()
*/
virtual ItemType::Ptr newFocusType() const;
/**
* @short Returns @c this.
*/
virtual const SourceLocationReflection *actualReflection() const;
/**
* Reimplementation of SourceLocationReflection::description().
*/
virtual QString description() const;
/**
* When this function is called, it signals that the parent will create
* a focus of type @p 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 @p itemType is not @c null.
*/
virtual void announceFocusType(const ItemType::Ptr &itemType);
/**
* This function take the two Expression pointers @p old and @p 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.
*/
static inline void rewrite(Expression::Ptr &old,
const Expression::Ptr &New,
const StaticContext::Ptr &context);
/**
* @short Rewrites this Expression to @p to, and return @p to.
*
* Source location annotations are adjusted appropriately.
*/
inline const Expression::Ptr &rewrite(const Expression::Ptr &to,
const StaticContext::Ptr &context) const;
/**
* By default 0.5 is returned.
*/
virtual PatternPriority patternPriority() const;
protected:
/**
* @returns @c true if all operands are constant values of somekind, and are already
* evaluated. A string literal, is a typical example.
*/
virtual bool compressOperands(const StaticContext::Ptr &) = 0;
void typeCheckOperands(const StaticContext::Ptr &context);
private:
static Expression::Ptr invokeOptimizers(const Expression::Ptr &expr,
const StaticContext::Ptr &context);
/**
* @return a StaticContext that has adopted the context item type properly
* for this Expression.
*/
inline StaticContext::Ptr finalizeStaticContext(const StaticContext::Ptr &context) const;
/**
* @short 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
* <tt>1 + 3</tt> 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 <a href="http://en.wikipedia.org/wiki/Constant_propagation">Constant folding,
* From Wikipedia, the free encyclopedia</a>
*/
Expression::Ptr constantPropagate(const StaticContext::Ptr &context) const;
Q_DISABLE_COPY(Expression)
};
Q_DECLARE_OPERATORS_FOR_FLAGS(Expression::Properties)
inline bool Expression::is(const Expression::ID i) const
{
return id() == i;
}
inline bool Expression::isEvaluated() const
{
return has(IsEvaluated);
}
inline bool Expression::has(const Expression::Property prop) const
{
return properties().testFlag(prop);
}
inline bool Expression::hasDependency(const Expression::Property prop) const
{
return dependencies().testFlag(prop);
}
inline void Expression::rewrite(Expression::Ptr &old,
const Expression::Ptr &New,
const StaticContext::Ptr &context)
{
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;
}
}
inline const Expression::Ptr &Expression::rewrite(const Expression::Ptr &to,
const StaticContext::Ptr &context) const
{
context->addLocation(to.data(), context->locationFor(this));
return to;
}
}
Q_DECLARE_TYPEINFO(QPatternist::Expression::Ptr, Q_MOVABLE_TYPE);
QT_END_NAMESPACE
QT_END_HEADER
#endif