Abstract superclass for all element nodes in the stylesheet.
Note: this class implements Locator. The element
retains information about its own location in the stylesheet, which is useful when
an XSL error is found.
REPORT_ALWAYS
public static final int REPORT_ALWAYS
- 1
REPORT_IF_INSTANTIATED
public static final int REPORT_IF_INSTANTIATED
- 3
REPORT_UNLESS_FORWARDS_COMPATIBLE
public static final int REPORT_UNLESS_FORWARDS_COMPATIBLE
- 2
attributeSets
protected Vector attributeSets
extensionNamespaces
protected short[] extensionNamespaces
reportingCircumstances
protected int reportingCircumstances
validationError
protected TransformerConfigurationException validationError
version
protected String version
bindVariable
public Binding bindVariable(int fingerprint)
throws XPathException
Bind a variable used in this element to the XSLVariable element in which it is declared
fingerprint
- The fingerprint of the name of the variable
- a Binding for the variable
checkEmpty
public void checkEmpty()
throws TransformerConfigurationException
Convenience method to check that the stylesheet element is empty
checkNotTopLevel
public void checkNotTopLevel()
throws TransformerConfigurationException
Convenience method to check that the stylesheet element is not at the top level
checkTopLevel
public void checkTopLevel()
throws TransformerConfigurationException
Convenience method to check that the stylesheet element is at the top level
checkUnknownAttribute
protected void checkUnknownAttribute(int nc)
throws TransformerConfigurationException
Check whether an unknown attribute is permitted.
nc
- The name code of the attribute name
checkWithinTemplate
public void checkWithinTemplate()
throws TransformerConfigurationException
Check that the stylesheet element is within a template body
compileError
protected void compileError(String message)
throws TransformerConfigurationException
compileError
protected void compileError(TransformerException error)
throws TransformerConfigurationException
Construct an exception with diagnostic information
definesExcludedNamespace
protected boolean definesExcludedNamespace(short uriCode)
Check whether this node excludes a particular namespace from the result.
This method checks this node only, not the ancestor nodes.
uriCode
- the code of the namespace URI being tested
definesExtensionElement
protected boolean definesExtensionElement(short uriCode)
Check whether a particular extension element namespace is defined on this node.
This checks this node only, not the ancestor nodes.
The implementation checks whether the prefix is included in the
[xsl:]extension-element-prefixes attribute.
uriCode
- the namespace URI code being tested
doesPostProcessing
public boolean doesPostProcessing()
Determine whether this element does any processing after instantiating any children.
The default implementation says it does. Tail recursion only works if call-template is
nested entirely in elements that do no such processing. (If the element is empty, this
property is irrelevant, because the element cannot contain an xsl:call-template).
fallbackProcessing
protected void fallbackProcessing(StyleElement instruction,
Context context)
throws TransformerException
Perform fallback processing
findAttributeSets
protected void findAttributeSets(String use)
throws TransformerConfigurationException
Determine the list of attribute-sets associated with this element.
This is used for xsl:element, xsl:copy, xsl:attribute-set, and on literal
result elements
forwardsCompatibleModeIsEnabled
public boolean forwardsCompatibleModeIsEnabled()
Determine whether forwards-compatible mode is enabled for this element
getContainingStyleSheet
public XSLStyleSheet getContainingStyleSheet()
Get the containing XSLStyleSheet element
getPrecedence
public int getPrecedence()
Get the import precedence of this stylesheet element.
getPreparedStyleSheet
public PreparedStyleSheet getPreparedStyleSheet()
Get the PreparedStyleSheet object.
- the PreparedStyleSheet to which this stylesheet element belongs
getPrincipalStyleSheet
protected XSLStyleSheet getPrincipalStyleSheet()
Get the principal XSLStyleSheet node. This gets the principal style sheet, i.e. the
one originally loaded, that forms the root of the import/include tree
getStandardNames
public final StandardNames getStandardNames()
Get the StandardNames object
getStyleSheetFunction
public Function getStyleSheetFunction(int fingerprint)
Get a Function declared using a saxon:function element in the stylesheet
fingerprint
- the fingerprint of the name of the function
- the Function object represented by this saxon:function; or null if not found
getVariableBinding
public Binding getVariableBinding(int fprint)
Bind a variable used in this element to the XSLVariable element in which it is declared
- a Binding for the variable, or null if it has not been declared
getVariableNames
public Enumeration[] getVariableNames()
List the variables that are in scope for this stylesheet element.
Designed for a debugger, not used by the processor.
- two Enumeration of Strings, the global ones [0] and the local ones [1]
getVersion
public String getVersion()
Get the version number on this element, or inherited from its ancestors
handleSortKeys
protected Expression handleSortKeys(Expression select)
Modify the "select" expression to include any sort keys specified. Used in XSLForEach
and XSLApplyTemplates
isExcludedNamespace
public boolean isExcludedNamespace(short uriCode)
Check whether a namespace uri defines an namespace excluded from the result.
This checks whether the namespace is defined as an excluded namespace on this
or any ancestor node.
uriCode
- the code of the namespace URI being tested
isExtensionNamespace
public boolean isExtensionNamespace(short uriCode)
Check whether a namespace uri defines an extension element. This checks whether the
namespace is defined as an extension namespace on this or any ancestor node.
uriCode
- the namespace URI code being tested
isInstruction
public boolean isInstruction()
Determine whether this node is an instruction. The default implementation says it isn't.
isTopLevel
public boolean isTopLevel()
Test whether this is a top-level element
makeAttributeValueTemplate
public Expression makeAttributeValueTemplate(String expression)
throws TransformerConfigurationException
Make an attribute value template in the context of this stylesheet element
makeExpression
public Expression makeExpression(String expression)
throws TransformerConfigurationException
Make an expression in the context of this stylesheet element
makePattern
public Pattern makePattern(String pattern)
throws TransformerConfigurationException
Make a pattern in the context of this stylesheet element
mayContainTemplateBody
public boolean mayContainTemplateBody()
Determine whether this type of element is allowed to contain a template-body
prepareAttributes
public void prepareAttributes()
throws TransformerConfigurationException
Set the attribute list for the element. This is called to process the attributes (note
the distinction from processAttributes in the superclass).
Must be supplied in a subclass
preprocess
public void preprocess()
throws TransformerConfigurationException
Default preprocessing method does nothing. It is implemented for those top-level elements
that can be evaluated before the source document is available, for example xsl:key,
xsl:attribute-set, xsl:template, xsl:locale
process
public void process(Context context)
throws TransformerException
Process: called to do the real work of this stylesheet element. This method
must be implemented in each subclass.
context
- The context in the source XML document, giving access to the current node,
the current variables, etc.
processAllAttributes
public void processAllAttributes()
throws TransformerConfigurationException
Process the attributes of this element and all its children
processAttributeSets
protected void processAttributeSets(Context context)
throws TransformerException
Expand the attribute sets referenced in this element's use-attribute-sets attribute
processAttributes
public final void processAttributes()
throws TransformerConfigurationException
Process the attribute list for the element. This is a wrapper method that calls
prepareAttributes (provided in the subclass) and traps any exceptions
processChildren
public void processChildren(Context context)
throws TransformerException
Process the children of this node in the stylesheet
context
- The context in the source XML document, giving access to the current node,
the current variables, etc.
processExcludedNamespaces
protected void processExcludedNamespaces(int nc)
throws TransformerConfigurationException
Process the [xsl:]exclude-result-prefixes attribute if there is one
nc
- the name code of the attribute required
processExtensionElementAttribute
protected void processExtensionElementAttribute(int nc)
throws TransformerConfigurationException
Process the [xsl:]extension-element-prefixes attribute if there is one
nc
- the name code of the attribute required
processVersionAttribute
protected void processVersionAttribute(int nc)
Process the [xsl:]version attribute if there is one
nc
- the name code of the attribute required
reportAbsence
public void reportAbsence(String attribute)
throws TransformerConfigurationException
Convenience method to report the absence of a mandatory attribute
setValidationError
protected void setValidationError(TransformerException reason,
int circumstances)
Set a validation error
styleError
protected TransformerException styleError(String message)
styleError
protected TransformerException styleError(TransformerException error)
Construct an exception with diagnostic information
substituteFor
public void substituteFor(StyleElement temp)
Make this node a substitute for a temporary one previously added to the tree. See
StyleNodeFactory for details. "A node like the other one in all things but its class".
Note that at this stage, the node will not yet be known to its parent, though it will
contain a reference to its parent; and it will have no children.
validate
public void validate()
throws TransformerConfigurationException
Check that the element is valid. This is called once for each element, after
the entire tree has been built. As well as validation, it can perform first-time
initialisation. The default implementation does nothing; it is normally overriden
in subclasses.
validateChildren
protected void validateChildren()
throws TransformerConfigurationException
validateSubtree
public void validateSubtree()
throws TransformerConfigurationException
Recursive walk through the stylesheet to validate all nodes