Source code
Revision control
Copy as Markdown
Other Tools
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
#ifndef TRANSFRMX_EXPR_H
#define TRANSFRMX_EXPR_H
#include "mozilla/Attributes.h"
#include "mozilla/UniquePtr.h"
#include "txExprResult.h"
#include "txCore.h"
#include "nsString.h"
#include "txOwningArray.h"
#include "nsAtom.h"
#ifdef DEBUG
# define TX_TO_STRING
#endif
/*
XPath class definitions.
Much of this code was ported from XSL:P.
*/
class nsAtom;
class txIMatchContext;
class txIEvalContext;
class txNodeSet;
class txXPathNode;
class txXPathTreeWalker;
/**
* A Base Class for all XSL Expressions
**/
class Expr {
public:
MOZ_COUNTED_DEFAULT_CTOR(Expr)
MOZ_COUNTED_DTOR_VIRTUAL(Expr)
/**
* Evaluates this Expr based on the given context node and processor state
* @param context the context node for evaluation of this Expr
* @param ps the ContextState containing the stack information needed
* for evaluation
* @return the result of the evaluation
**/
virtual nsresult evaluate(txIEvalContext* aContext,
txAExprResult** aResult) = 0;
/**
* Returns the type of this expression.
*/
enum ExprType {
LOCATIONSTEP_EXPR,
PATH_EXPR,
UNION_EXPR,
LITERAL_EXPR,
OTHER_EXPR
};
virtual ExprType getType() { return OTHER_EXPR; }
/**
* Returns the type or types of results this Expr return.
*/
using ResultType = uint16_t;
enum {
NODESET_RESULT = 0x01,
BOOLEAN_RESULT = 0x02,
NUMBER_RESULT = 0x04,
STRING_RESULT = 0x08,
RTF_RESULT = 0x10,
ANY_RESULT = 0xFFFF
};
virtual ResultType getReturnType() = 0;
bool canReturnType(ResultType aType) {
return (getReturnType() & aType) != 0;
}
using ContextSensitivity = uint16_t;
enum {
NO_CONTEXT = 0x00,
NODE_CONTEXT = 0x01,
POSITION_CONTEXT = 0x02,
SIZE_CONTEXT = 0x04,
NODESET_CONTEXT = POSITION_CONTEXT | SIZE_CONTEXT,
VARIABLES_CONTEXT = 0x08,
PRIVATE_CONTEXT = 0x10,
ANY_CONTEXT = 0xFFFF
};
/**
* Returns true if this expression is sensitive to *any* of
* the requested contexts in aContexts.
*/
virtual bool isSensitiveTo(ContextSensitivity aContexts) = 0;
/**
* Returns sub-expression at given position
*/
virtual Expr* getSubExprAt(uint32_t aPos) = 0;
/**
* Replace sub-expression at given position. Does not delete the old
* expression, that is the responsibility of the caller.
*/
virtual void setSubExprAt(uint32_t aPos, Expr* aExpr) = 0;
virtual nsresult evaluateToBool(txIEvalContext* aContext, bool& aResult);
virtual nsresult evaluateToString(txIEvalContext* aContext,
nsString& aResult);
#ifdef TX_TO_STRING
/**
* Returns the String representation of this Expr.
* @param dest the String to use when creating the String
* representation. The String representation will be appended to
* any data in the destination String, to allow cascading calls to
* other #toString() methods for Expressions.
* @return the String representation of this Expr.
**/
virtual void toString(nsAString& str) = 0;
#endif
}; //-- Expr
#ifdef TX_TO_STRING
# define TX_DECL_TOSTRING void toString(nsAString& aDest) override;
# define TX_DECL_APPENDNAME void appendName(nsAString& aDest) override;
#else
# define TX_DECL_TOSTRING
# define TX_DECL_APPENDNAME
#endif
#define TX_DECL_EXPR_BASE \
nsresult evaluate(txIEvalContext* aContext, txAExprResult** aResult) \
override; \
ResultType getReturnType() override; \
bool isSensitiveTo(ContextSensitivity aContexts) override;
#define TX_DECL_EXPR \
TX_DECL_EXPR_BASE \
TX_DECL_TOSTRING \
Expr* getSubExprAt(uint32_t aPos) override; \
void setSubExprAt(uint32_t aPos, Expr* aExpr) override;
#define TX_DECL_OPTIMIZABLE_EXPR \
TX_DECL_EXPR \
ExprType getType() override;
#define TX_DECL_FUNCTION \
TX_DECL_APPENDNAME \
TX_DECL_EXPR_BASE
#define TX_IMPL_EXPR_STUBS_BASE(_class, _ReturnType) \
Expr::ResultType _class::getReturnType() { return _ReturnType; }
#define TX_IMPL_EXPR_STUBS_0(_class, _ReturnType) \
TX_IMPL_EXPR_STUBS_BASE(_class, _ReturnType) \
Expr* _class::getSubExprAt(uint32_t aPos) { return nullptr; } \
void _class::setSubExprAt(uint32_t aPos, Expr* aExpr) { \
MOZ_ASSERT_UNREACHABLE("setting bad subexpression index"); \
}
#define TX_IMPL_EXPR_STUBS_1(_class, _ReturnType, _Expr1) \
TX_IMPL_EXPR_STUBS_BASE(_class, _ReturnType) \
Expr* _class::getSubExprAt(uint32_t aPos) { \
if (aPos == 0) { \
return _Expr1.get(); \
} \
return nullptr; \
} \
void _class::setSubExprAt(uint32_t aPos, Expr* aExpr) { \
NS_ASSERTION(aPos < 1, "setting bad subexpression index"); \
mozilla::Unused << _Expr1.release(); \
_Expr1 = mozilla::WrapUnique(aExpr); \
}
#define TX_IMPL_EXPR_STUBS_2(_class, _ReturnType, _Expr1, _Expr2) \
TX_IMPL_EXPR_STUBS_BASE(_class, _ReturnType) \
Expr* _class::getSubExprAt(uint32_t aPos) { \
switch (aPos) { \
case 0: \
return _Expr1.get(); \
case 1: \
return _Expr2.get(); \
default: \
break; \
} \
return nullptr; \
} \
void _class::setSubExprAt(uint32_t aPos, Expr* aExpr) { \
NS_ASSERTION(aPos < 2, "setting bad subexpression index"); \
if (aPos == 0) { \
mozilla::Unused << _Expr1.release(); \
_Expr1 = mozilla::WrapUnique(aExpr); \
} else { \
mozilla::Unused << _Expr2.release(); \
_Expr2 = mozilla::WrapUnique(aExpr); \
} \
}
#define TX_IMPL_EXPR_STUBS_LIST(_class, _ReturnType, _ExprList) \
TX_IMPL_EXPR_STUBS_BASE(_class, _ReturnType) \
Expr* _class::getSubExprAt(uint32_t aPos) { \
return _ExprList.SafeElementAt(aPos); \
} \
void _class::setSubExprAt(uint32_t aPos, Expr* aExpr) { \
NS_ASSERTION(aPos < _ExprList.Length(), \
"setting bad subexpression index"); \
_ExprList[aPos] = aExpr; \
}
/**
* This class represents a FunctionCall as defined by the XPath 1.0
* Recommendation.
**/
class FunctionCall : public Expr {
public:
/**
* Adds the given parameter to this FunctionCall's parameter list.
* The ownership of the given Expr is passed over to the FunctionCall,
* even on failure.
* @param aExpr the Expr to add to this FunctionCall's parameter list
*/
void addParam(Expr* aExpr) { mParams.AppendElement(aExpr); }
/**
* Check if the number of parameters falls within a range.
*
* @param aParamCountMin minimum number of required parameters.
* @param aParamCountMax maximum number of parameters. If aParamCountMax
* is negative the maximum number is not checked.
* @return boolean representing whether the number of parameters falls
* within the expected range or not.
*
*/
virtual bool requireParams(int32_t aParamCountMin, int32_t aParamCountMax,
txIEvalContext* aContext);
TX_DECL_TOSTRING
Expr* getSubExprAt(uint32_t aPos) override;
void setSubExprAt(uint32_t aPos, Expr* aExpr) override;
protected:
txOwningArray<Expr> mParams;
/*
* Evaluates the given Expression and converts its result to a number.
*/
static nsresult evaluateToNumber(Expr* aExpr, txIEvalContext* aContext,
double* aResult);
/*
* Evaluates the given Expression and converts its result to a NodeSet.
* If the result is not a NodeSet an error is returned.
*/
static nsresult evaluateToNodeSet(Expr* aExpr, txIEvalContext* aContext,
txNodeSet** aResult);
/**
* Returns true if any argument is sensitive to the given context.
*/
bool argsSensitiveTo(ContextSensitivity aContexts);
#ifdef TX_TO_STRING
/*
* Appends the name of the function to `aStr`.
*/
virtual void appendName(nsAString& aStr) = 0;
#endif
};
class txCoreFunctionCall : public FunctionCall {
public:
// This must be ordered in the same order as descriptTable in
// txCoreFunctionCall.cpp. If you change one, change the other.
enum eType {
COUNT = 0, // count()
ID, // id()
LAST, // last()
LOCAL_NAME, // local-name()
NAMESPACE_URI, // namespace-uri()
NAME, // name()
POSITION, // position()
CONCAT, // concat()
CONTAINS, // contains()
NORMALIZE_SPACE, // normalize-space()
STARTS_WITH, // starts-with()
STRING, // string()
STRING_LENGTH, // string-length()
SUBSTRING, // substring()
SUBSTRING_AFTER, // substring-after()
SUBSTRING_BEFORE, // substring-before()
TRANSLATE, // translate()
NUMBER, // number()
ROUND, // round()
FLOOR, // floor()
CEILING, // ceiling()
SUM, // sum()
BOOLEAN, // boolean()
_FALSE, // false()
LANG, // lang()
_NOT, // not()
_TRUE // true()
};
/*
* Creates a txCoreFunctionCall of the given type
*/
explicit txCoreFunctionCall(eType aType) : mType(aType) {}
TX_DECL_FUNCTION
static bool getTypeFromAtom(nsAtom* aName, eType& aType);
private:
eType mType;
};
/*
* This class represents a NodeTest as defined by the XPath spec
*/
class txNodeTest {
public:
MOZ_COUNTED_DEFAULT_CTOR(txNodeTest)
MOZ_COUNTED_DTOR_VIRTUAL(txNodeTest)
/*
* Virtual methods
* pretty much a txPattern, but not supposed to be used
* standalone. The NodeTest node() is different to the
* Pattern "node()" (document node isn't matched)
*/
virtual nsresult matches(const txXPathNode& aNode, txIMatchContext* aContext,
bool& aMatched) = 0;
virtual double getDefaultPriority() = 0;
/**
* Returns the type of this nodetest.
*/
enum NodeTestType { NAME_TEST, NODETYPE_TEST, OTHER_TEST };
virtual NodeTestType getType() { return OTHER_TEST; }
/**
* Returns true if this expression is sensitive to *any* of
* the requested flags.
*/
virtual bool isSensitiveTo(Expr::ContextSensitivity aContext) = 0;
#ifdef TX_TO_STRING
virtual void toString(nsAString& aDest) = 0;
#endif
};
#define TX_DECL_NODE_TEST \
TX_DECL_TOSTRING \
nsresult matches(const txXPathNode& aNode, txIMatchContext* aContext, \
bool& aMatched) override; \
double getDefaultPriority() override; \
bool isSensitiveTo(Expr::ContextSensitivity aContext) override;
/*
* This class represents a NameTest as defined by the XPath spec
*/
class txNameTest : public txNodeTest {
public:
/*
* Creates a new txNameTest with the given type and the given
* principal node type
*/
txNameTest(nsAtom* aPrefix, nsAtom* aLocalName, int32_t aNSID,
uint16_t aNodeType);
NodeTestType getType() override;
TX_DECL_NODE_TEST
RefPtr<nsAtom> mPrefix;
RefPtr<nsAtom> mLocalName;
int32_t mNamespace;
private:
uint16_t mNodeType;
};
/*
* This class represents a NodeType as defined by the XPath spec
*/
class txNodeTypeTest : public txNodeTest {
public:
enum NodeType { COMMENT_TYPE, TEXT_TYPE, PI_TYPE, NODE_TYPE };
/*
* Creates a new txNodeTypeTest of the given type
*/
explicit txNodeTypeTest(NodeType aNodeType) : mNodeType(aNodeType) {}
/*
* Sets the name of the node to match. Only availible for pi nodes
*/
void setNodeName(const nsAString& aName) { mNodeName = NS_Atomize(aName); }
NodeType getNodeTestType() { return mNodeType; }
NodeTestType getType() override;
TX_DECL_NODE_TEST
private:
NodeType mNodeType;
RefPtr<nsAtom> mNodeName;
};
/**
* Class representing a nodetest combined with a predicate. May only be used
* if the predicate is not sensitive to the context-nodelist.
*/
class txPredicatedNodeTest : public txNodeTest {
public:
txPredicatedNodeTest(txNodeTest* aNodeTest, Expr* aPredicate);
TX_DECL_NODE_TEST
private:
mozilla::UniquePtr<txNodeTest> mNodeTest;
mozilla::UniquePtr<Expr> mPredicate;
};
/**
* Represents an ordered list of Predicates,
* for use with Step and Filter Expressions
**/
class PredicateList {
public:
/**
* Adds the given Expr to the list.
* The ownership of the given Expr is passed over the PredicateList,
* even on failure.
* @param aExpr the Expr to add to the list
*/
void add(Expr* aExpr) {
NS_ASSERTION(aExpr, "missing expression");
mPredicates.AppendElement(aExpr);
}
nsresult evaluatePredicates(txNodeSet* aNodes, txIMatchContext* aContext);
/**
* Drops the first predicate without deleting it.
*/
void dropFirst() { mPredicates.RemoveElementAt(0); }
/**
* returns true if this predicate list is empty
**/
bool isEmpty() { return mPredicates.IsEmpty(); }
#ifdef TX_TO_STRING
/**
* Returns the String representation of this PredicateList.
* @param dest the String to use when creating the String
* representation. The String representation will be appended to
* any data in the destination String, to allow cascading calls to
* other #toString() methods for Expressions.
* @return the String representation of this PredicateList.
**/
void toString(nsAString& dest);
#endif
protected:
bool isSensitiveTo(Expr::ContextSensitivity aContext);
Expr* getSubExprAt(uint32_t aPos) { return mPredicates.SafeElementAt(aPos); }
void setSubExprAt(uint32_t aPos, Expr* aExpr) {
NS_ASSERTION(aPos < mPredicates.Length(),
"setting bad subexpression index");
mPredicates[aPos] = aExpr;
}
//-- list of predicates
txOwningArray<Expr> mPredicates;
}; //-- PredicateList
class LocationStep : public Expr, public PredicateList {
public:
enum LocationStepType {
ANCESTOR_AXIS = 0,
ANCESTOR_OR_SELF_AXIS,
ATTRIBUTE_AXIS,
CHILD_AXIS,
DESCENDANT_AXIS,
DESCENDANT_OR_SELF_AXIS,
FOLLOWING_AXIS,
FOLLOWING_SIBLING_AXIS,
NAMESPACE_AXIS,
PARENT_AXIS,
PRECEDING_AXIS,
PRECEDING_SIBLING_AXIS,
SELF_AXIS
};
/**
* Creates a new LocationStep using the given NodeExpr and Axis Identifier
* @param nodeExpr the NodeExpr to use when matching Nodes
* @param axisIdentifier the Axis Identifier in which to search for nodes
**/
LocationStep(txNodeTest* aNodeTest, LocationStepType aAxisIdentifier)
: mNodeTest(aNodeTest), mAxisIdentifier(aAxisIdentifier) {}
TX_DECL_OPTIMIZABLE_EXPR
txNodeTest* getNodeTest() { return mNodeTest.get(); }
void setNodeTest(txNodeTest* aNodeTest) {
mozilla::Unused << mNodeTest.release();
mNodeTest = mozilla::WrapUnique(aNodeTest);
}
LocationStepType getAxisIdentifier() { return mAxisIdentifier; }
void setAxisIdentifier(LocationStepType aAxisIdentifier) {
mAxisIdentifier = aAxisIdentifier;
}
private:
/**
* Append the current position of aWalker to aNodes if it matches mNodeTest,
* using aContext as the context for matching.
*/
nsresult appendIfMatching(const txXPathTreeWalker& aWalker,
txIMatchContext* aContext, txNodeSet* aNodes);
/**
* Append the descendants of the current position of aWalker to aNodes if
* they match mNodeTest, using aContext as the context for matching.
*/
nsresult appendMatchingDescendants(const txXPathTreeWalker& aWalker,
txIMatchContext* aContext,
txNodeSet* aNodes);
/**
* Append the descendants of the current position of aWalker to aNodes in
* reverse order if they match mNodeTest, using aContext as the context for
* matching.
*/
nsresult appendMatchingDescendantsRev(const txXPathTreeWalker& aWalker,
txIMatchContext* aContext,
txNodeSet* aNodes);
mozilla::UniquePtr<txNodeTest> mNodeTest;
LocationStepType mAxisIdentifier;
};
class FilterExpr : public Expr, public PredicateList {
public:
/**
* Creates a new FilterExpr using the given Expr
* @param expr the Expr to use for evaluation
*/
explicit FilterExpr(Expr* aExpr) : expr(aExpr) {}
TX_DECL_EXPR
private:
mozilla::UniquePtr<Expr> expr;
}; //-- FilterExpr
class txLiteralExpr : public Expr {
public:
explicit txLiteralExpr(double aDbl)
: mValue(new NumberResult(aDbl, nullptr)) {}
explicit txLiteralExpr(const nsAString& aStr)
: mValue(new StringResult(aStr, nullptr)) {}
explicit txLiteralExpr(txAExprResult* aValue) : mValue(aValue) {}
TX_DECL_EXPR
private:
RefPtr<txAExprResult> mValue;
};
/**
* Represents an UnaryExpr. Returns the negative value of its expr.
**/
class UnaryExpr : public Expr {
public:
explicit UnaryExpr(Expr* aExpr) : expr(aExpr) {}
TX_DECL_EXPR
private:
mozilla::UniquePtr<Expr> expr;
}; //-- UnaryExpr
/**
* Represents a BooleanExpr, a binary expression that
* performs a boolean operation between its lvalue and rvalue.
**/
class BooleanExpr : public Expr {
public:
//-- BooleanExpr Types
enum _BooleanExprType { AND = 1, OR };
BooleanExpr(Expr* aLeftExpr, Expr* aRightExpr, short aOp)
: leftExpr(aLeftExpr), rightExpr(aRightExpr), op(aOp) {}
TX_DECL_EXPR
private:
mozilla::UniquePtr<Expr> leftExpr, rightExpr;
short op;
}; //-- BooleanExpr
/**
* Represents a MultiplicativeExpr, a binary expression that
* performs a multiplicative operation between its lvalue and rvalue:
* * : multiply
* mod : modulus
* div : divide
*
**/
class txNumberExpr : public Expr {
public:
enum eOp { ADD, SUBTRACT, DIVIDE, MULTIPLY, MODULUS };
txNumberExpr(Expr* aLeftExpr, Expr* aRightExpr, eOp aOp)
: mLeftExpr(aLeftExpr), mRightExpr(aRightExpr), mOp(aOp) {}
TX_DECL_EXPR
private:
mozilla::UniquePtr<Expr> mLeftExpr, mRightExpr;
eOp mOp;
}; //-- MultiplicativeExpr
/**
* Represents a RelationalExpr, an expression that compares its lvalue
* to its rvalue using:
* = : equal to
* < : less than
* > : greater than
* <= : less than or equal to
* >= : greater than or equal to
*
**/
class RelationalExpr : public Expr {
public:
enum RelationalExprType {
EQUAL,
NOT_EQUAL,
LESS_THAN,
GREATER_THAN,
LESS_OR_EQUAL,
GREATER_OR_EQUAL
};
RelationalExpr(Expr* aLeftExpr, Expr* aRightExpr, RelationalExprType aOp)
: mLeftExpr(aLeftExpr), mRightExpr(aRightExpr), mOp(aOp) {}
TX_DECL_EXPR
private:
bool compareResults(txIEvalContext* aContext, txAExprResult* aLeft,
txAExprResult* aRight);
mozilla::UniquePtr<Expr> mLeftExpr;
mozilla::UniquePtr<Expr> mRightExpr;
RelationalExprType mOp;
};
/**
* VariableRefExpr
* Represents a variable reference ($refname)
**/
class VariableRefExpr : public Expr {
public:
VariableRefExpr(nsAtom* aPrefix, nsAtom* aLocalName, int32_t aNSID);
TX_DECL_EXPR
private:
RefPtr<nsAtom> mPrefix;
RefPtr<nsAtom> mLocalName;
int32_t mNamespace;
};
/**
* Represents a PathExpr
**/
class PathExpr : public Expr {
public:
//-- Path Operators
//-- RELATIVE_OP is the default
//-- LF, changed from static const short to enum
enum PathOperator { RELATIVE_OP, DESCENDANT_OP };
/**
* Adds the Expr to this PathExpr
* The ownership of the given Expr is passed over the PathExpr,
* even on failure.
* @param aExpr the Expr to add to this PathExpr
*/
void addExpr(Expr* aExpr, PathOperator pathOp);
/**
* Removes and deletes the expression at the given index.
*/
void deleteExprAt(uint32_t aPos) {
NS_ASSERTION(aPos < mItems.Length(), "killing bad expression index");
mItems.RemoveElementAt(aPos);
}
TX_DECL_OPTIMIZABLE_EXPR
PathOperator getPathOpAt(uint32_t aPos) {
NS_ASSERTION(aPos < mItems.Length(), "getting bad pathop index");
return mItems[aPos].pathOp;
}
void setPathOpAt(uint32_t aPos, PathOperator aPathOp) {
NS_ASSERTION(aPos < mItems.Length(), "setting bad pathop index");
mItems[aPos].pathOp = aPathOp;
}
private:
class PathExprItem {
public:
mozilla::UniquePtr<Expr> expr;
PathOperator pathOp;
};
nsTArray<PathExprItem> mItems;
/*
* Selects from the descendants of the context node
* all nodes that match the Expr
*/
nsresult evalDescendants(Expr* aStep, const txXPathNode& aNode,
txIMatchContext* aContext, txNodeSet* resNodes);
};
/**
* This class represents a RootExpr, which only matches the Document node
**/
class RootExpr : public Expr {
public:
/**
* Creates a new RootExpr
*/
RootExpr()
#ifdef TX_TO_STRING
: mSerialize(true)
#endif
{
}
TX_DECL_EXPR
#ifdef TX_TO_STRING
public:
void setSerialize(bool aSerialize) { mSerialize = aSerialize; }
private:
// When a RootExpr is used in a PathExpr it shouldn't be serialized
bool mSerialize;
#endif
}; //-- RootExpr
/**
* Represents a UnionExpr
**/
class UnionExpr : public Expr {
public:
/**
* Adds the PathExpr to this UnionExpr
* The ownership of the given Expr is passed over the UnionExpr,
* even on failure.
* @param aExpr the Expr to add to this UnionExpr
*/
void addExpr(Expr* aExpr) { mExpressions.AppendElement(aExpr); }
/**
* Removes and deletes the expression at the given index.
*/
void deleteExprAt(uint32_t aPos) {
NS_ASSERTION(aPos < mExpressions.Length(), "killing bad expression index");
delete mExpressions[aPos];
mExpressions.RemoveElementAt(aPos);
}
TX_DECL_OPTIMIZABLE_EXPR
private:
txOwningArray<Expr> mExpressions;
}; //-- UnionExpr
/**
* Class specializing in executing expressions like "@foo" where we are
* interested in different result-types, and expressions like "@foo = 'hi'"
*/
class txNamedAttributeStep : public Expr {
public:
txNamedAttributeStep(int32_t aNsID, nsAtom* aPrefix, nsAtom* aLocalName);
TX_DECL_EXPR
private:
int32_t mNamespace;
RefPtr<nsAtom> mPrefix;
RefPtr<nsAtom> mLocalName;
};
/**
*
*/
class txUnionNodeTest : public txNodeTest {
public:
void addNodeTest(txNodeTest* aNodeTest) {
mNodeTests.AppendElement(aNodeTest);
}
TX_DECL_NODE_TEST
private:
txOwningArray<txNodeTest> mNodeTests;
};
/**
* Expression that failed to parse
*/
class txErrorExpr : public Expr {
public:
#ifdef TX_TO_STRING
explicit txErrorExpr(const nsAString& aStr) : mStr(aStr) {}
#endif
TX_DECL_EXPR
#ifdef TX_TO_STRING
private:
nsString mStr;
#endif
};
#endif