Package net.sf.saxon.style

Class StyleElement

java.lang.Object
net.sf.saxon.tree.NodeImpl
net.sf.saxon.tree.ParentNodeImpl
net.sf.saxon.tree.ElementImpl
net.sf.saxon.tree.ElementWithAttributes
net.sf.saxon.style.StyleElement
All Implemented Interfaces:
Source, SourceLocator, LocationProvider, SaxonLocator, Container, FingerprintedNode, Item, NodeInfo, ValueRepresentation, InstructionInfo, Locator
Direct Known Subclasses:
AbsentExtensionElement, ExtensionInstruction, LiteralResultElement, SaxonCollation, SaxonDoctype, SaxonEntityRef, SaxonImportQuery, SaxonScript, SaxonWhile, XSLAnalyzeString, XSLApplyImports, XSLApplyTemplates, XSLAttributeSet, XSLCallTemplate, XSLCharacterMap, XSLChoose, XSLCopy, XSLCopyOf, XSLDecimalFormat, XSLDocument, XSLElement, XSLFallback, XSLForEach, XSLForEachGroup, XSLFunction, XSLGeneralIncorporate, XSLGeneralVariable, XSLIf, XSLImportSchema, XSLKey, XSLMatchingSubstring, XSLMessage, XSLNamespaceAlias, XSLNextMatch, XSLNumber, XSLOtherwise, XSLOutput, XSLOutputCharacter, XSLPerformSort, XSLPreserveSpace, XSLResultDocument, XSLSequence, XSLSort, XSLStringConstructor, XSLStylesheet, XSLTemplate, XSLWhen
public abstract class StyleElement extends ElementWithAttributes implements Locator, Container, InstructionInfo
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.

  • Field Details

    • extensionNamespaces

      protected short[] extensionNamespaces

    • version

      protected BigDecimal version

    • staticContext

      protected StaticContext staticContext

    • validationError

      protected StaticError validationError

    • reportingCircumstances

      protected int reportingCircumstances

    • defaultXPathNamespace

      protected String defaultXPathNamespace

    • defaultCollationName

      protected String defaultCollationName

    • REPORT_ALWAYS

      public static final int REPORT_ALWAYS
      See Also:

    • REPORT_UNLESS_FORWARDS_COMPATIBLE

      public static final int REPORT_UNLESS_FORWARDS_COMPATIBLE
      See Also:

    • REPORT_IF_INSTANTIATED

      public static final int REPORT_IF_INSTANTIATED
      See Also:

    • REPORT_UNLESS_FALLBACK_AVAILABLE

      public static final int REPORT_UNLESS_FALLBACK_AVAILABLE
      See Also:

  • Constructor Details

    • StyleElement

      public StyleElement()
      Constructor

  • Method Details

    • getExecutable

      public Executable getExecutable()
      Description copied from interface: Container
      Get the Executable (representing a complete stylesheet or query) of which this Container forms part
      Specified by:
      getExecutable in interface Container

    • getLocationProvider

      public LocationProvider getLocationProvider()
      Get the LocationProvider allowing location identifiers to be resolved.
      Specified by:
      getLocationProvider in interface Container

    • getTargetNamePool

      public NamePool getTargetNamePool()
      Get the namepool to be used at run-time, this namepool holds the names used in all XPath expressions and patterns

    • getStaticContext

      public StaticContext getStaticContext()
      Get the static context for expressions on this element
      Returns:
      the static context

    • getLineNumber

      public int getLineNumber()
      Description copied from class: ElementImpl
      Get the line number of the node within its source document entity
      Specified by:
      getLineNumber in interface InstructionInfo
      Specified by:
      getLineNumber in interface Locator
      Specified by:
      getLineNumber in interface NodeInfo
      Specified by:
      getLineNumber in interface SourceLocator
      Overrides:
      getLineNumber in class ElementImpl
      Returns:
      the line number of the node in its original source document; or -1 if not available

    • setLineNumber

      public void setLineNumber(int lineNumber)
      Description copied from class: ElementImpl
      Set the line number of the element within its source document entity
      Overrides:
      setLineNumber in class ElementImpl

    • isExplaining

      protected boolean isExplaining()
      Determine whether saxon:explain has been set to "yes"

    • 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.

    • setValidationError

      protected void setValidationError(TransformerException reason, int circumstances)
      Set a validation error

    • isInstruction

      public boolean isInstruction()
      Determine whether this node is an instruction. The default implementation says it isn't.

    • getReturnedItemType

      protected ItemType getReturnedItemType()
      Determine the type of item returned by this instruction (only relevant if it is an instruction). Default implementation returns Type.ITEM, indicating that we don't know, it might be anything. Returns null in the case of an element such as xsl:sort or xsl:variable that can appear in a sequence constructor but contributes nothing to the result sequence.
      Returns:
      the item type returned

    • getCommonChildItemType

      protected ItemType getCommonChildItemType()
      Get the most general type of item returned by the children of this instruction
      Returns:
      the lowest common supertype of the item types returned by the children

    • markTailCalls

      public void markTailCalls()
      Mark tail-recursive calls on templates and functions. For most instructions, this does nothing.

    • mayContainSequenceConstructor

      public boolean mayContainSequenceConstructor()
      Determine whether this type of element is allowed to contain a sequence constructor

    • mayContainFallback

      public boolean mayContainFallback()
      Determine whether this type of element is allowed to contain an xsl:fallback instruction

    • getContainingStylesheet

      public XSLStylesheet getContainingStylesheet()
      Get the containing XSLStylesheet element

    • getPrecedence

      public int getPrecedence()
      Get the import precedence of this stylesheet element.

    • makeNameCode

      public final int makeNameCode(String qname) throws XPathException, NamespaceException
      Make a NameCode, using this Element as the context for namespace resolution, and registering the code in the namepool. If the name is unprefixed, the default namespace is not used.
      Parameters:
      qname - The name as written, in the form "[prefix:]localname". The name must have already been validated as a syntactically-correct QName.
      Throws:
      XPathException - if the qname is not a lexically-valid QName, or if the name is in a reserved namespace.
      NamespaceException - if the prefix of the qname has not been declared

    • makeNamespaceContext

      public SavedNamespaceContext makeNamespaceContext()
      Make a NamespaceContext object representing the list of in-scope namespaces. The NamePool used for numeric codes in the NamespaceContext will be the target name pool.

    • processAllAttributes

      public void processAllAttributes() throws XPathException
      Process the attributes of this element and all its children
      Throws:
      XPathException

    • getAttributeValue

      public String getAttributeValue(String clarkName)
      Get an attribute value given the Clark name of the attribute (that is, the name in {uri}local format).

    • processAttributes

      public final void processAttributes() throws XPathException
      Process the attribute list for the element. This is a wrapper method that calls prepareAttributes (provided in the subclass) and traps any exceptions
      Throws:
      XPathException

    • checkUnknownAttribute

      protected void checkUnknownAttribute(int nc) throws XPathException
      Check whether an unknown attribute is permitted.
      Parameters:
      nc - The name code of the attribute name
      Throws:
      XPathException

    • prepareAttributes

      public abstract void prepareAttributes() throws XPathException
      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
      Throws:
      XPathException

    • getLastChildInstruction

      protected StyleElement getLastChildInstruction()
      Find the last child instruction of this instruction. Returns null if there are no child instructions, or if the last child is a text node.

    • makeExpression

      public Expression makeExpression(String expression) throws XPathException
      Make an expression in the context of this stylesheet element
      Throws:
      XPathException

    • makePattern

      public Pattern makePattern(String pattern) throws XPathException
      Make a pattern in the context of this stylesheet element
      Throws:
      XPathException

    • makeAttributeValueTemplate

      public Expression makeAttributeValueTemplate(String expression) throws XPathException
      Make an attribute value template in the context of this stylesheet element
      Throws:
      XPathException

    • makeSequenceType

      public SequenceType makeSequenceType(String sequenceType) throws XPathException
      Process an attribute whose value is a SequenceType
      Throws:
      XPathException

    • processExtensionElementAttribute

      protected void processExtensionElementAttribute(String nc) throws XPathException
      Process the [xsl:]extension-element-prefixes attribute if there is one
      Parameters:
      nc - the Clark name of the attribute required
      Throws:
      XPathException

    • processExcludedNamespaces

      protected void processExcludedNamespaces(String nc) throws XPathException
      Process the [xsl:]exclude-result-prefixes attribute if there is one
      Parameters:
      nc - the Clark name of the attribute required
      Throws:
      XPathException

    • processVersionAttribute

      protected void processVersionAttribute(String nc) throws XPathException
      Process the [xsl:]version attribute if there is one
      Parameters:
      nc - the Clark name of the attribute required
      Throws:
      XPathException

    • getVersion

      public BigDecimal getVersion()
      Get the numeric value of the version number on this element, or inherited from its ancestors

    • forwardsCompatibleModeIsEnabled

      public boolean forwardsCompatibleModeIsEnabled()
      Determine whether forwards-compatible mode is enabled for this element

    • backwardsCompatibleModeIsEnabled

      public boolean backwardsCompatibleModeIsEnabled()
      Determine whether backwards-compatible mode is enabled for this element

    • processDefaultCollationAttribute

      protected void processDefaultCollationAttribute(String nc) throws XPathException
      Process the [xsl:]default-xpath-namespace attribute if there is one
      Parameters:
      nc - the Clark name of the attribute required
      Throws:
      XPathException

    • getDefaultCollationName

      protected String getDefaultCollationName()
      Get the default collation for this stylesheet element. If no default collation is specified in the stylesheet, return the Unicode codepoint collation name.

    • 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.
      Parameters:
      uriCode - the namespace URI code 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.
      Parameters:
      uriCode - the namespace URI code being tested

    • 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.
      Parameters:
      uriCode - the code of the namespace URI being tested

    • 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.
      Parameters:
      uriCode - the code of the namespace URI being tested

    • processDefaultXPathNamespaceAttribute

      protected void processDefaultXPathNamespaceAttribute(String nc)
      Process the [xsl:]default-xpath-namespace attribute if there is one
      Parameters:
      nc - the Clark name of the attribute required

    • getDefaultXPathNamespace

      protected short getDefaultXPathNamespace()
      Get the default XPath namespace code applicable to this element

    • getSchemaType

      public SchemaType getSchemaType(String typeAtt) throws XPathException
      Get the Schema type definition for a type named in the stylesheet (in a "type" attribute).
      Throws:
      XPathException - if the type is not declared in an imported schema, or is not a built-in type

    • getTypeAnnotation

      public int getTypeAnnotation(SchemaType schemaType)
      Get the type annotation to use for a given schema type

    • validate

      public void validate() throws XPathException
      Check that the stylesheet 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.
      Throws:
      XPathException

    • postValidate

      public void postValidate() throws XPathException
      Hook to allow additional validation of a parent element immediately after its children have been validated.
      Throws:
      XPathException

    • typeCheck

      public Expression typeCheck(String name, Expression exp) throws XPathException
      Type-check an expression. This is called to check each expression while the containing instruction is being validated. It is not just a static type-check, it also adds code to perform any necessary run-time type checking and/or conversion.
      Throws:
      XPathException

    • allocateSlots

      public void allocateSlots(Expression exp)
      Allocate slots in the local stack frame to range variables used in an XPath expression
      Parameters:
      exp - the XPath expression for which slots are to be allocated

    • typeCheck

      public Pattern typeCheck(String name, Pattern pattern) throws XPathException
      Type-check a pattern. This is called to check each pattern while the containing instruction is being validated. It is not just a static type-check, it also adds code to perform any necessary run-time type checking and/or conversion.
      Throws:
      XPathException

    • fixupReferences

      public void fixupReferences() throws XPathException
      Fix up references from XPath expressions. Overridden for function declarations and variable declarations
      Throws:
      XPathException

    • getContainingSlotManager

      public SlotManager getContainingSlotManager()
      Get the SlotManager for the containing Procedure definition
      Returns:
      the SlotManager associated with the containing Function, Template, etc, or null if there is no such containing Function, Template etc.

    • validateSubtree

      public void validateSubtree() throws XPathException
      Recursive walk through the stylesheet to validate all nodes
      Throws:
      XPathException

    • validateChildren

      protected void validateChildren() throws XPathException
      Validate the children of this node, recursively. Overridden for top-level data elements.
      Throws:
      XPathException

    • isPermittedChild

      protected boolean isPermittedChild(StyleElement child)
      Specify that certain children are permitted for this element

    • 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

    • getPreparedStylesheet

      public PreparedStylesheet getPreparedStylesheet()
      Get the PreparedStylesheet object.
      Returns:
      the PreparedStylesheet to which this stylesheet element belongs

    • checkWithinTemplate

      public void checkWithinTemplate() throws XPathException
      Check that the stylesheet element is within a sequence constructor
      Throws:
      XPathException - if not within a sequence constructor

    • checkSortComesFirst

      protected void checkSortComesFirst(boolean sortRequired) throws XPathException
      Check that among the children of this element, any xsl:sort elements precede any other elements
      Parameters:
      sortRequired - true if there must be at least one xsl:sort element
      Throws:
      XPathException - if invalid

    • checkTopLevel

      public void checkTopLevel(String errorCode) throws XPathException
      Convenience method to check that the stylesheet element is at the top level
      Throws:
      XPathException - if not at top level

    • checkEmpty

      public void checkEmpty() throws XPathException
      Convenience method to check that the stylesheet element is empty
      Throws:
      XPathException - if it is not empty

    • reportAbsence

      public void reportAbsence(String attribute) throws XPathException
      Convenience method to report the absence of a mandatory attribute
      Throws:
      XPathException - if the attribute is missing

    • compile

      public abstract Expression compile(Executable exec) throws XPathException
      Compile the instruction on the stylesheet tree into an executable instruction for use at run-time.
      Returns:
      either a ComputedExpression, or null. The value null is returned when compiling an instruction that returns a no-op, or when compiling a top-level object such as an xsl:template that compiles into something other than an instruction.
      Throws:
      XPathException

    • compileSequenceConstructor

      public Expression compileSequenceConstructor(Executable exec, AxisIterator iter, boolean includeParams) throws XPathException
      Compile the children of this instruction on the stylesheet tree, adding the subordinate instructions to the parent instruction on the execution tree.
      Returns:
      the array of children
      Throws:
      XPathException

    • makeTraceInstruction

      protected static TraceWrapper makeTraceInstruction(StyleElement source, Expression child)
      Create a trace instruction to wrap a real instruction

    • fallbackProcessing

      protected Expression fallbackProcessing(Executable exec, StyleElement instruction) throws XPathException
      Perform fallback processing. Generate fallback code for an extension instruction that is not recognized by the implementation.
      Parameters:
      instruction - The unknown extension instruction
      Throws:
      XPathException

    • allocateLocationId

      public int allocateLocationId(String systemId, int lineNumber)
      Allocate a location identifier

    • makeSortKeys

      protected SortKeyDefinition[] makeSortKeys() throws XPathException
      Construct sort keys for a SortedIterator
      Returns:
      an array of SortKeyDefinition objects if there are any sort keys; or null if there are none.
      Throws:
      XPathException

    • getAttributeSets

      protected AttributeSet[] getAttributeSets(String use, List list) throws XPathException
      Get 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
      Parameters:
      use - the original value of the [xsl:]use-attribute-sets attribute
      list - an empty list to hold the list of XSLAttributeSet elements in the stylesheet tree. Or null, if these are not required.
      Returns:
      an array of AttributeList instructions representing the compiled attribute sets
      Throws:
      XPathException

    • getWithParamInstructions

      protected WithParam[] getWithParamInstructions(Executable exec, boolean tunnel, Instruction caller) throws XPathException
      Get the list of xsl:with-param elements for a calling element (apply-templates, call-template, apply-imports, next-match). This method can be used to get either the tunnel parameters, or the non-tunnel parameters.
      Parameters:
      tunnel - true if the tunnel="yes" parameters are wanted, false to get
      caller -
      Throws:
      XPathException

    • compileError

      protected void compileError(TransformerException error) throws XPathException
      Construct an exception with diagnostic information
      Throws:
      XPathException

    • compileError

      protected void compileError(String message) throws XPathException
      Throws:
      XPathException

    • compileError

      protected void compileError(String message, String errorCode) throws XPathException
      Compile time error, specifying an error code
      Parameters:
      message - the error message
      errorCode - the error code. May be null if not known or not defined
      Throws:
      XPathException

    • undeclaredNamespaceError

      protected void undeclaredNamespaceError(String prefix, String errorCode) throws XPathException
      Throws:
      XPathException

    • compileWarning

      protected void compileWarning(String message, String errorCode) throws XPathException
      Throws:
      XPathException

    • issueWarning

      protected void issueWarning(TransformerException error)
      Construct an exception with diagnostic information

    • issueWarning

      protected void issueWarning(String message, SourceLocator locator)

    • isTopLevel

      public boolean isTopLevel()
      Test whether this is a top-level element

    • bindVariable

      public XSLVariableDeclaration bindVariable(int fingerprint) throws StaticError
      Bind a variable used in this element to the compiled form of the XSLVariable element in which it is declared
      Parameters:
      fingerprint - The fingerprint of the name of the variable
      Returns:
      the XSLVariableDeclaration (that is, an xsl:variable or xsl:param instruction) for the variable
      Throws:
      StaticError - if the variable has not been declared

    • getStylesheetFunction

      public XSLFunction getStylesheetFunction(int fingerprint, int arity)
      Get a FunctionCall declared using an xsl:function element in the stylesheet
      Parameters:
      fingerprint - the fingerprint of the name of the function
      arity - the number of arguments in the function call. The value -1 indicates that any arity will do (this is used to support the function-available() function).
      Returns:
      the XSLFunction object representing the function declaration in the stylesheet, or null if no such function is defined.

    • getConstructType

      public int getConstructType()
      Get the type of construct. This will be a constant in class Location. This method is part of the InstructionInfo interface
      Specified by:
      getConstructType in interface InstructionInfo

    • getObjectNameCode

      public int getObjectNameCode()
      Get a name identifying the object of the expression, for example a function name, template name, variable name, key name, element name, etc. This is used only where the name is known statically. If there is no name, the value will be -1.
      Specified by:
      getObjectNameCode in interface InstructionInfo

    • getObjectFingerprint

      public int getObjectFingerprint()
      Get a fingerprint identifying the object of the expression, for example a function name, template name, variable name, key name, element name, etc. This is used only where the name is known statically. If there is no name, the value will be -1.

    • setObjectNameCode

      public void setObjectNameCode(int nameCode)
      Set the object name code

    • getNamespaceResolver

      public NamespaceResolver getNamespaceResolver()
      Get the namespace context of the instruction.
      Specified by:
      getNamespaceResolver in interface InstructionInfo

    • getProperty

      public Object getProperty(String name)
      Get the value of a particular property of the instruction. This is part of the InstructionInfo interface for run-time tracing and debugging. The properties available include all the attributes of the source instruction (named by the attribute name): these are all provided as string values.
      Specified by:
      getProperty in interface InstructionInfo
      Parameters:
      name - The name of the required property
      Returns:
      The value of the requested property, or null if the property is not available

    • getProperties

      public Iterator getProperties()
      Get an iterator over all the properties available. The values returned by the iterator will be of type String, and each string can be supplied as input to the getProperty() method to retrieve the value of the property.
      Specified by:
      getProperties in interface InstructionInfo

    • getSystemId

      public String getSystemId(int locationId)
      Description copied from interface: LocationProvider
      Get the URI of the document or module containing a particular location
      Specified by:
      getSystemId in interface LocationProvider
      Parameters:
      locationId - identifier of the location in question (as passed down the Receiver pipeline)
      Returns:
      the URI of the document or module.

    • getLineNumber

      public int getLineNumber(int locationId)
      Description copied from interface: LocationProvider
      Get the line number within the document or module containing a particular location
      Specified by:
      getLineNumber in interface LocationProvider
      Parameters:
      locationId - identifier of the location in question (as passed down the Receiver pipeline)
      Returns:
      the line number within the document or module.

    • getHostLanguage

      public int getHostLanguage()
      Get the host language (XSLT, XQuery, XPath) used to implement the code in this container
      Specified by:
      getHostLanguage in interface Container
      Returns:
      typically Configuration.XSLT or Configuration.XQUERY

    • replaceSubExpression

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