net.sf.saxon.instruct

Class ProcessingInstruction

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

public class ProcessingInstruction
extends SimpleNodeConstructor

An xsl:processing-instruction element in the stylesheet, or a processing-instruction constructor in a query

Field Summary

Fields inherited from class net.sf.saxon.instruct.SimpleNodeConstructor

select

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

EVALUATE_METHOD, ITERATE_METHOD, PROCESS_METHOD, locationId, staticProperties

Constructor Summary

ProcessingInstruction(Expression name)
Create an xsl:processing-instruction instruction

Method Summary

protected String
checkContent(String data, XPathContext context)
Check the content of the node, and adjust it if necessary
Expression
copy()
Copy an expression.
int
evaluateNameCode(XPathContext context)
Run-time method to compute the name of the node being constructed.
void
explain(ExpressionPresenter out)
Diagnostic print of expression structure.
int
getCardinality()
Determine the static cardinality of the expression.
int
getDependencies()
Determine which aspects of the context the expression depends on.
int
getInstructionNameCode()
Get the name of this instruction for diagnostic and tracing purposes
ItemType
getItemType(TypeHierarchy th)
Determine the data type of the expression, if possible.
Expression
getNameExpression()
Get the expression that defines the processing instruction name
Iterator
iterateSubExpressions()
Get the immediate sub-expressions of this expression.
void
localTypeCheck(ExpressionVisitor visitor, ItemType contextItemType)
Method to perform type-checking specific to the kind of instruction
TailCall
processLeavingTail(XPathContext context)
Process this instruction, that is, produce a processing-instruction node in the result sequence.
protected void
promoteInst(PromotionOffer offer)
Offer promotion for subexpressions.
boolean
replaceSubExpression(Expression original, Expression replacement)
Replace one subexpression by a replacement subexpression
Expression
simplify(ExpressionVisitor visitor)
Simplify an expression.

Methods inherited from class net.sf.saxon.instruct.SimpleNodeConstructor

checkContent, computeCardinality, computeSpecialProperties, createsNewNodes, evaluateItem, evaluateNameCode, expandChildren, getSelect, iterate, iterateSubExpressions, localTypeCheck, optimize, promoteInst, replaceSubExpression, setSelect, simplify, typeCheck

Methods inherited from class net.sf.saxon.instruct.Instruction

assembleParams, assembleTunnelParams, computeCardinality, computeSpecialProperties, createsNewNodes, dynamicError, evaluateAsString, evaluateItem, getImplementationMethod, getInstructionInfo, getInstructionNameCode, getItemType, getSourceLocator, isXSLT, iterate, process, processLeavingTail, promote, promoteInst, simplify

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

ProcessingInstruction

public ProcessingInstruction(Expression name)
Create an xsl:processing-instruction instruction
Parameters:
name - the expression used to compute the name of the generated processing-instruction

Method Details

checkContent

protected String checkContent(String data,
                              XPathContext context)
            throws XPathException
Check the content of the node, and adjust it if necessary
Overrides:
checkContent in interface SimpleNodeConstructor
Parameters:
data - the supplied content
Returns:
the original content, unless adjustments are needed
Throws:
XPathException - if the content is invalid

copy

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

evaluateNameCode

public int evaluateNameCode(XPathContext context)
            throws XPathException
Run-time method to compute the name of the node being constructed. This is overridden for nodes that have a name. The default implementation returns -1, which is suitable for unnamed nodes such as comments
Overrides:
evaluateNameCode in interface SimpleNodeConstructor
Parameters:
context - the XPath dynamic evaluation context
Returns:
the name pool nameCode identifying the name of the constructed node
Throws:
XPathException - if any failure occurs

explain

public void explain(ExpressionPresenter out)
Diagnostic print of expression structure. The abstract expression tree is written to the supplied output destination.
Overrides:
explain in interface Expression

getCardinality

