Package net.sf.saxon.style

## Class StyleElement

- java.lang.Object
- - net.sf.saxon.tree.linked.NodeImpl
  - - net.sf.saxon.tree.linked.ParentNodeImpl
    - - net.sf.saxon.tree.linked.ElementImpl
      - - net.sf.saxon.style.StyleElement

- All Implemented Interfaces:
    `javax.xml.transform.Source`, `javax.xml.transform.SourceLocator`, `GroundedValue`, `Item`, `MutableNodeInfo`, `NamespaceResolver`, `NodeInfo`, `Sequence`, `Location`, `SteppingNode<NodeImpl>`, `SiblingCountingNode`, `org.xml.sax.Locator`
  Direct Known Subclasses:
    `AbsentExtensionElement`, `ExtensionInstruction`, `IXSLRemoveAttribute`, `IXSLRemoveProperty`, `IXSLScheduleAction`, `IXSLSetAttribute`, `IXSLSetProperty`, `IXSLSetStyle`, `LiteralResultElement`, `SaxonChange`, `SaxonDeepUpdate`, `SaxonDelete`, `SaxonDo`, `SaxonDoctype`, `SaxonEntityRef`, `SaxonForEachMember`, `SaxonImportQuery`, `SaxonInsert`, `SaxonItemType`, `SaxonRename`, `SaxonReplace`, `SaxonTabulateMaps`, `SaxonUpdate`, `SaxonWhile`, `SQLColumn`, `XSLAcceptExpose`, `XSLAccumulator`, `XSLAccumulatorRule`, `XSLAnalyzeString`, `XSLApplyImports`, `XSLApplyTemplates`, `XSLAssert`, `XSLAttributeSet`, `XSLBreakOrContinue`, `XSLCallTemplate`, `XSLCatch`, `XSLCharacterMap`, `XSLChoose`, `XSLContextItem`, `XSLCopy`, `XSLCopyOf`, `XSLDecimalFormat`, `XSLDocument`, `XSLElement`, `XSLEvaluate`, `XSLFallback`, `XSLForEach`, `XSLForEachGroup`, `XSLFork`, `XSLFunction`, `XSLGeneralIncorporate`, `XSLGeneralVariable`, `XSLGlobalVariable`, `XSLIf`, `XSLImportSchema`, `XSLIterate`, `XSLKey`, `XSLLeafNodeConstructor`, `XSLMap`, `XSLMapEntry`, `XSLMatchingSubstring`, `XSLMerge`, `XSLMergeAction`, `XSLMergeSource`, `XSLMessage`, `XSLMode`, `XSLModuleRoot`, `XSLNamespaceAlias`, `XSLNextMatch`, `XSLNumber`, `XSLOnCompletion`, `XSLOtherwise`, `XSLOutput`, `XSLOutputCharacter`, `XSLOverride`, `XSLPerformSort`, `XSLPreserveSpace`, `XSLResultDocument`, `XSLSequence`, `XSLSortOrMergeKey`, `XSLSourceDocument`, `XSLTemplate`, `XSLTry`, `XSLUsePackage`, `XSLWhen`, `XSLWherePopulated`

      public abstract class StyleElement
      extends ElementImpl

  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 XSLT static error is found.

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class | Description
    --- | --- | ---
    `static class` | `StyleElement.OnFailure` |

  - ### Field Summary

    Fields
    Modifier and Type | Field | Description
    --- | --- | ---
    `static int` | `ACTION_COMPILE` |
    `static int` | `ACTION_FIXUP` |
    `static int` | `ACTION_OPTIMIZE` |
    `static int` | `ACTION_PROCESS_ATTRIBUTES` |
    `static int` | `ACTION_TYPECHECK` |
    `static int` | `ACTION_VALIDATE` |
    `protected int` | `actionsCompleted` |
    `protected java.lang.String` | `defaultCollationName` |
    `protected StructuredQName` | `defaultMode` |
    `protected java.lang.String` | `defaultXPathNamespace` |
    `protected boolean` | `expandText` |
    `protected java.lang.String[]` | `extensionNamespaces` |
    `protected StyleElement.OnFailure` | `reportingCircumstances` |
    `protected ExpressionContext` | `staticContext` |
    `protected XmlProcessingIncident` | `validationError` |
    `protected int` | `version` |

    - ### Fields inherited from class net.sf.saxon.tree.linked.NodeImpl

      `NODE_LETTER`

    - ### Fields inherited from interface net.sf.saxon.om.NodeInfo

      `IS_DTD_TYPE, IS_NILLED`

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `StyleElement()` | Constructor

  - ### Method Summary

    All Methods Instance Methods Abstract Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `protected Location` | `allocateLocation()` | Allocate a location
    `SourceBinding` | `bindLocalVariable​(StructuredQName qName)` | Bind a variable reference used in this element to the compiled form of the XSLVariable element in which it is declared, considering only local variables and params
    `SourceBinding` | `bindVariable​(StructuredQName qName)` | Bind a variable used in this element to the compiled form of the XSLVariable element in which it is declared
    `void` | `checkEmpty()` | Convenience method to check that the stylesheet element is empty
    `void` | `checkTopLevel​(java.lang.String errorCode, boolean allowOverride)` | Convenience method to check that the stylesheet element is at the top level (that is, as a child of xsl:stylesheet or xsl:transform)
    `protected void` | `checkUnknownAttribute​(NodeName nc)` | Check whether an unknown attribute is permitted.
    `Expression` | `compile​(Compilation compilation, ComponentDeclaration decl)` | Compile the instruction on the stylesheet tree into an executable instruction for use at run-time.
    `void` | `compileDeclaration​(Compilation compilation, ComponentDeclaration decl)` | Compile a declaration in the stylesheet tree for use at run-time.
    `void` | `compileError​(java.lang.String message)` | Report a static error in the stylesheet
    `void` | `compileError​(java.lang.String message, java.lang.String errorCode)` | Compile time error, specifying an error code
    `void` | `compileError​(java.lang.String message, java.lang.String errorCode, Location loc)` |
    `void` | `compileError​(java.lang.String message, StructuredQName errorCode)` | Compile time error, specifying an error code
    `void` | `compileError​(XmlProcessingError error)` | Report an error with diagnostic information
    `void` | `compileError​(XPathException err)` |
    `void` | `compileErrorInAttribute​(java.lang.String message, java.lang.String errorCode, java.lang.String attributeName)` | Compile time error, specifying an error code and the name of the attribute that is in error.
    `Expression` | `compileSequenceConstructor​(Compilation compilation, ComponentDeclaration decl, boolean includeParams)` | Compile the children of this instruction on the stylesheet tree, adding the subordinate instructions to the parent instruction on the execution tree.
    `Expression` | `compileSequenceConstructor​(Compilation compilation, ComponentDeclaration decl, SequenceIterator iter, boolean includeParams)` | Compile the children of this instruction on the stylesheet tree, adding the subordinate instructions to the parent instruction on the execution tree.
    `void` | `compileWarning​(java.lang.String message, java.lang.String errorCode)` |
    `void` | `compileWarning​(java.lang.String message, java.lang.String errorCode, Location location)` |
    `void` | `compileWarning​(java.lang.String message, StructuredQName errorCode)` |
    `void` | `fixupReferences()` | Fix up references from XPath expressions.
    `protected java.lang.String` | `generateId()` |
    `java.lang.String` | `getAttributeValue​(java.lang.String clarkName)` | Get an attribute value given the Clark name of the attribute (that is, the name in {uri}local format).
    `java.lang.String` | `getBaseURI()` | Get the base URI of the element, which acts as the static base URI for XPath expressions defined on this element.
    `SourceBinding` | `getBindingInformation​(StructuredQName name)` | Ask whether this element contains a binding for a variable with a given name; and if it does, return the source binding information
    `Compilation` | `getCompilation()` |
    `Configuration` | `getConfiguration()` | Get the configuration
    `StylesheetPackage` | `getContainingPackage()` | Get the containing package (the principal stylesheet module of the package in which this XSLT element appears)
    `SlotManager` | `getContainingSlotManager()` | Get the SlotManager for the containing Procedure definition
    `Visibility` | `getDeclaredVisibility()` | Get the visibility of the component.
    `protected java.lang.String` | `getDefaultCollationName()` | Get the default collation for this stylesheet element.
    `java.lang.String` | `getDefaultXPathNamespace()` | Get the default XPath namespace for elements and types
    `NamespaceResolver` | `getNamespaceResolver()` | Get the namespace context of the instruction.
    `StructuredQName` | `getObjectName()` | Get a name identifying the object of the expression, for example a function name, template name, variable name, key name, element name, etc.
    `StylesheetPackage` | `getPackageData()` |
    `PrincipalStylesheetModule` | `getPrincipalStylesheetModule()` | Get the principal stylesheet module of the package in which this XSLT element appears
    `java.util.Iterator<java.lang.String>` | `getProperties()` | Get an iterator over all the properties available.
    `SchemaType` | `getSchemaType​(java.lang.String typeAtt)` | Get the Schema type definition for a type named in the stylesheet (in a "type" attribute).
    `ExpressionContext` | `getStaticContext()` | Get the static context for expressions on this element
    `ExpressionContext` | `getStaticContext​(StructuredQName attributeName)` |
    `SimpleType` | `getTypeAnnotation​(SchemaType schemaType)` | Get the type annotation to use for a given schema type
    `StylesheetPackage` | `getUsedPackage()` | Assuming this is an xsl:use-package element, find the package to which it refers.
    `Visibility` | `getVisibility()` | Get the visibility of the component.
    `WithParam[]` | `getWithParamInstructions​(Expression parent, Compilation compilation, ComponentDeclaration decl, boolean tunnel)` | Get the list of xsl:with-param elements for a calling element (apply-templates, call-template, apply-imports, next-match).
    `Actor` | `getXslOriginal​(int componentKind)` | Check that a reference to xsl:original appears within an xsl:override element, and that the name of the containing component matches the name of a component in the used stylesheet package; return the component in that package with matching symbolic name
    `protected SourceBinding` | `hasImplicitBinding​(StructuredQName name)` | Ask whether this particular element implicitly binds a given variable (used for xsl:accumulator-rule)
    `void` | `index​(ComponentDeclaration decl, PrincipalStylesheetModule top)` | Method supplied by declaration elements to add themselves to a stylesheet-level index
    `protected void` | `invalidAttribute​(java.lang.String attributeName, java.lang.String allowedValues)` |
    `boolean` | `isDeclaration()` | Ask whether this node is a declaration, that is, a permitted child of xsl:stylesheet (including xsl:include and xsl:import).
    `protected boolean` | `isExtensionAttributeAllowed​(java.lang.String attribute)` | Ask if an extension attribute is allowed; if no Professional Edition license is available, issue a warning saying the attribute is ignored, and return false
    `boolean` | `isExtensionNamespace​(java.lang.String uri)` | Check whether a namespace uri defines an extension element.
    `boolean` | `isInstruction()` | Ask whether this node is an instruction.
    `protected boolean` | `isPermittedChild​(StyleElement child)` | Check whether a given child is permitted for this element.
    `boolean` | `isSchemaAware()` | Ask whether the code is compiled in schema-aware mode
    `protected void` | `issueWarning​(java.lang.String message, javax.xml.transform.SourceLocator locator)` | Report a warning to the error listener
    `protected void` | `issueWarning​(XPathException error)` | Report a warning to the error listener
    `boolean` | `isTopLevel()` | Test whether this is a top-level element
    `protected boolean` | `isWithinDeclaredStreamableConstruct()` |
    `protected Expression` | `makeAttributeValueTemplate​(java.lang.String expression, AttributeInfo att)` | Make an attribute value template in the context of this stylesheet element
    `Expression` | `makeExpression​(java.lang.String expression, AttributeInfo att)` | Compile an XPath expression in the context of this stylesheet element
    `ExpressionVisitor` | `makeExpressionVisitor()` | Make an expression visitor
    `StructuredQName` | `makeQName​(java.lang.String lexicalQName, java.lang.String errorCode, java.lang.String attributeName)` | Make a structured QName, using this Element as the context for namespace resolution.
    `RetainedStaticContext` | `makeRetainedStaticContext()` |
    `SequenceType` | `makeSequenceType​(java.lang.String sequenceType)` | Process an attribute whose value is a SequenceType
    `protected boolean` | `markTailCalls()` | Mark tail-recursive calls on templates and functions.
    `protected boolean` | `mayContainFallback()` | Determine whether this type of element is allowed to contain an xsl:fallback instruction.
    `protected boolean` | `mayContainParam()` | Determine whether this type of element is allowed to contain an xsl:param element
    `protected boolean` | `mayContainSequenceConstructor()` | Determine whether this type of element is allowed to contain a sequence constructor
    `void` | `postValidate()` | Hook to allow additional validation of a parent element immediately after its children have been validated.
    `protected abstract void` | `prepareAttributes()` | Set the attribute list for the element.
    `void` | `processAllAttributes()` | Process the attributes of this element and all its children
    `boolean` | `processBooleanAttribute​(java.lang.String name, java.lang.String value)` | Process an attribute whose value is yes, no, true, false, 1, or 0; returning true or false.
    `void` | `processStandardAttributes​(java.lang.String namespace)` | Process the standard attributes such as `[xsl:]expand-text`.
    `protected void` | `processVersionAttribute​(java.lang.String ns)` | Process the [xsl:]version attribute if there is one
    `void` | `reportAbsence​(java.lang.String attribute)` | Convenience method to report the absence of a mandatory attribute
    `protected void` | `requireSyntaxExtensions​(java.lang.String attributeName)` | Ask whether XSLT syntax extensions are allowed, for example xsl:when/@select.
    `protected boolean` | `seesAvuncularVariables()` | Ask whether variables declared in an "uncle" element are visible.
    `void` | `setCompilation​(Compilation compilation)` |
    `void` | `setObjectName​(StructuredQName qName)` | Set the object name, for example the name of a function, variable, or template declared on this element
    `void` | `setValidationError​(XmlProcessingIncident reason, StyleElement.OnFailure circumstances)` | Set a validation error.
    `void` | `substituteFor​(StyleElement temp)` | Make this node a substitute for a temporary one previously added to the tree.
    `Expression` | `typeCheck​(java.lang.String name, Expression exp)` | Type-check an expression.
    `Pattern` | `typeCheck​(java.lang.String name, Pattern pattern)` | Type-check a pattern.
    `void` | `validate​(ComponentDeclaration decl)` | Check that the stylesheet element is valid.
    `protected void` | `validateChildren​(ComponentDeclaration decl, boolean excludeStylesheet)` | Validate the children of this node, recursively.
    `void` | `validateSubtree​(ComponentDeclaration decl, boolean excludeStylesheet)` | Recursive walk through the stylesheet to validate all nodes
    `protected int` | `validateValidationAttribute​(java.lang.String value)` | Validate the value of the [xsl:]validation attribute

    - ### Methods inherited from class net.sf.saxon.tree.linked.ElementImpl

      `addAttribute, addNamespace, addNamespace, attributes, checkNotNamespaceSensitiveElement, copy, delete, fixupInsertedNamespaces, generateId, getAllNamespaces, getAttributeValue, getColumnNumber, getDeclaredNamespaces, getLineNumber, getNodeKind, getNodeName, getRoot, getSchemaType, getSystemId, getURIForPrefix, initialise, isId, isIdref, isInScopeNamespace, isNilled, iteratePrefixes, removeAttribute, removeNamespace, removeTypeAnnotation, rename, replaceStringValue, setAttributeInfo, setAttributes, setLocation, setNamespaceMap, setNilled, setNodeName, setSystemId, setTypeAnnotation`

    - ### Methods inherited from class net.sf.saxon.tree.linked.ParentNodeImpl

      `addChild, children, compact, getFirstChild, getLastChild, getNthChild, getNumberOfChildren, getRawSequenceNumber, getSequenceNumber, getStringValue, getStringValueCS, hasChildNodes, insertChildren, iterateChildren, removeChild, replaceChildrenAt, setChildren, setRawSequenceNumber`

    - ### Methods inherited from class net.sf.saxon.tree.linked.NodeImpl

      `atomize, compareOrder, effectiveBooleanValue, equals, getDisplayName, getFingerprint, getLocalPart, getNamePool, getNextInDocument, getNextSibling, getParent, getPhysicalRoot, getPrefix, getPreviousInDocument, getPreviousSibling, getRawParent, getSiblingPosition, getSuccessorElement, getTreeInfo, getURI, hasFingerprint, head, insertSiblings, isDeleted, iterateAxis, iterateAxis, newBuilder, replace, saveLocation, setRawParent, setSiblingPosition`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

    - ### Methods inherited from interface net.sf.saxon.om.GroundedValue

      `asIterable, concatenate, containsNode, materialize`

    - ### Methods inherited from interface net.sf.saxon.om.Item

      `getLength, itemAt, iterate, reduce, subsequence`

    - ### Methods inherited from interface net.sf.saxon.om.NodeInfo

      `children, equals, getGenre, getPublicId, hashCode, isSameNodeInfo, isStreamed, toShortString`

    - ### Methods inherited from interface net.sf.saxon.om.Sequence

      `makeRepeatable`

    - ### Methods inherited from interface javax.xml.transform.Source

      `isEmpty`

