Abstract superclass for all instructions in the compiled stylesheet.
This represents a compiled instruction, and as such, the minimum information is
retained from the original stylesheet.
Note: this class implements SourceLocator: that is, it can identify where in the stylesheet
the source instruction was located.
assembleParams
protected static ParameterSet assembleParams(XPathContext context,
WithParam[] actualParams)
throws XPathException
Assemble a ParameterSet. Method used by instructions that have xsl:with-param
children. This method is used for the non-tunnel parameters.
context
- the XPath dynamic contextactualParams
- the set of with-param parameters that specify tunnel="no"
assembleTunnelParams
protected static ParameterSet assembleTunnelParams(XPathContext context,
WithParam[] actualParams)
throws XPathException
Assemble a ParameterSet. Method used by instructions that have xsl:with-param
children. This method is used for the tunnel parameters.
context
- the XPath dynamic contextactualParams
- the set of with-param parameters that specify tunnel="yes"
computeCardinality
public int computeCardinality()
Get the cardinality of the sequence returned by evaluating this instruction
- computeCardinality in interface Expression
computeSpecialProperties
public int computeSpecialProperties()
Get the static properties of this expression (other than its type). The result is
bit-signficant. These properties are used for optimizations. In general, if
property bit is set, it is true, but if it is unset, the value is unknown.
- computeSpecialProperties in interface Expression
- a set of flags indicating static properties of this expression
createsNewNodes
public boolean createsNewNodes()
Determine whether this instruction creates new nodes.
This implementation returns a default value of false
- true if the instruction creates new nodes (or if it can't be proved that it doesn't)
dynamicError
protected static XPathException dynamicError(SourceLocator loc,
XPathException error,
XPathContext context)
Construct an exception with diagnostic information. Note that this method
returns the exception, it does not throw it: that is up to the caller.
loc
- the location of the errorerror
- The exception containing information about the errorcontext
- The controller of the transformation
- an exception based on the supplied exception, but with location information
added relating to this instruction
evaluateAsString
public final CharSequence evaluateAsString(XPathContext context)
throws XPathException
Evaluate an expression as a String. This function must only be called in contexts
where it is known that the expression will return a single string (or where an empty sequence
is to be treated as a zero-length string). Implementations should not attempt to convert
the result to a string, other than converting () to "". This method is used mainly to
evaluate expressions produced by compiling an attribute value template.
- evaluateAsString in interface Expression
context
- The context in which the expression is to be evaluated
- the value of the expression, evaluated in the current context.
The expression must return a string or (); if the value of the
expression is (), this method returns "".
XPathException
- if any dynamic error occurs evaluating the
expression
evaluateItem
public Item evaluateItem(XPathContext context)
throws XPathException
Evaluate an expression as a single item. This always returns either a single Item or
null (denoting the empty sequence). No conversion is done. This method should not be
used unless the static type of the expression is a subtype of "item" or "item?": that is,
it should not be called if the expression may return a sequence. There is no guarantee that
this condition will be detected.
- evaluateItem in interface EvaluableItem
- evaluateItem in interface Expression
context
- The context in which the expression is to be evaluated
- the node or atomic value that results from evaluating the
expression; or null to indicate that the result is an empty
sequence
XPathException
- if any dynamic error occurs evaluating the
expression
getImplementationMethod
public int getImplementationMethod()
An implementation of Expression must provide at least one of the methods evaluateItem(), iterate(), or process().
This method indicates which of these methods is prefered. For instructions this is the process() method.
- getImplementationMethod in interface Expression
getInstructionNameCode
public int getInstructionNameCode()
Get the namecode of the instruction for use in diagnostics
- a code identifying the instruction: typically but not always
the fingerprint of a name in the XSLT namespace
getItemType
public ItemType getItemType(TypeHierarchy th)
Get the item type of the items returned by evaluating this instruction
- getItemType in interface Expression
th
- the type hierarchy cache
- the static item type of the instruction
getSourceLocator
public SourceLocator getSourceLocator()
Get a SourceLocator identifying the location of this instruction
- the location of this instruction in the source stylesheet or query
isXSLT
public boolean isXSLT()
Establish whether this is an XSLT instruction or an XQuery instruction
(used to produce appropriate diagnostics)
- true for XSLT, false for XQuery
iterate
public SequenceIterator iterate(XPathContext context)
throws XPathException
Return an Iterator to iterate over the values of a sequence. The value of every
expression can be regarded as a sequence, so this method is supported for all
expressions. This default implementation handles iteration for expressions that
return singleton values: for non-singleton expressions, the subclass must
provide its own implementation.
- iterate in interface SequenceIterable
- iterate in interface Expression
context
- supplies the context for evaluation
- a SequenceIterator that can be used to iterate over the result
of the expression
XPathException
- if any dynamic error occurs evaluating the
expression
process
public void process(XPathContext context)
throws XPathException
Process the instruction, without returning any tail calls
- process in interface Expression
context
- The dynamic context, giving access to the current node,
the current variables, etc.
processLeavingTail
public abstract TailCall processLeavingTail(XPathContext context)
throws XPathException
ProcessLeavingTail: called to do the real work of this instruction. This method
must be implemented in each subclass. The results of the instruction are written
to the current Receiver, which can be obtained via the Controller.
- processLeavingTail in interface TailCallReturner
context
- The dynamic context of the transformation, giving access to the current node,
the current variables, etc.
- null if the instruction has completed execution; or a TailCall indicating
a function call or template call that is delegated to the caller, to be made after the stack has
been unwound so as to save stack space.
promote
public Expression promote(PromotionOffer offer)
throws XPathException
Offer promotion for this subexpression. The offer will be accepted if the subexpression
is not dependent on the factors (e.g. the context item) identified in the PromotionOffer.
This method is always called at compile time.
- promote in interface Expression
offer
- details of the offer, for example the offer to move
expressions that don't depend on the context to an outer level in
the containing expression
- if the offer is not accepted, return this expression unchanged.
Otherwise return the result of rewriting the expression to promote
this subexpression
promoteInst
protected void promoteInst(PromotionOffer offer)
throws XPathException
Handle promotion offers, that is, non-local tree rewrites.
offer
- The type of rewrite being offered
simplify
public abstract 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.
- simplify in interface Expression
visitor
- an expression visitor
- the simplified expression
XPathException
- if an error is discovered during expression
rewriting