## 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:
  Container, FingerprintedNode, InstructionInfo, Item, LocationProvider, org.xml.sax.Locator, NodeInfo, SaxonLocator, javax.xml.transform.Source, javax.xml.transform.SourceLocator, ValueRepresentation

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 org.xml.sax.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 Summary
`protected java.lang.String` `defaultCollationName`
`protected java.lang.String` `defaultXPathNamespace`
`protected short[]` `extensionNamespaces`
`static int` `REPORT_ALWAYS`
`static int` `REPORT_IF_INSTANTIATED`
`static int` `REPORT_UNLESS_FALLBACK_AVAILABLE`
`static int` `REPORT_UNLESS_FORWARDS_COMPATIBLE`
`protected int` `reportingCircumstances`
`protected StaticContext` `staticContext`
`protected StaticError` `validationError`
`protected java.math.BigDecimal` `version`

Fields inherited from class net.sf.saxon.tree.ElementWithAttributes
`attributeList, namespaceList`

Fields inherited from class net.sf.saxon.tree.ElementImpl
`nameCode, root, sequence`

Fields inherited from class net.sf.saxon.tree.NodeImpl
`index, NODE_LETTER, parent`

Fields inherited from interface net.sf.saxon.om.NodeInfo
`ALL_NAMESPACES, EMPTY_NAMESPACE_LIST, IS_DTD_TYPE, LOCAL_NAMESPACES, NO_NAMESPACES`

Fields inherited from interface net.sf.saxon.om.ValueRepresentation
`EMPTY_VALUE_ARRAY`

Constructor Summary
`StyleElement()` Constructor

