/** * preEvaluate: if all arguments are known statically, evaluate early * @param visitor an expression visitor */ public Expression preEvaluate(ExpressionVisitor visitor) throws XPathException { config = visitor.getConfiguration(); return super.preEvaluate(visitor); }
/** * preEvaluate: if all arguments are known statically, evaluate early * @param visitor an expression visitor */ public Expression preEvaluate(ExpressionVisitor visitor) throws XPathException { config = visitor.getConfiguration(); return super.preEvaluate(visitor); }
/** * preEvaluate: if all arguments are known statically, evaluate early * @param visitor an expression visitor */ public Expression preEvaluate(ExpressionVisitor visitor) throws XPathException { config = visitor.getConfiguration(); return super.preEvaluate(visitor); }
/** * Simplify and validate. * @param visitor an expression visitor */ public Expression simplify(ExpressionVisitor visitor) throws XPathException { Atomizer a = new Atomizer(argument[0], visitor.getConfiguration()); ExpressionTool.copyLocationInfo(this, a); return visitor.simplify(a); }
/** * Check whether this specific instance of the expression is negatable * * @return true if it is */ public boolean isNegatable(ExpressionVisitor visitor) { // Expression is not negatable if it might involve NaN TypeHierarchy th = visitor.getConfiguration().getTypeHierarchy(); return !maybeNaN(operand0, th) && !maybeNaN(operand1, th); }
public Expression typeCheck(ExpressionVisitor visitor, ItemType contextItemType) throws XPathException { Expression exp = super.typeCheck(visitor, contextItemType); if (exp instanceof Unordered) { Optimizer opt = visitor.getConfiguration().getOptimizer(); return ExpressionTool.unsorted(opt, ((Unordered)exp).argument[0], false); } return exp; }
/** * Simplify and validate. * @param visitor an expression visitor */ public Expression simplify(ExpressionVisitor visitor) throws XPathException { Atomizer a = new Atomizer(argument[0], visitor.getConfiguration()); ExpressionTool.copyLocationInfo(this, a); return visitor.simplify(a); }
/** * Check whether this specific instance of the expression is negatable * * @return true if it is */ public boolean isNegatable(ExpressionVisitor visitor) { // Expression is not negatable if it might involve NaN TypeHierarchy th = visitor.getConfiguration().getTypeHierarchy(); return !maybeNaN(operand0, th) && !maybeNaN(operand1, th); }
/** * Simplify and validate. * @param visitor an expression visitor */ public Expression simplify(ExpressionVisitor visitor) throws XPathException { Atomizer a = new Atomizer(argument[0], visitor.getConfiguration()); ExpressionTool.copyLocationInfo(this, a); return visitor.simplify(a); }
/** * Static analysis: prevent sorting of the argument */ public void checkArguments(ExpressionVisitor visitor) throws XPathException { super.checkArguments(visitor); Optimizer opt = visitor.getConfiguration().getOptimizer(); argument[0] = ExpressionTool.unsorted(opt, argument[0], false); }
public Expression typeCheck(ExpressionVisitor visitor, ItemType contextItemType) throws XPathException { Expression exp = super.typeCheck(visitor, contextItemType); if (exp instanceof Unordered) { Optimizer opt = visitor.getConfiguration().getOptimizer(); return ExpressionTool.unsorted(opt, ((Unordered)exp).argument[0], true); } return exp; }
public Expression typeCheck(ExpressionVisitor visitor, ItemType contextItemType) throws XPathException { Expression exp = super.typeCheck(visitor, contextItemType); if (exp instanceof Unordered) { Optimizer opt = visitor.getConfiguration().getOptimizer(); return ExpressionTool.unsorted(opt, ((Unordered)exp).argument[0], true); } return exp; }
/** * Type-check the pattern. * Default implementation does nothing. This is only needed for patterns that contain * variable references or function calls. * @return the optimised Pattern */ public Pattern analyze(ExpressionVisitor visitor, ItemType contextItemType) throws XPathException { idExpression = visitor.typeCheck(idExpression, contextItemType); RoleLocator role = new RoleLocator(RoleLocator.FUNCTION, "id", 1, visitor.getConfiguration().getNamePool()); idExpression = TypeChecker.staticTypeCheck(idExpression, SequenceType.ATOMIC_SEQUENCE, false, role, visitor); return this; }
public void checkArguments(ExpressionVisitor visitor) throws XPathException { if (expressionBaseURI == null) { // only do this once. The second call supplies an env pointing to the containing // xsl:template, which has a different base URI (and in a simplified stylesheet, has no base URI) super.checkArguments(visitor); expressionBaseURI = visitor.getStaticContext().getBaseURI(); Optimizer opt = visitor.getConfiguration().getOptimizer(); argument[0] = ExpressionTool.unsorted(opt, argument[0], false); } }
/** * Static analysis: prevent sorting of the argument */ public void checkArguments(ExpressionVisitor visitor) throws XPathException { super.checkArguments(visitor); Optimizer opt = visitor.getConfiguration().getOptimizer(); argument[0] = ExpressionTool.unsorted(opt, argument[0], false); isSingletonId = !Cardinality.allowsMany(argument[0].getCardinality()); }
public void localTypeCheck(ExpressionVisitor visitor, ItemType contextItemType) throws XPathException { // Do early checking of content if known statically if (select instanceof Literal) { String s = ((Literal)select).getValue().getStringValue(); String s2 = checkContent(s, visitor.getStaticContext().makeEarlyEvaluationContext()); if (!s2.equals(s)) { setSelect(new StringLiteral(s2), visitor.getConfiguration()); } } }
public void localTypeCheck(ExpressionVisitor visitor, ItemType contextItemType) throws XPathException { // Do early checking of content if known statically if (select instanceof Literal) { String s = ((Literal)select).getValue().getStringValue(); String s2 = checkContent(s, visitor.getStaticContext().makeEarlyEvaluationContext()); if (!s2.equals(s)) { setSelect(new StringLiteral(s2), visitor.getConfiguration()); } } }
/** * Static analysis: prevent sorting of the argument */ public void checkArguments(ExpressionVisitor visitor) throws XPathException { super.checkArguments(visitor); Optimizer opt = visitor.getConfiguration().getOptimizer(); argument[0] = ExpressionTool.unsorted(opt, argument[0], false); isSingletonId = !Cardinality.allowsMany(argument[0].getCardinality()); }
public Expression optimize(ExpressionVisitor visitor, ItemType contextItemType) throws XPathException { TypeHierarchy th = visitor.getConfiguration().getTypeHierarchy(); setStartExpression(visitor.optimize(start, contextItemType)); setStepExpression(step.optimize(visitor, start.getItemType(th))); return promoteFocusIndependentSubexpressions(visitor, contextItemType); }
public void checkArguments(ExpressionVisitor visitor) throws XPathException { super.checkArguments(visitor); if (stringCollator != null) { int type = argument[0].getItemType(visitor.getConfiguration().getTypeHierarchy()).getPrimitiveType(); atomicComparer = AtomicSortComparer.makeSortComparer( stringCollator, type, visitor.getStaticContext().makeEarlyEvaluationContext()); } }