net.sf.saxon.expr

Class ArithmeticExpression

Implemented Interfaces:
EvaluableItem, InstructionInfoProvider, SequenceIterable, Serializable, SourceLocator

public class ArithmeticExpression
extends BinaryExpression

Arithmetic Expression: an expression using one of the operators plus, minus, multiply, div, idiv, mod. Note that this code does not handle backwards compatibility mode: see ArithmeticExpression10

Field Summary

Fields inherited from class net.sf.saxon.expr.BinaryExpression

operand0, operand1, operator

Fields inherited from class net.sf.saxon.expr.Expression

EVALUATE_METHOD, ITERATE_METHOD, PROCESS_METHOD, locationId, staticProperties

Constructor Summary

ArithmeticExpression(Expression p0, int operator, Expression p1)
Create an arithmetic expression

Method Summary

static AtomicValue
compute(AtomicValue value0, int operator, AtomicValue value1, XPathContext context)
Static method to apply arithmetic to two values
Expression
copy()
Copy an expression.
Item
evaluateItem(XPathContext context)
Evaluate the expression.
Calculator
getCalculator()
Get the calculator allocated to evaluate this expression
ItemType
getItemType(TypeHierarchy th)
Determine the data type of the expression, insofar as this is known statically
static int
mapOpCode(int op)
Map operator codes from those in the Token class to those in the Calculator class
Expression
simplify(ExpressionVisitor visitor)
Simplify an expression.
Expression
typeCheck(ExpressionVisitor visitor, ItemType contextItemType)
Type-check the expression statically.

Methods inherited from class net.sf.saxon.expr.BinaryExpression

computeCardinality, computeSpecialProperties, displayOperator, equals, explain, getOperands, getOperator, hashCode, isAssociative, isCommutative, isInverse, iterateSubExpressions, optimize, promote, replaceSubExpression, setFlattened, simplify, toString, typeCheck

Methods inherited from class net.sf.saxon.expr.Expression

addToPathMap, adoptChildExpression, checkPermittedContents, computeCardinality, computeDependencies, computeSpecialProperties, computeStaticProperties, copy, display, doPromotion, dynamicError, effectiveBooleanValue, evaluateAsString, evaluateItem, explain, explain, findParentOf, getCardinality, getColumnNumber, getConstructType, getContainer, getDependencies, getExecutable, getHostLanguage, getImplementationMethod, getInstructionInfo, getIntrinsicDependencies, getItemType, getLineNumber, getLocationId, getLocationProvider, getPublicId, getSlotsUsed, getSpecialProperties, getSystemId, hasLoopingSubexpression, implementsStaticTypeCheck, iterate, iterateEvents, iterateSubExpressions, markTailFunctionCalls, optimize, process, promote, replaceSubExpression, resetLocalStaticProperties, setContainer, setFiltered, setFlattened, setLocationId, simplify, staticTypeCheck, suppressValidation, toString, typeCheck, typeError

Constructor Details

ArithmeticExpression

public ArithmeticExpression(Expression p0,
                            int operator,
                            Expression p1)
Create an arithmetic expression
Parameters:
p0 - the first operand
operator - the operator, for example Token.PLUS
p1 - the second operand

Method Details

compute

public static AtomicValue compute(AtomicValue value0,
                                  int operator,
                                  AtomicValue value1,
                                  XPathContext context)
            throws XPathException
Static method to apply arithmetic to two values
Parameters:
value0 - the first value
operator - the operator as denoted in the Calculator class, for example Calculator.PLUS
value1 - the second value
context - the XPath dynamic evaluation context
Returns:
the result of the arithmetic operation

copy

public Expression copy()
Copy an expression. This makes a deep copy.
Overrides:
copy in interface Expression
Returns:
the copy of the original expression

evaluateItem

public Item evaluateItem(XPathContext context)
            throws XPathException
Evaluate the expression.
Specified by:
evaluateItem in interface EvaluableItem
Overrides:
evaluateItem in interface Expression

getCalculator

public Calculator getCalculator()
Get the calculator allocated to evaluate this expression
Returns:
the calculator, a helper object that does the actual calculation

getItemType

public ItemType getItemType(TypeHierarchy th)
Determine the data type of the expression, insofar as this is known statically
Overrides:
getItemType in interface Expression
Parameters:
th - the type hierarchy cache
Returns:
the atomic type of the result of this arithmetic expression

mapOpCode

public static int mapOpCode(int op)
Map operator codes from those in the Token class to those in the Calculator class
Returns:
an operator denoted by a constant defined in the Calculator class, for example Calculator.PLUS

simplify

public Expression simplify(ExpressionVisitor visitor)
            throws XPathException
Simplify an expression. This performs any static optimization (by rewriting the expression as a different expression). The default implementation does nothing.
Overrides:
simplify in interface BinaryExpression
Parameters:
visitor - an expression visitor
Returns:
the simplified expression
Throws:
XPathException - if an error is discovered during expression rewriting

typeCheck

public Expression typeCheck(ExpressionVisitor visitor,
                            ItemType contextItemType)
            throws XPathException
Type-check the expression statically. We try to work out which particular arithmetic function to use if the types of operands are known an compile time.
Overrides:
typeCheck in interface BinaryExpression