mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-09-10 11:54:40 +00:00
1005 lines
26 KiB
C++
1005 lines
26 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/* 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
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#ifndef TRANSFRMX_EXPR_H
|
|
#define TRANSFRMX_EXPR_H
|
|
|
|
#include "mozilla/Attributes.h"
|
|
#include "nsAutoPtr.h"
|
|
#include "txExprResult.h"
|
|
#include "txCore.h"
|
|
#include "nsString.h"
|
|
#include "txOwningArray.h"
|
|
#include "nsIAtom.h"
|
|
|
|
#ifdef DEBUG
|
|
#define TX_TO_STRING
|
|
#endif
|
|
|
|
/*
|
|
XPath class definitions.
|
|
Much of this code was ported from XSL:P.
|
|
*/
|
|
|
|
class nsIAtom;
|
|
class txIMatchContext;
|
|
class txIEvalContext;
|
|
class txNodeSet;
|
|
class txXPathNode;
|
|
|
|
/**
|
|
* A Base Class for all XSL Expressions
|
|
**/
|
|
class Expr
|
|
{
|
|
public:
|
|
Expr()
|
|
{
|
|
MOZ_COUNT_CTOR(Expr);
|
|
}
|
|
virtual ~Expr()
|
|
{
|
|
MOZ_COUNT_DTOR(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.
|
|
*/
|
|
typedef uint16_t ResultType;
|
|
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;
|
|
}
|
|
|
|
typedef uint16_t ContextSensitivity;
|
|
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_GETNAMEATOM \
|
|
nsresult getNameAtom(nsIAtom** aAtom) override;
|
|
#else
|
|
#define TX_DECL_TOSTRING
|
|
#define TX_DECL_GETNAMEATOM
|
|
#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_GETNAMEATOM \
|
|
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) \
|
|
{ \
|
|
NS_NOTREACHED("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; \
|
|
} \
|
|
return nullptr; \
|
|
} \
|
|
void \
|
|
_class::setSubExprAt(uint32_t aPos, Expr* aExpr) \
|
|
{ \
|
|
NS_ASSERTION(aPos < 1, "setting bad subexpression index");\
|
|
_Expr1.forget(); \
|
|
_Expr1 = 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; \
|
|
case 1: \
|
|
return _Expr2; \
|
|
default: \
|
|
break; \
|
|
} \
|
|
return nullptr; \
|
|
} \
|
|
void \
|
|
_class::setSubExprAt(uint32_t aPos, Expr* aExpr) \
|
|
{ \
|
|
NS_ASSERTION(aPos < 2, "setting bad subexpression index");\
|
|
if (aPos == 0) { \
|
|
_Expr1.forget(); \
|
|
_Expr1 = aExpr; \
|
|
} \
|
|
else { \
|
|
_Expr2.forget(); \
|
|
_Expr2 = 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
|
|
* @return nsresult indicating out of memory
|
|
*/
|
|
nsresult addParam(Expr* aExpr)
|
|
{
|
|
return mParams.AppendElement(aExpr) ?
|
|
NS_OK : NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* XXX txIEvalContext should be txIParseContest, bug 143291
|
|
*/
|
|
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
|
|
/*
|
|
* Returns the name of the function as an atom.
|
|
*/
|
|
virtual nsresult getNameAtom(nsIAtom** aAtom) = 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(nsIAtom* aName, eType& aType);
|
|
|
|
private:
|
|
eType mType;
|
|
};
|
|
|
|
|
|
/*
|
|
* This class represents a NodeTest as defined by the XPath spec
|
|
*/
|
|
class txNodeTest
|
|
{
|
|
public:
|
|
txNodeTest()
|
|
{
|
|
MOZ_COUNT_CTOR(txNodeTest);
|
|
}
|
|
virtual ~txNodeTest()
|
|
{
|
|
MOZ_COUNT_DTOR(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 bool matches(const txXPathNode& aNode,
|
|
txIMatchContext* aContext) = 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 \
|
|
bool matches(const txXPathNode& aNode, txIMatchContext* aContext) 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(nsIAtom* aPrefix, nsIAtom* aLocalName, int32_t aNSID,
|
|
uint16_t aNodeType);
|
|
|
|
NodeTestType getType() override;
|
|
|
|
TX_DECL_NODE_TEST
|
|
|
|
nsCOMPtr<nsIAtom> mPrefix;
|
|
nsCOMPtr<nsIAtom> 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 = do_GetAtom(aName);
|
|
}
|
|
|
|
NodeType getNodeTestType()
|
|
{
|
|
return mNodeType;
|
|
}
|
|
|
|
NodeTestType getType() override;
|
|
|
|
TX_DECL_NODE_TEST
|
|
|
|
private:
|
|
NodeType mNodeType;
|
|
nsCOMPtr<nsIAtom> 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:
|
|
nsAutoPtr<txNodeTest> mNodeTest;
|
|
nsAutoPtr<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
|
|
* @return nsresult indicating out of memory
|
|
*/
|
|
nsresult add(Expr* aExpr)
|
|
{
|
|
NS_ASSERTION(aExpr, "missing expression");
|
|
return mPredicates.AppendElement(aExpr) ?
|
|
NS_OK : NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
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;
|
|
}
|
|
void setNodeTest(txNodeTest* aNodeTest)
|
|
{
|
|
mNodeTest.forget();
|
|
mNodeTest = aNodeTest;
|
|
}
|
|
LocationStepType getAxisIdentifier()
|
|
{
|
|
return mAxisIdentifier;
|
|
}
|
|
void setAxisIdentifier(LocationStepType aAxisIdentifier)
|
|
{
|
|
mAxisIdentifier = aAxisIdentifier;
|
|
}
|
|
|
|
private:
|
|
void fromDescendants(const txXPathNode& aNode, txIMatchContext* aCs,
|
|
txNodeSet* aNodes);
|
|
void fromDescendantsRev(const txXPathNode& aNode, txIMatchContext* aCs,
|
|
txNodeSet* aNodes);
|
|
|
|
nsAutoPtr<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:
|
|
nsAutoPtr<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:
|
|
nsAutoPtr<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:
|
|
nsAutoPtr<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:
|
|
nsAutoPtr<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);
|
|
|
|
nsAutoPtr<Expr> mLeftExpr;
|
|
nsAutoPtr<Expr> mRightExpr;
|
|
RelationalExprType mOp;
|
|
};
|
|
|
|
/**
|
|
* VariableRefExpr
|
|
* Represents a variable reference ($refname)
|
|
**/
|
|
class VariableRefExpr : public Expr {
|
|
|
|
public:
|
|
|
|
VariableRefExpr(nsIAtom* aPrefix, nsIAtom* aLocalName, int32_t aNSID);
|
|
|
|
TX_DECL_EXPR
|
|
|
|
private:
|
|
nsCOMPtr<nsIAtom> mPrefix;
|
|
nsCOMPtr<nsIAtom> 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
|
|
* @return nsresult indicating out of memory
|
|
*/
|
|
nsresult 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:
|
|
nsAutoPtr<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
|
|
* @return nsresult indicating out of memory
|
|
*/
|
|
nsresult addExpr(Expr* aExpr)
|
|
{
|
|
return mExpressions.AppendElement(aExpr) ?
|
|
NS_OK : NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
/**
|
|
* 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, nsIAtom* aPrefix,
|
|
nsIAtom* aLocalName);
|
|
|
|
TX_DECL_EXPR
|
|
|
|
private:
|
|
int32_t mNamespace;
|
|
nsCOMPtr<nsIAtom> mPrefix;
|
|
nsCOMPtr<nsIAtom> mLocalName;
|
|
};
|
|
|
|
/**
|
|
*
|
|
*/
|
|
class txUnionNodeTest : public txNodeTest
|
|
{
|
|
public:
|
|
nsresult addNodeTest(txNodeTest* aNodeTest)
|
|
{
|
|
return mNodeTests.AppendElement(aNodeTest) ?
|
|
NS_OK : NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
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
|
|
|
|
|