Method Summary
`int` `allocateLocationId(java.lang.String systemId, int lineNumber)` Allocate a location identifier
`void` `allocateSlots(Expression exp)` Allocate slots in the local stack frame to range variables used in an XPath expression
`boolean` `backwardsCompatibleModeIsEnabled()` Determine whether backwards-compatible mode is enabled for this element
`XSLVariableDeclaration` `bindVariable(int fingerprint)` 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
`protected void` `checkSortComesFirst(boolean sortRequired)` Check that among the children of this element, any xsl:sort elements precede any other elements
`void` `checkTopLevel(java.lang.String errorCode)` Convenience method to check that the stylesheet element is at the top level
`protected void` `checkUnknownAttribute(int nc)` Check whether an unknown attribute is permitted.
`void` `checkWithinTemplate()` Check that the stylesheet element is within a sequence constructor
`abstract Expression` `compile(Executable exec)` Compile the instruction on the stylesheet tree into an executable instruction for use at run-time.
`protected void` `compileError(java.lang.String message)`
`protected void` `compileError(java.lang.String message, java.lang.String errorCode)` Compile time error, specifying an error code
`protected void` `compileError(javax.xml.transform.TransformerException error)` Construct an exception with diagnostic information
`Expression` `compileSequenceConstructor(Executable exec, AxisIterator 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.
`protected void` `compileWarning(java.lang.String message, java.lang.String errorCode)`
`protected boolean` `definesExcludedNamespace(short uriCode)` Check whether this node excludes a particular namespace from the result.
`protected boolean` `definesExtensionElement(short uriCode)` Check whether a particular extension element namespace is defined on this node.
`protected Expression` `fallbackProcessing(Executable exec, StyleElement instruction)` Perform fallback processing.
`void` `fixupReferences()` Fix up references from XPath expressions.
`boolean` `forwardsCompatibleModeIsEnabled()` Determine whether forwards-compatible mode is enabled for this element
`protected AttributeSet[]` `getAttributeSets(java.lang.String use, java.util.List list)` Get the list of attribute-sets associated with this element.
`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).
`protected ItemType` `getCommonChildItemType()` Get the most general type of item returned by the children of this instruction
`int` `getConstructType()` Get the type of construct.
`SlotManager` `getContainingSlotManager()` Get the SlotManager for the containing Procedure definition
`XSLStylesheet` `getContainingStylesheet()` Get the containing XSLStylesheet element
`protected java.lang.String` `getDefaultCollationName()` Get the default collation for this element
`protected short` `getDefaultXPathNamespace()` Get the default XPath namespace code applicable to this element
`Executable` `getExecutable()` Get the Executable (representing a complete stylesheet or query) of which this Container forms part
`protected StyleElement` `getLastChildInstruction()` Find the last child instruction of this instruction.
`int` `getLineNumber()` Return the line number where the current document event ends.
`int` `getLineNumber(int locationId)`
`LocationProvider` `getLocationProvider()` Get the LocationProvider allowing location identifiers to be resolved.
`NamespaceResolver` `getNamespaceResolver()` Get the namespace context of the instruction.
`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.
`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.
`int` `getPrecedence()` Get the import precedence of this stylesheet element.
`PreparedStylesheet` `getPreparedStylesheet()` Get the PreparedStylesheet object.
`protected XSLStylesheet` `getPrincipalStylesheet()` Get the principal XSLStylesheet node.
`java.util.Iterator` `getProperties()` Get an iterator over all the properties available.
`java.lang.Object` `getProperty(java.lang.String name)` Get the value of a particular property of the instruction.
`protected ItemType` `getReturnedItemType()` Determine the type of item returned by this instruction (only relevant if it is an instruction).
`SchemaType` `getSchemaType(java.lang.String typeAtt)` Get the Schema type definition for a type named in the stylesheet (in a "type" attribute).
`StaticContext` `getStaticContext()` Get the static context for expressions on this element
`XSLFunction` `getStylesheetFunction(int fingerprint, int arity)` Get a FunctionCall declared using an xsl:function element in the stylesheet
`java.lang.String` `getSystemId(int locationId)`
`NamePool` `getTargetNamePool()` Get the namepool to be used at run-time, this namepool holds the names used in all XPath expressions and patterns
`int` `getTypeAnnotation(SchemaType schemaType)` Get the type annotation to use for a given schema type
`java.math.BigDecimal` `getVersion()` Get the numeric value of the version number on this element, or inherited from its ancestors
`protected WithParam[]` `getWithParamInstructions(Executable exec, boolean tunnel, Instruction caller)` Get the list of xsl:with-param elements for a calling element (apply-templates, call-template, apply-imports, next-match).
`boolean` `isExcludedNamespace(short uriCode)` Check whether a namespace uri defines an namespace excluded from the result.
`protected boolean` `isExplaining()` Determine whether saxon:explain has been set to "yes"
`boolean` `isExtensionNamespace(short uriCode)` Check whether a namespace uri defines an extension element.
`boolean` `isInstruction()` Determine whether this node is an instruction.
`protected boolean` `isPermittedChild(StyleElement child)` Specify that certain children are permitted for this element
`protected void` `issueWarning(java.lang.String message, javax.xml.transform.SourceLocator locator)`
`protected void` `issueWarning(javax.xml.transform.TransformerException error)` Construct an exception with diagnostic information
`boolean` `isTopLevel()` Test whether this is a top-level element
`Expression` `makeAttributeValueTemplate(java.lang.String expression)` Make an attribute value template in the context of this stylesheet element
`Expression` `makeExpression(java.lang.String expression)` Make an expression in the context of this stylesheet element
`int` `makeNameCode(java.lang.String qname)` Make a NameCode, using this Element as the context for namespace resolution, and registering the code in the namepool.
`SavedNamespaceContext` `makeNamespaceContext()` Make a NamespaceContext object representing the list of in-scope namespaces.
`Pattern` `makePattern(java.lang.String pattern)` Make a pattern in the context of this stylesheet element
`SequenceType` `makeSequenceType(java.lang.String sequenceType)` Process an attribute whose value is a SequenceType
`protected SortKeyDefinition[]` `makeSortKeys()` Construct sort keys for a SortedIterator
`protected static TraceWrapper` `makeTraceInstruction(StyleElement source, Expression child)` Create a trace instruction to wrap a real instruction
`void` `markTailCalls()` Mark tail-recursive calls on templates and functions.
`boolean` `mayContainFallback()` Determine whether this type of element is allowed to contain an xsl:fallback instruction
`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.
`abstract void` `prepareAttributes()` Set the attribute list for the element.
`void` `processAllAttributes()` Process the attributes of this element and all its children
`void` `processAttributes()` Process the attribute list for the element.
`protected void` `processDefaultCollationAttribute(java.lang.String nc)` Process the [xsl:]default-xpath-namespace attribute if there is one
`protected void` `processDefaultXPathNamespaceAttribute(java.lang.String nc)` Process the [xsl:]default-xpath-namespace attribute if there is one
`protected void` `processExcludedNamespaces(java.lang.String nc)` Process the [xsl:]exclude-result-prefixes attribute if there is one
`protected void` `processExtensionElementAttribute(java.lang.String nc)` Process the [xsl:]extension-element-prefixes attribute if there is one
`protected void` `processVersionAttribute(java.lang.String nc)` 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
`void` `setLineNumber(int lineNumber)` Set the line number of the element within its source document entity
`void` `setObjectNameCode(int nameCode)` Set the object name code
`protected void` `setValidationError(javax.xml.transform.TransformerException reason, int 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.
`protected void` `undeclaredNamespaceError(java.lang.String prefix, java.lang.String errorCode)`
`void` `validate()` Check that the stylesheet element is valid.
`protected void` `validateChildren()` Validate the children of this node, recursively.
`void` `validateSubtree()` Recursive walk through the stylesheet to validate all nodes

Methods inherited from class net.sf.saxon.tree.ElementWithAttributes
`copy, getAttributeList, getAttributeValue, getDeclaredNamespaces, getInScopeNamespaceCodes, getPrefixForURI, getURICodeForPrefix, getURIForPrefix, initialise, iteratePrefixes, sendNamespaceDeclarations, setNamespaceDeclarations`

Methods inherited from class net.sf.saxon.tree.ElementImpl
`addChild, compact, enumerateChildren, generateId, getBaseURI, getDocumentRoot, getFirstChild, getLastChild, getNameCode, getNodeKind, getNthChild, getRoot, getSequenceNumber, getStringValue, getStringValueCS, getSystemId, hasChildNodes, setNameCode, setSystemId, useChildrenArray`

Methods inherited from class net.sf.saxon.tree.NodeImpl
`atomize, compareOrder, getColumnNumber, getConfiguration, getDisplayName, getDocumentNumber, getFingerprint, getLocalPart, getNamePool, getNextInDocument, getNextSibling, getParent, getPrefix, getPreviousInDocument, getPreviousSibling, getPublicId, getTypeAnnotation, getTypedValue, getURI, isSameNodeInfo, iterateAxis, iterateAxis`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Methods inherited from interface org.xml.sax.Locator
`getColumnNumber, getPublicId, getSystemId`

Methods inherited from interface javax.xml.transform.SourceLocator
`getColumnNumber, getPublicId, getSystemId`

Methods inherited from interface net.sf.saxon.trace.InstructionInfo
`getSystemId`

Field Detail

### extensionNamespaces

    protected short[] extensionNamespaces

### version

    protected java.math.BigDecimal version

### staticContext

    protected StaticContext staticContext

### validationError

    protected StaticError validationError

### reportingCircumstances

    protected int reportingCircumstances

### defaultXPathNamespace

    protected java.lang.String defaultXPathNamespace

### defaultCollationName

    protected java.lang.String defaultCollationName

### REPORT_ALWAYS

    public static final int REPORT_ALWAYS

See Also:
  Constant Field Values

### REPORT_UNLESS_FORWARDS_COMPATIBLE

    public static final int REPORT_UNLESS_FORWARDS_COMPATIBLE

See Also:
  Constant Field Values

### REPORT_IF_INSTANTIATED

    public static final int REPORT_IF_INSTANTIATED

See Also:
  Constant Field Values

### REPORT_UNLESS_FALLBACK_AVAILABLE

    public static final int REPORT_UNLESS_FALLBACK_AVAILABLE

See Also:
  Constant Field Values

Constructor Detail

### StyleElement

    public StyleElement()

  Constructor

Method Detail

### 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 interface: `org.xml.sax.Locator`
  Return the line number where the current document event ends.

  Warning: The return value from the method is intended only as an approximation for the sake of error reporting; it is not intended to provide sufficient information to edit the character content of the original XML document.

  The return value is an approximation of the line number in the document entity or external parsed entity where the markup triggering the event appears.

  If possible, the SAX driver should provide the line position of the first character after the text associated with the document event. The first line in the document is line 1.

  Specified by:
    `getLineNumber` in interface `org.xml.sax.Locator`
  Overrides:
    `getLineNumber` in class `ElementImpl`

### 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(javax.xml.transform.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(java.lang.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 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).

### 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(java.lang.String expression)
                              throws XPathException

  Make an expression in the context of this stylesheet element

  Throws:
    `XPathException`

### makePattern

    public Pattern makePattern(java.lang.String pattern)
                        throws XPathException

  Make a pattern in the context of this stylesheet element

  Throws:
    `XPathException`

### makeAttributeValueTemplate

    public Expression makeAttributeValueTemplate(java.lang.String expression)
                                          throws XPathException

  Make an attribute value template in the context of this stylesheet element

  Throws:
    `XPathException`

### makeSequenceType

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

  Process an attribute whose value is a SequenceType

  Throws:
    `XPathException`

### processExtensionElementAttribute

    protected void processExtensionElementAttribute(java.lang.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(java.lang.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(java.lang.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 java.math.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(java.lang.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 java.lang.String getDefaultCollationName()

  Get the default collation for this element

### 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(java.lang.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(java.lang.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(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.

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

  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(java.lang.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(java.lang.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(java.lang.String systemId,
                                  int lineNumber)

  Allocate a location identifier

### makeSortKeys

    protected SortKeyDefinition[] makeSortKeys()

  Construct sort keys for a SortedIterator

  Returns:
    an array of SortKeyDefinition objects if there are any sort keys; or null if there are none.

### getAttributeSets

    protected AttributeSet[] getAttributeSets(java.lang.String use,
                                              java.util.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(javax.xml.transform.TransformerException error)
                         throws XPathException

  Construct an exception with diagnostic information

  Throws:
    `XPathException`

### compileError

    protected void compileError(java.lang.String message)
                         throws XPathException

  Throws:
    `XPathException`

### compileError

    protected void compileError(java.lang.String message,
                                java.lang.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(java.lang.String prefix,
                                            java.lang.String errorCode)
                                     throws XPathException

  Throws:
    `XPathException`

### compileWarning

    protected void compileWarning(java.lang.String message,
                                  java.lang.String errorCode)
                           throws XPathException

  Throws:
    `XPathException`

### issueWarning

    protected void issueWarning(javax.xml.transform.TransformerException error)

  Construct an exception with diagnostic information

### issueWarning

    protected void issueWarning(java.lang.String message,
                                javax.xml.transform.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 java.lang.Object getProperty(java.lang.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 java.util.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 java.lang.String getSystemId(int locationId)

  Specified by:
    `getSystemId` in interface `LocationProvider`

### getLineNumber

    public int getLineNumber(int locationId)

  Specified by:
    `getLineNumber` in interface `LocationProvider`