public int getCardinality()
Determine the static cardinality of the expression. This establishes how many items there will be in the result of the expression, at compile time (i.e., without actually evaluating the result.
Overrides:
getCardinality in interface Expression
Returns:
one of the values Cardinality.ONE_OR_MORE, Cardinality.ZERO_OR_MORE, Cardinality.EXACTLY_ONE, Cardinality.ZERO_OR_ONE, Cardinality.EMPTY. This default implementation returns ZERO_OR_MORE (which effectively gives no information).

getDependencies

public int getDependencies()
Determine which aspects of the context the expression depends on. The result is a bitwise-or'ed value composed from constants such as XPathContext.VARIABLES and XPathContext.CURRENT_NODE. The default implementation combines the intrinsic dependencies of this expression with the dependencies of the subexpressions, computed recursively. This is overridden for expressions such as FilterExpression where a subexpression's dependencies are not necessarily inherited by the parent expression.
Overrides:
getDependencies in interface Expression
Returns:
a set of bit-significant flags identifying the dependencies of the expression

getInstructionNameCode

public int getInstructionNameCode()
Get the name of this instruction for diagnostic and tracing purposes
Overrides:
getInstructionNameCode in interface Instruction
Returns:
the string "xsl:processing-instruction"

getItemType

public ItemType getItemType(TypeHierarchy th)
Determine the data type of the expression, if possible. All expression return sequences, in general; this method determines the type of the items within the sequence, assuming that (a) this is known in advance, and (b) it is the same for all items in the sequence.

This method should always return a result, though it may be the best approximation that is available at the time.

Overrides:
getItemType in interface Instruction
Parameters:
th - the type hierarchy cache
Returns:
a value such as Type.STRING, Type.BOOLEAN, Type.NUMBER, Type.NODE, or Type.ITEM (meaning not known at compile time)

getNameExpression

public Expression getNameExpression()
Get the expression that defines the processing instruction name
Returns:
the expression that defines the processing instruction name

iterateSubExpressions

public Iterator iterateSubExpressions()
Get the immediate sub-expressions of this expression. Default implementation returns a zero-length array, appropriate for an expression that has no sub-expressions.
Overrides:
iterateSubExpressions in interface SimpleNodeConstructor
Returns:
an iterator containing the sub-expressions of this expression

localTypeCheck

public void localTypeCheck(ExpressionVisitor visitor,
                           ItemType contextItemType)
            throws XPathException
Method to perform type-checking specific to the kind of instruction
Overrides:
localTypeCheck in interface SimpleNodeConstructor
Parameters:
visitor - an expression visitor
contextItemType - the static type of the context item
Throws:
XPathException -

processLeavingTail

public TailCall processLeavingTail(XPathContext context)
            throws XPathException
Process this instruction, that is, produce a processing-instruction node in the result sequence.
Specified by:
processLeavingTail in interface TailCallReturner
Overrides:
processLeavingTail in interface Instruction
Parameters:
context - the dynamic context of this transformation
Returns:
always returns null in this implementation
Throws:
XPathException - if any non-recoverable dynamic error occurs

promoteInst

protected void promoteInst(PromotionOffer offer)
            throws XPathException
Offer promotion for subexpressions. The offer will be accepted if the subexpression is not dependent on the factors (e.g. the context item) identified in the PromotionOffer. By default the offer is not accepted - this is appropriate in the case of simple expressions such as constant values and variable references where promotion would give no performance advantage. This method is always called at compile time.
Overrides:
promoteInst in interface SimpleNodeConstructor
Parameters:
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
Throws:
XPathException - if any error is detected

replaceSubExpression

public boolean replaceSubExpression(Expression original,
                                    Expression replacement)
Replace one subexpression by a replacement subexpression
Overrides:
replaceSubExpression in interface SimpleNodeConstructor
Parameters:
original - the original subexpression
replacement - the replacement subexpression
Returns:
true if the original subexpression is found

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 SimpleNodeConstructor
Parameters:
visitor - an expression visitor
Returns:
the simplified expression
Throws:
XPathException - if an error is discovered during expression rewriting