- - ### Field Detail

    - #### extensionNamespaces

          protected java.lang.String[] extensionNamespaces

    - #### version

          protected int version

    - #### staticContext

          protected ExpressionContext staticContext

    - #### validationError

          protected XmlProcessingIncident validationError

    - #### reportingCircumstances

          protected StyleElement.OnFailure reportingCircumstances

    - #### defaultXPathNamespace

          protected java.lang.String defaultXPathNamespace

    - #### defaultCollationName

          protected java.lang.String defaultCollationName

    - #### defaultMode

          protected StructuredQName defaultMode

    - #### expandText

          protected boolean expandText

    - #### actionsCompleted

          protected int actionsCompleted

    - #### ACTION_VALIDATE

          public static final int ACTION_VALIDATE

      See Also:
        Constant Field Values

    - #### ACTION_COMPILE

          public static final int ACTION_COMPILE

      See Also:
        Constant Field Values

    - #### ACTION_TYPECHECK

          public static final int ACTION_TYPECHECK

      See Also:
        Constant Field Values

    - #### ACTION_OPTIMIZE

          public static final int ACTION_OPTIMIZE

      See Also:
        Constant Field Values

    - #### ACTION_FIXUP

          public static final int ACTION_FIXUP

      See Also:
        Constant Field Values

    - #### ACTION_PROCESS_ATTRIBUTES

          public static final int ACTION_PROCESS_ATTRIBUTES

      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### StyleElement

          public StyleElement()

      Constructor

  - ### Method Detail

    - #### getCompilation

          public Compilation getCompilation()

    - #### setCompilation

          public void setCompilation​(Compilation compilation)

    - #### getPackageData

          public StylesheetPackage getPackageData()

    - #### getConfiguration

          public Configuration getConfiguration()

      Description copied from class: `NodeImpl`
      Get the configuration
      Specified by:
        `getConfiguration` in interface `NodeInfo`
      Overrides:
        `getConfiguration` in class `NodeImpl`
      Returns:
        the Configuration to which the tree belongs. The default implementation invokes `getTreeInfo().getConfiguration()`.

    - #### getStaticContext

          public ExpressionContext getStaticContext()

      Get the static context for expressions on this element
      Returns:
        the static context

    - #### getStaticContext

          public ExpressionContext getStaticContext​(StructuredQName attributeName)

    - #### getBaseURI

          public java.lang.String getBaseURI()

      Get the base URI of the element, which acts as the static base URI for XPath expressions defined on this element. This is an expensive operation so the result is cached
      Specified by:
        `getBaseURI` in interface `NodeInfo`
      Overrides:
        `getBaseURI` in class `ElementImpl`
      Returns:
        the base URI

    - #### makeExpressionVisitor

          public ExpressionVisitor makeExpressionVisitor()

      Make an expression visitor
      Returns:
        the expression visitor

    - #### isSchemaAware

          public boolean isSchemaAware()

      Ask whether the code is compiled in schema-aware mode
      Returns:
        true if the compilation is schema-aware

    - #### 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.
      Parameters:
        `temp` - the element which this one is substituting for

    - #### setValidationError

          public void setValidationError​(XmlProcessingIncident reason,
                                         StyleElement.OnFailure circumstances)

      Set a validation error. This is an error detected during construction of this element on the stylesheet, but which is not to be reported until later.
      Parameters:
        `reason` - the details of the error
        `circumstances` - a code identifying the circumstances under which the error is to be reported

    - #### isInstruction

          public boolean isInstruction()

      Ask whether this node is an instruction. The default implementation says it isn't.
      Returns:
        true if this element is an instruction

    - #### isDeclaration

          public boolean isDeclaration()

      Ask whether this node is a declaration, that is, a permitted child of xsl:stylesheet (including xsl:include and xsl:import). The default implementation returns false
      Returns:
        true if the element is a permitted child of xsl:stylesheet or xsl:transform

    - #### getVisibility

          public Visibility getVisibility()

      Get the visibility of the component. Returns the actual value of the visibility attribute, after validation, unless this is absent, in which case it returns the default value of PRIVATE. Invokes `invalidAttribute(String, String)` if the value is invalid.
      Returns:
        the declared visibility of the component, or `Visibility.PRIVATE` if the visibility attribute is absent.

    - #### getDeclaredVisibility

          public Visibility getDeclaredVisibility()

      Get the visibility of the component. Returns the actual value of the visibility attribute, after validation, unless this is absent, in which case it returns null.
      Returns:
        the declared visibility of the component, or null if the visibility attribute is absent.

    - #### markTailCalls

          protected boolean markTailCalls()

      Mark tail-recursive calls on templates and functions. For most instructions, this returns false.
      Returns:
        true if one or more tail calls were identified

    - #### mayContainSequenceConstructor

          protected boolean mayContainSequenceConstructor()

      Determine whether this type of element is allowed to contain a sequence constructor
      Returns:
        true if this instruction is allowed to contain a sequence constructor

    - #### mayContainFallback

          protected boolean mayContainFallback()

      Determine whether this type of element is allowed to contain an xsl:fallback instruction. Note that this is only relevant if the element is an instruction.
      Returns:
        true if this element is allowed to contain an xsl:fallback

    - #### mayContainParam

          protected boolean mayContainParam()

      Determine whether this type of element is allowed to contain an xsl:param element
      Returns:
        true if this element is allowed to contain an xsl:param

    - #### makeQName

          public final StructuredQName makeQName​(java.lang.String lexicalQName,
                                                 java.lang.String errorCode,
                                                 java.lang.String attributeName)

      Make a structured QName, using this Element as the context for namespace resolution. If the name is unprefixed, the default namespace is not used. If the name is not valid, then a compileError is reported, and the value saxon:error-name is returned.
      Parameters:
        `lexicalQName` - The lexical QName as written, in the form "[prefix:]localname". Leading and trailing whitespace will be trimmed. The EQName syntax "Q{uri}local" is also accepted.
        `errorCode` - The error code to be used if the QName is not valid. If this is set to null, then the code used is XTSE0280 for an undeclared prefix, and XTSE0020 for all other errors. The code XTSE0080 is used if the URI is a reserved namespace, regardless of the supplied error code.
        `attributeName` - EQName of the attribute containing the QName, for use in error reporting. May be null.
      Returns:
        the StructuredQName representation of this lexical QName

    - #### getUsedPackage

          public StylesheetPackage getUsedPackage()

      Assuming this is an xsl:use-package element, find the package to which it refers.
      Returns:
        the package referenced by this xsl:use-package element; or null if this is not an xsl:use-package element

    - #### getXslOriginal

          public Actor getXslOriginal​(int componentKind)
                               throws XPathException

      Check that a reference to xsl:original appears within an xsl:override element, and that the name of the containing component matches the name of a component in the used stylesheet package; return the component in that package with matching symbolic name
      Parameters:
        `componentKind` - the kind of component required, e.g. StandardNames.XSL_TEMPLATE
      Returns:
        the component with matching name in the used stylesheet
      Throws:
        `XPathException` - if the xsl:original reference appears in an invalid context

    - #### makeRetainedStaticContext

          public RetainedStaticContext makeRetainedStaticContext()

    - #### getNamespaceResolver

          public NamespaceResolver getNamespaceResolver()

      Get the namespace context of the instruction.
      Returns:
        the namespace context. This method does not make a copy of the namespace context, so a reference to the returned NamespaceResolver will lock the stylesheet tree in memory.

    - #### processAllAttributes

          public void processAllAttributes()
                                    throws XPathException

      Process the attributes of this element and all its children
      Throws:
        `XPathException` - in the event of a static error being detected

    - #### processStandardAttributes

          public void processStandardAttributes​(java.lang.String namespace)

      Process the standard attributes such as `[xsl:]expand-text`. Invokes `compileError(String)` or similar if the value of any of these attributes is invalid.

      The method processes:

      - `extension-element-prefixes`
      - `exclude-result-prefixes`
      - `version`
      - `default-xpath-namespace`
      - `default-validation`
      - `expand-text`

      but not:

      - `default-collation`
      - `default-mode`
      Parameters:
        `namespace` - either "" to find the attributes in the null namespace, or NamespaceConstant.XSLT to find them in the XSLT namespace

    - #### getAttributeValue

          public java.lang.String getAttributeValue​(java.lang.String clarkName)

      Get an attribute value given the Clark name of the attribute (that is, the name in {uri}local format).
      Parameters:
        `clarkName` - the name of the attribute in {uri}local format
      Returns:
        the value of the attribute if it exists, or null otherwise

    - #### checkUnknownAttribute

          protected void checkUnknownAttribute​(NodeName nc)

      Check whether an unknown attribute is permitted.
      Parameters:
        `nc` - The name code of the attribute name

    - #### prepareAttributes

          protected abstract void prepareAttributes()

      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

    - #### makeExpression

          public Expression makeExpression​(java.lang.String expression,
                                           AttributeInfo att)

      Compile an XPath expression in the context of this stylesheet element
      Parameters:
        `expression` - the source text of the XPath expression
        `att` - the attribute containing the XPath expression, or null if the expression is in a text node
      Returns:
        the compiled expression tree for the XPath expression. In the case of an error, returns an ErrorExpression that will fail at run-time if executed.

    - #### makeAttributeValueTemplate

          protected Expression makeAttributeValueTemplate​(java.lang.String expression,
                                                          AttributeInfo att)

      Make an attribute value template in the context of this stylesheet element
      Parameters:
        `expression` - the source text of the attribute value template
        `att` - the attribute containing the AVT, or null in the case of a text value template
      Returns:
        a compiled XPath expression that computes the value of the attribute (including concatenating the results of embedded expressions with any surrounding fixed text)

    - #### processBooleanAttribute

          public boolean processBooleanAttribute​(java.lang.String name,
                                                 java.lang.String value)

      Process an attribute whose value is yes, no, true, false, 1, or 0; returning true or false.
      Parameters:
        `name` - the name of the attribute (used for diagnostics)
        `value` - the value of the attribute

    - #### makeSequenceType

          public SequenceType makeSequenceType​(java.lang.String sequenceType)
                                        throws XPathException

      Process an attribute whose value is a SequenceType
      Parameters:
        `sequenceType` - the source text of the attribute
      Returns:
        the processed sequence type
      Throws:
        `XPathException` - if the syntax is invalid or for example if it refers to a type that is not in the static context

    - #### processVersionAttribute

          protected void processVersionAttribute​(java.lang.String ns)

      Process the [xsl:]version attribute if there is one
      Parameters:
        `ns` - the namespace URI of the attribute required, either the XSLT namespace or ""

    - #### validateValidationAttribute

          protected int validateValidationAttribute​(java.lang.String value)

      Validate the value of the [xsl:]validation attribute
      Parameters:
        `value` - the raw value of the attribute
      Returns:
        the encoded value of the attribute

    - #### isExtensionAttributeAllowed

          protected boolean isExtensionAttributeAllowed​(java.lang.String attribute)

      Ask if an extension attribute is allowed; if no Professional Edition license is available, issue a warning saying the attribute is ignored, and return false
      Parameters:
        `attribute` - the name of the attribute

    - #### getDefaultCollationName

          protected java.lang.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.
      Returns:
        the name of the default collation

    - #### isExtensionNamespace

          public boolean isExtensionNamespace​(java.lang.String uri)

      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:
        `uri` - the namespace URI being tested
      Returns:
        true if the URI is an extension element namespace URI

    - #### getDefaultXPathNamespace

          public java.lang.String getDefaultXPathNamespace()

      Get the default XPath namespace for elements and types
      Returns:
        the default namespace for elements and types. Return `NamespaceConstant.NULL` for the non-namespace

    - #### getSchemaType

          public SchemaType getSchemaType​(java.lang.String typeAtt)

      Get the Schema type definition for a type named in the stylesheet (in a "type" attribute).
      Parameters:
        `typeAtt` - the value of the type attribute
      Returns:
        the corresponding schema type

    - #### getTypeAnnotation

          public SimpleType getTypeAnnotation​(SchemaType schemaType)

      Get the type annotation to use for a given schema type
      Parameters:
        `schemaType` - the schema type
      Returns:
        the corresponding numeric type annotation

    - #### validate

          public void validate​(ComponentDeclaration decl)
                        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.
      Parameters:
        `decl` - the declaration to be validated
      Throws:
        `XPathException` - if any error is found during validation

    - #### postValidate

          public void postValidate()
                            throws XPathException

      Hook to allow additional validation of a parent element immediately after its children have been validated.
      Throws:
        `XPathException` - if any error is found during post-traversal validation

    - #### index

          public void index​(ComponentDeclaration decl,
                            PrincipalStylesheetModule top)
                     throws XPathException

      Method supplied by declaration elements to add themselves to a stylesheet-level index
      Parameters:
        `decl` - the Declaration being indexed. (This corresponds to the StyleElement object except in cases where one module is imported several times with different precedence.)
        `top` - represents the outermost XSLStylesheet or XSLPackage element
      Throws:
        `XPathException` - if any error is encountered

    - #### typeCheck

          public Expression typeCheck​(java.lang.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.
      Parameters:
        `name` - the name of the attribute containing the expression to be checked (used for diagnostics)
        `exp` - the expression to be checked
      Returns:
        the (possibly rewritten) expression after type checking
      Throws:
        `XPathException` - if type-checking fails statically, that is, if it can be determined that the supplied value for the expression cannot possibly be of the required type

    - #### typeCheck

          public Pattern typeCheck​(java.lang.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.
      Parameters:
        `name` - the name of the attribute holding the pattern, for example "match": used in diagnostics
        `pattern` - the compiled pattern
      Returns:
        the original pattern, or a substitute pattern if it has been rewritten. Returns null if and only if the supplied pattern is null.
      Throws:
        `XPathException` - if the pattern fails optimistic static type-checking

    - #### fixupReferences

          public void fixupReferences()
                               throws XPathException

      Fix up references from XPath expressions. Overridden for function declarations and variable declarations
      Throws:
        `XPathException` - if any references cannot be fixed up.

    - #### 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​(ComponentDeclaration decl,
                                      boolean excludeStylesheet)
                               throws XPathException

      Recursive walk through the stylesheet to validate all nodes
      Parameters:
        `decl` - the declaration to be validated
        `excludeStylesheet` - true if the XSLStylesheet element is to be excluded
      Throws:
        `XPathException` - if validation fails

    - #### validateChildren

          protected void validateChildren​(ComponentDeclaration decl,
                                          boolean excludeStylesheet)
                                   throws XPathException

      Validate the children of this node, recursively. Overridden for top-level data elements.
      Parameters:
        `decl` - the declaration whose children are to be validated
        `excludeStylesheet` - true if the xsl:stylesheet element is to be excluded
      Throws:
        `XPathException` - if validation fails

    - #### isPermittedChild

          protected boolean isPermittedChild​(StyleElement child)

      Check whether a given child is permitted for this element. This method is used when a non-instruction child element such as xsl:sort is encountered in a context where instructions would normally be expected.
      Parameters:
        `child` - the child that may or may not be permitted
      Returns:
        true if the child is permitted.

    - #### getPrincipalStylesheetModule

          public PrincipalStylesheetModule getPrincipalStylesheetModule()

      Get the principal stylesheet module of the package in which this XSLT element appears
      Returns:
        the containing package

    - #### getContainingPackage

          public StylesheetPackage getContainingPackage()

      Get the containing package (the principal stylesheet module of the package in which this XSLT element appears)
      Returns:
        the containing package. May be null if the method is called during initialization.

    - #### checkTopLevel

          public void checkTopLevel​(java.lang.String errorCode,
                                    boolean allowOverride)

      Convenience method to check that the stylesheet element is at the top level (that is, as a child of xsl:stylesheet or xsl:transform)
      Parameters:
        `errorCode` - the error to throw if it is not at the top level; defaults to XTSE0010 if the value is null
        `allowOverride` - true if the element is allowed to appear as a child of xsl:override

    - #### checkEmpty

          public void checkEmpty()

      Convenience method to check that the stylesheet element is empty

    - #### reportAbsence

          public void reportAbsence​(java.lang.String attribute)

      Convenience method to report the absence of a mandatory attribute
      Parameters:
        `attribute` - the name of the attribute whose absence is to be reported

    - #### compile

          public Expression compile​(Compilation compilation,
                                    ComponentDeclaration decl)
                             throws XPathException

      Compile the instruction on the stylesheet tree into an executable instruction for use at run-time.
      Parameters:
        `compilation` - the compilation episode
        `decl` - the containing top-level declaration, for example xsl:function or xsl:template
      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` - if validation fails

    - #### isWithinDeclaredStreamableConstruct

          protected boolean isWithinDeclaredStreamableConstruct()

    - #### generateId

          protected java.lang.String generateId()

    - #### compileDeclaration

          public void compileDeclaration​(Compilation compilation,
                                         ComponentDeclaration decl)
                                  throws XPathException

      Compile a declaration in the stylesheet tree for use at run-time.
      Parameters:
        `compilation` - the compilation episode
        `decl` - the containing top-level declaration, for example xsl:function or xsl:template
      Throws:
        `XPathException` - if compilation fails

    - #### compileSequenceConstructor

          public Expression compileSequenceConstructor​(Compilation compilation,
                                                       ComponentDeclaration decl,
                                                       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.
      Parameters:
        `compilation` - the Executable
        `decl` - the Declaration of the containing top-level stylesheet element
        `includeParams` - true if xsl:param elements are to be treated as child instructions (true for templates but not for functions)
      Returns:
        the compiled sequence constructor
      Throws:
        `XPathException` - if compilation fails

    - #### compileSequenceConstructor

          public Expression compileSequenceConstructor​(Compilation compilation,
                                                       ComponentDeclaration decl,
                                                       SequenceIterator 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.
      Parameters:
        `compilation` - the Executable
        `decl` - the Declaration of the containing top-level stylesheet element
        `iter` - Iterator over the children. This is used in the case where there are children that are not part of the sequence constructor, for example the xsl:sort children of xsl:for-each; the iterator can be positioned past such elements.
        `includeParams` - true if xsl:param elements are to be treated as child instructions (true for templates but not for functions)
      Returns:
        the compiled sequence constructor
      Throws:
        `XPathException` - if compilation fails

    - #### allocateLocation

          protected Location allocateLocation()

      Allocate a location
      Returns:
        an location which can be used to report the location of the instruction

    - #### getWithParamInstructions

          public WithParam[] getWithParamInstructions​(Expression parent,
                                                      Compilation compilation,
                                                      ComponentDeclaration decl,
                                                      boolean tunnel)
                                               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:
        `compilation` - the compilation episode
        `decl` - the containing stylesheet declaration
        `tunnel` - true if the tunnel="yes" parameters are wanted, false to get
      Returns:
        an array of WithParam objects for either the ordinary parameters or the tunnel parameters, as an array containing the results of compiling the xsl:with-param children of this instruction (if any)
      Throws:
        `XPathException` - if any error is detected

    - #### compileError

          public void compileError​(XmlProcessingError error)

      Report an error with diagnostic information
      Parameters:
        `error` - contains information about the error

    - #### compileError

          public void compileError​(XPathException err)

    - #### compileError

          public void compileError​(java.lang.String message)

      Report a static error in the stylesheet
      Parameters:
        `message` - the error message

    - #### compileError

          public void compileError​(java.lang.String message,
                                   StructuredQName errorCode)

      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

    - #### compileError

          public void compileError​(java.lang.String message,
                                   java.lang.String errorCode)

      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

    - #### compileError

          public void compileError​(java.lang.String message,
                                   java.lang.String errorCode,
                                   Location loc)

    - #### compileErrorInAttribute

          public void compileErrorInAttribute​(java.lang.String message,
                                              java.lang.String errorCode,
                                              java.lang.String attributeName)

      Compile time error, specifying an error code and the name of the attribute that is in error.
      Parameters:
        `message` - the error message
        `errorCode` - the error code. May be null if not known or not defined
        `attributeName` - the name of the attribute. For attributes in no namespace this is the local part of the name; for namespaced attributes a name in Clark format may be supplied.

    - #### invalidAttribute

          protected void invalidAttribute​(java.lang.String attributeName,
                                          java.lang.String allowedValues)

    - #### requireSyntaxExtensions

          protected void requireSyntaxExtensions​(java.lang.String attributeName)

      Ask whether XSLT syntax extensions are allowed, for example xsl:when/@select. Returns true if explicitly enabled in the configuration. Note, this is not affected by forwards-compatibility mode (because it's too error-prone to simply ignore the presence of these attributes).

    - #### compileWarning

          public void compileWarning​(java.lang.String message,
                                     StructuredQName errorCode)

    - #### compileWarning

          public void compileWarning​(java.lang.String message,
                                     java.lang.String errorCode)

    - #### compileWarning

          public void compileWarning​(java.lang.String message,
                                     java.lang.String errorCode,
                                     Location location)

    - #### issueWarning

          protected void issueWarning​(XPathException error)

      Report a warning to the error listener
      Parameters:
        `error` - an exception containing the warning text

    - #### issueWarning

          protected void issueWarning​(java.lang.String message,
                                      javax.xml.transform.SourceLocator locator)

      Report a warning to the error listener
      Parameters:
        `message` - the warning message text
        `locator` - the location of the problem in the source stylesheet

    - #### isTopLevel

          public boolean isTopLevel()

      Test whether this is a top-level element
      Returns:
        true if the element is a child of the xsl:stylesheet or xsl:package element

    - #### getBindingInformation

          public SourceBinding getBindingInformation​(StructuredQName name)

      Ask whether this element contains a binding for a variable with a given name; and if it does, return the source binding information
      Parameters:
        `name` - the variable name
      Returns:
        the binding information if this element binds a variable of this name; otherwise null

    - #### bindVariable

          public SourceBinding bindVariable​(StructuredQName qName)

      Bind a variable used in this element to the compiled form of the XSLVariable element in which it is declared
      Parameters:
        `qName` - The name of the variable
      Returns:
        the XSLVariableDeclaration (that is, an xsl:variable or xsl:param instruction) for the variable, or null if no declaration of the variable can be found

    - #### bindLocalVariable

          public SourceBinding bindLocalVariable​(StructuredQName qName)

      Bind a variable reference used in this element to the compiled form of the XSLVariable element in which it is declared, considering only local variables and params
      Parameters:
        `qName` - The name of the variable
      Returns:
        the XSLVariableDeclaration (that is, an xsl:variable or xsl:param instruction) for the variable, or null if no local declaration of the variable can be found

    - #### seesAvuncularVariables

          protected boolean seesAvuncularVariables()

      Ask whether variables declared in an "uncle" element are visible.
      Returns:
        true for all elements except xsl:fallback and xsl:catch

    - #### hasImplicitBinding

          protected SourceBinding hasImplicitBinding​(StructuredQName name)

      Ask whether this particular element implicitly binds a given variable (used for xsl:accumulator-rule)

    - #### getObjectName

          public StructuredQName getObjectName()

      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 null.
      Returns:
        the name of the object declared in this element, if any

    - #### setObjectName

          public void setObjectName​(StructuredQName qName)

      Set the object name, for example the name of a function, variable, or template declared on this element
      Parameters:
        `qName` - the object name as a QName

    - #### getProperties

          public java.util.Iterator<java.lang.String> 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.