StyleElement

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

All Implemented Interfaces:

Source, SourceLocator, PullEvent, Location, FingerprintedNode, Item, MutableNodeInfo, NamespaceResolver, NodeInfo, Sequence, SteppingNode<NodeImpl>, SiblingCountingNode, Locator

Direct Known Subclasses:

AbsentExtensionElement, ExtensionInstruction, LiteralResultElement, SaxonDoctype, SaxonEntityRef, SaxonImportQuery, 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, XSLStream, 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.

Field Summary

Fields
Modifier and Type	Field and 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 String`	`defaultCollationName`
`protected StructuredQName`	`defaultMode`
`protected String`	`defaultXPathNamespace`
`protected boolean`	`expandText`
`protected String[]`	`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 ExpressionContext`	`staticContext`
`protected XPathException`	`validationError`
`protected int`	`version`
`protected static String[]`	`YES_NO`

Fields inherited from class net.sf.saxon.tree.linked.NodeImpl
NODE_LETTER

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

Constructor Summary

Constructors
Constructor and Description

StyleElement()
Constructor

Constructors
Constructor and Description
`StyleElement()` Constructor

Method Summary

Methods
Modifier and Type	Method and Description
`protected void`	`addChild(NodeImpl node, int index)` Add a child node to this node.
`void`	`addXSLOverrideFunctionLibrary(FunctionLibraryList list)` Add a function library that recognizes the function call xsl:original, which is permitted within a function that overrides another
`void`	`allocateLocalSlots(Expression exp)` Allocate slots in the local stack frame to range variables used in an XPath expression
`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
`boolean`	`changesRetainedStaticContext()` Ask whether this instruction requires a different retained static context from the containing (parent) instruction.
`void`	`check30attribute(String attName)` Check an attribute that is permitted under 3.0 but not under 2.0
`protected void`	`checkAttributeValue(String name, String value, boolean avt, String[] allowed)` Check the value of an attribute, as supplied statically
`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(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.
`void`	`compact(int size)` Compact the space used by this node
`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(String message)` Report a static error in the stylesheet
`void`	`compileError(String message, String errorCode)` Compile time error, specifying an error code
`void`	`compileError(String message, StructuredQName errorCode)` Compile time error, specifying an error code
`void`	`compileError(XPathException error)` Report an error with diagnostic information
`void`	`compileErrorInAttribute(String message, String errorCode, 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(String message, String errorCode)`
`void`	`compileWarning(String message, StructuredQName errorCode)`
`protected boolean`	`definesExcludedNamespace(String uri)` Check whether this node excludes a particular namespace from the result.
`protected boolean`	`definesExtensionElement(String uri)` Check whether a particular extension element namespace is defined on this node.
`protected Expression`	`fallbackProcessing(Compilation exec, ComponentDeclaration decl, StyleElement instruction)` Perform fallback processing.
`StyleElement`	`findAncestorElement(int fingerprint)` Get the first ancestor element in the stylesheet tree that has a given name, supplied by fingerprint.
`StringCollator`	`findCollation(String name, String baseURI)` Find a named collation.
`void`	`fixupReferences()` Fix up references from XPath expressions.
`boolean`	`forwardsCompatibleModeIsEnabled()` Determine whether forwards-compatible mode is enabled for this element
`protected String`	`generateId()`
`String`	`getAttributeValue(String clarkName)` Get an attribute value given the Clark name of the attribute (that is, the name in {uri}local format).
`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()`
`int`	`getConstructType()` Get the type of construct.
`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
`XSLModuleRoot`	`getContainingStylesheet()` Get the containing XSLStylesheet or XSLPackage element
`Visibility`	`getDeclaredVisibility()`
`protected String`	`getDefaultCollationName()` Get the default collation for this stylesheet element.
`StructuredQName`	`getDefaultMode()` Get the default mode for this stylesheet element.
`int`	`getDefaultValidation()` Get the value of the default-validation attribute on the containing xsl:stylesheet element
`protected String`	`getDefaultXPathNamespace()` Get the default XPath namespace for elements and types
`int`	`getEffectiveVersion()` Get the numeric value of the version number appearing as an attribute on this element, or inherited from its ancestors
`NodeImpl`	`getFirstChild()` Get the first child node of the element
`int`	`getHostLanguage()` Get the host language (XSLT, XQuery, XPath) used to implement the code in this container
`NodeImpl`	`getLastChild()` Get the last child node of the element
`protected StyleElement`	`getLastChildInstruction()` Find the last child instruction of this instruction.
`Location`	`getLocation()`
`NamespaceResolver`	`getNamespaceResolver()` Get the namespace context of the instruction.
`protected NodeImpl`	`getNthChild(int n)` Get the nth child node of the element (numbering from 0)
`int`	`getNumberOfChildren()` Determine how many children the node has
`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.
`Component`	`getOverriddenComponent()` Get the component that this declaration overrides, or null if this is not an overriding declaration
`StylesheetPackage`	`getPackageData()`
`PrincipalStylesheetModule`	`getPrincipalStylesheetModule()` Get the principal stylesheet module of the package in which this XSLT element appears
`int`	`getProcessorVersion()` Determine what version of the XSLT the configured processor supports
`Iterator<String>`	`getProperties()` Get an iterator over all the properties available.
`Object`	`getProperty(String name)` Get the value of a particular property of the instruction.
`protected int`	`getRawSequenceNumber()`
`SchemaType`	`getSchemaType(String typeAtt)` Get the Schema type definition for a type named in the stylesheet (in a "type" attribute).
`protected long`	`getSequenceNumber()` Get the node sequence number (in document order).
`ExpressionContext`	`getStaticContext()` Get the static context for expressions on this element
`ExpressionContext`	`getStaticContext(StructuredQName attributeName)`
`String`	`getStringValue()` Return the string-value of the node, that is, the concatenation of the character content of all descendent elements and text nodes.
`CharSequence`	`getStringValueCS()` Get the value of the item as a CharSequence.
`SimpleType`	`getTypeAnnotation(SchemaType schemaType)` Get the type annotation to use for a given schema type
`protected StructuredQName[]`	`getUsedAttributeSets(String use)` Get the list of attribute-set names associated with this element.
`StylesheetPackage`	`getUsedPackage()` Assuming this is an xsl:use-package element, find the package to which it refers.
`Visibility`	`getVisibility()`
`protected 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).
`ComponentCode`	`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
`boolean`	`hasChildNodes()` Determine if the node has any children.
`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
`void`	`insertChildren(NodeInfo[] source, boolean atStart, boolean inherit)` Insert a sequence of nodes as children of this node.
`protected void`	`insertChildrenAt(NodeInfo[] source, int index, boolean inherit)` Insert children before or after a given existing child
`protected Visibility`	`interpretVisibilityValue(String s, String flags)` Process the value of the visibility attribute (XSLT 3.0)
`protected void`	`invalidAttribute(String attributeName, String allowedValues)`
`boolean`	`isActionCompleted(int action)` Ask if an action on this StyleElement has been completed
`boolean`	`isDeclaration()` Ask whether this node is a declaration, that is, a permitted child of xsl:stylesheet (including xsl:include and xsl:import).
`boolean`	`isExcludedNamespace(String uri)` Check whether a namespace uri defines an namespace excluded from the result.
`boolean`	`isExpandingText()` Ask whether content value templates are available within this element
`protected boolean`	`isExplaining()` Determine whether saxon:explain has been set to "yes"
`boolean`	`isExtensionNamespace(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(String message, 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
`boolean`	`isXslt30Processor()` Ask whether the configured XSLT processor supports XSLT 3.0
`protected AxisIterator`	`iterateChildren(NodeTest test)` Get an enumeration of the children of this node
`protected Expression`	`makeAttributeValueTemplate(String expression, int attIndex)` Make an attribute value template in the context of this stylesheet element
`Expression`	`makeExpression(String expression, int attIndex)` Compile an XPath expression in the context of this stylesheet element
`ExpressionVisitor`	`makeExpressionVisitor()` Make an expression visitor
`SavedNamespaceContext`	`makeNamespaceContext()` Make a NamespaceContext object representing the list of in-scope namespaces.
`Pattern`	`makePattern(String pattern, String attributeName)` Make a pattern in the context of this stylesheet element
`StructuredQName`	`makeQName(String lexicalQName)` Make a structured QName, using this Element as the context for namespace resolution.
`RetainedStaticContext`	`makeRetainedStaticContext()`
`SequenceType`	`makeSequenceType(String sequenceType)` Process an attribute whose value is a SequenceType
`SortKeyDefinitionList`	`makeSortKeys(Compilation compilation, ComponentDeclaration decl)` Construct sort keys for a SortedIterator
`protected static Expression`	`makeTraceInstruction(StyleElement source, Expression child)` Create a trace instruction to wrap a real instruction
`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(String attName)` 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
`protected void`	`processAttributes()` Process the attribute list for the element.
`boolean`	`processBooleanAttribute(String name, String value)` Process an attribute whose value is yes, no, true, false, 1, or 0; returning true or false.
`protected void`	`processDefaultCollationAttribute()` Process the [xsl:]default-collation attribute if there is one
`protected void`	`processDefaultMode()` Process the [xsl:]default-mode attribute if there is one
`protected void`	`processDefaultXPathNamespaceAttribute(String ns)` Process the [xsl:]xpath-default-namespace attribute if there is one
`protected void`	`processExcludedNamespaces(String ns)` Process the [xsl:]exclude-result-prefixes attribute if there is one
`protected void`	`processExpandTextAttribute(String ns)` Process the [xsl:]expand-text attribute if there is one (and if XSLT 3.0 is enabled)
`protected void`	`processExtensionElementAttribute(String ns)` Process the [xsl:]extension-element-prefixes attribute if there is one
`void`	`processStandardAttributes(String namespace)` Process the standard attributes such as [xsl:]default-collation
`protected void`	`processVersionAttribute(String ns)` Process the [xsl:]version attribute if there is one
`protected void`	`removeChild(NodeImpl child)` Remove a given child
`protected void`	`replaceChildrenAt(NodeInfo[] source, int index, boolean inherit)` Replace child at a given index by new children
`void`	`reportAbsence(String attribute)` Convenience method to report the absence of a mandatory attribute
`protected boolean`	`seesAvuncularVariables()` Ask whether variables declared in an "uncle" element are visible.
`void`	`setActionCompleted(int action)` Say that an action on this StyleElement has been completed
`protected void`	`setChildren(Object children)` Set the children of this node
`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
`protected void`	`setRawSequenceNumber(int seq)`
`void`	`setValidationError(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(String name, Expression exp)` Type-check an expression.
`Pattern`	`typeCheck(String name, Pattern pattern)` Type-check a pattern.
`protected void`	`undeclaredNamespaceError(String prefix, String errorCode, String attributeName)`
`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(String value)` Validate the value of the [xsl:]validation attribute
`boolean`	`xPath10ModeIsEnabled()` Determine whether 1.0-compatible mode is enabled for this element

Methods inherited from class net.sf.saxon.tree.linked.NodeImpl
atomize, compareOrder, comparePosition, equals, getConfiguration, getDisplayName, getFingerprint, getLocalPart, getNameCode, getNamePool, getNextInDocument, getNextSibling, getParent, getPhysicalRoot, getPrefix, getPreviousInDocument, getPreviousSibling, getPublicId, getRawParent, getSiblingPosition, getSuccessorElement, getTreeInfo, getURI, head, insertSiblings, isDeleted, isIdref, isSameNodeInfo, iterate, iterateAxis, iterateAxis, newBuilder, replace, saveLocation, setRawParent, setSiblingPosition

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

Methods inherited from interface net.sf.saxon.om.NodeInfo
hashCode

- Field Detail
  - extensionNamespaces
```
protected String[] extensionNamespaces
```
  - version
```
protected int version
```
  - staticContext
```
protected ExpressionContext staticContext
```
  - validationError
```
protected XPathException validationError
```
  - reportingCircumstances
```
protected int reportingCircumstances
```
  - defaultXPathNamespace
```
protected String defaultXPathNamespace
```
  - defaultCollationName
```
protected String defaultCollationName
```
  - defaultMode
```
protected StructuredQName defaultMode
```
  - expandText
```
protected boolean expandText
```
  - 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
  - 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
  - YES_NO
```
protected static final String[] YES_NO
```
- Constructor Detail
  - StyleElement
```
public StyleElement()
```
    Constructor
- Method Detail
  - getCompilation
```
public Compilation getCompilation()
```
  - setCompilation
```
public void setCompilation(Compilation compilation)
```
  - getPackageData
```
public StylesheetPackage getPackageData()
```
  - getStaticContext
```
public ExpressionContext getStaticContext()
```
    Get the static context for expressions on this element
    
    Returns:
    the static context
  - getStaticContext
```
public ExpressionContext getStaticContext(StructuredQName attributeName)
```
  - 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
  - isExplaining
```
protected boolean isExplaining()
```
    Determine whether saxon:explain has been set to "yes"
    
    Returns:
    true if saxon:explain has been set to "yes" on this element
  - 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(TransformerException reason,
                      int 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()
                         throws XPathException
```
    Throws:
    
    XPathException
  - getDeclaredVisibility
```
public Visibility getDeclaredVisibility()
                                 throws XPathException
```
    Throws:
    
    XPathException
  - 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(String attName)
```
    Determine whether this type of element is allowed to contain an xsl:param element
    
    Parameters:
    attName - if null, the method tests whether an xsl:param child is allowed. If non-null, it tests whether an xsl:param child with the given attribute name is allowed
    
    Returns:
    true if this element is allowed to contain an xsl:param
  - getContainingStylesheet
```
public XSLModuleRoot getContainingStylesheet()
```
    Get the containing XSLStylesheet or XSLPackage element
    
    Returns:
    the XSLStylesheet element representing the outermost element of the containing stylesheet module. Return null if there is no containing XSLStylesheet element
  - getDefaultValidation
```
public int getDefaultValidation()
```
    Get the value of the default-validation attribute on the containing xsl:stylesheet element
    
    Returns:
    the value of default-validation, as a constant from the Validation class, or Validation.STRIP if there is no containing xsl:stylesheet or if it has no default-validation attribute.
  - makeQName
```
public final StructuredQName makeQName(String lexicalQName)
                                throws XPathException,
                                       NamespaceException
```
    Make a structured QName, using this Element as the context for namespace resolution. If the name is unprefixed, the default namespace is not used.
    
    Parameters:
    lexicalQName - The lexical QName as written, in the form "[prefix:]localname". The name must have already been validated as a syntactically-correct QName. Leading and trailing whitespace will be trimmed. If XSLT 3.0 is enabled, then the EQName syntax "Q{uri}local" is also accepted.
    
    Returns:
    the StructuredQName representation of this lexical 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
  - addXSLOverrideFunctionLibrary
```
public void addXSLOverrideFunctionLibrary(FunctionLibraryList list)
```
    Add a function library that recognizes the function call xsl:original, which is permitted within a function that overrides another
    
    Parameters:
    list - the function library list to which the new function library should be added
  - findAncestorElement
```
public StyleElement findAncestorElement(int fingerprint)
```
    Get the first ancestor element in the stylesheet tree that has a given name, supplied by fingerprint. Used particularly in Saxon-HE code to find elements such as xsl:override and xsl:use-package that are not present in the Saxon-HE codebase
    
    Parameters:
    fingerprint - the name of the required element
    
    Returns:
    the first (innermost) ancestor with the required name, or null if none is found
  - 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 ComponentCode 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
  - getOverriddenComponent
```
public Component getOverriddenComponent()
```
    Get the component that this declaration overrides, or null if this is not an overriding declaration
    
    Returns:
    the overridden component, or null
  - makeNamespaceContext
```
public SavedNamespaceContext makeNamespaceContext()
```
    Make a NamespaceContext object representing the list of in-scope namespaces. This will be a copy of the namespace context with no references to objects in the stylesheet tree, so that it can be kept until run-time without locking the tree down in memory.
    
    Returns:
    a copy of the namespace context
  - makeRetainedStaticContext
```
public RetainedStaticContext makeRetainedStaticContext()
```
  - changesRetainedStaticContext
```
public boolean changesRetainedStaticContext()
```
    Ask whether this instruction requires a different retained static context from the containing (parent) instruction. That is, this instruction changes the static base URI, the default collation, or the set of in-scope namespaces.
    
    Returns:
    true if the context for evaluating this instruction differs in relevant ways from that of the calling instruction
  - 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(String namespace)
                               throws XPathException
```
    Process the standard attributes such as [xsl:]default-collation
    
    Parameters:
    namespace - either "" to find the attributes in the null namespace, or NamespaceConstant.XSLT to find them in the XSLT namespace
    
    Throws:
    
    XPathException - if any of the standard attributes is incorrect
  - getAttributeValue
```
public String getAttributeValue(String clarkName)
```
    Get an attribute value given the Clark name of the attribute (that is, the name in {uri}local format).
    
    Parameters:
    clarkName - the name of the attribute in {uri}local format
    
    Returns:
    the value of the attribute if it exists, or null otherwise
  - processAttributes
```
protected 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 - if a static error is detected
  - checkUnknownAttribute
```
protected void checkUnknownAttribute(NodeName nc)
                              throws XPathException
```
    Check whether an unknown attribute is permitted.
    
    Parameters:
    nc - The name code of the attribute name
    
    Throws:
    
    XPathException - (and reports the error) if this is an attribute that is not permitted on the containing element
  - check30attribute
```
public void check30attribute(String attName)
                      throws XPathException
```
    Check an attribute that is permitted under 3.0 but not under 2.0
    
    Throws:
    
    XPathException
  - prepareAttributes
```
protected 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 - if a static error is detected
  - 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.
    
    Returns:
    the last child instruction, or null if there are no child instructions
  - makeExpression
```
public Expression makeExpression(String expression,
                        int attIndex)
                          throws XPathException
```
    Compile an XPath expression in the context of this stylesheet element
    
    Parameters:
    expression - the source text of the XPath expression
    attIndex - the index position of the attribute containing the XPath expression, or -1 if the expression is in a text node
    
    Returns:
    the compiled expression tree for the XPath expression
    
    Throws:
    
    XPathException - if a static error is detected in the XPath expression
  - makePattern
```
public Pattern makePattern(String pattern,
                  String attributeName)
                    throws XPathException
```
    Make a pattern in the context of this stylesheet element
    
    Parameters:
    pattern - the source text of the pattern
    
    Returns:
    the compiled pattern
    
    Throws:
    
    XPathException - if a static error is detected in the pattern
  - makeAttributeValueTemplate
```
protected Expression makeAttributeValueTemplate(String expression,
                                    int attIndex)
                                         throws XPathException
```
    Make an attribute value template in the context of this stylesheet element
    
    Parameters:
    expression - the source text of the attribute 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)
    
    Throws:
    
    XPathException - if a static error is detected in the AVT
  - getLocation
```
public Location getLocation()
```
  - checkAttributeValue
```
protected void checkAttributeValue(String name,
                       String value,
                       boolean avt,
                       String[] allowed)
                            throws XPathException
```
    Check the value of an attribute, as supplied statically
    
    Parameters:
    name - the name of the attribute
    value - the value of the attribute
    avt - set to true if the value is permitted to be an attribute value template
    allowed - list of permitted values, which must be in alphabetical order
    
    Throws:
    
    XPathException - if the value given for the attribute is not a permitted value
  - processBooleanAttribute
```
public boolean processBooleanAttribute(String name,
                              String value)
                                throws XPathException
```
    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
    
    Throws:
    
    XPathException - if the value is not one of the above
  - makeSequenceType
```
public SequenceType makeSequenceType(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
  - processExtensionElementAttribute
```
protected void processExtensionElementAttribute(String ns)
                                         throws XPathException
```
    Process the [xsl:]extension-element-prefixes attribute if there is one
    
    Parameters:
    ns - the namespace URI of the attribute - either the XSLT namespace or "" for the null namespace
    
    Throws:
    
    XPathException - if the value of the attribute is invalid
  - processExcludedNamespaces
```
protected void processExcludedNamespaces(String ns)
                                  throws XPathException
```
    Process the [xsl:]exclude-result-prefixes attribute if there is one
    
    Parameters:
    ns - the namespace URI of the attribute required, either the XSLT namespace or ""
    
    Throws:
    
    XPathException - if the value of the attribute is invalid
  - processVersionAttribute
```
protected void processVersionAttribute(String ns)
                                throws XPathException
```
    Process the [xsl:]version attribute if there is one
    
    Parameters:
    ns - the namespace URI of the attribute required, either the XSLT namespace or ""
    
    Throws:
    
    XPathException - if the value of the attribute is invalid
  - getEffectiveVersion
```
public int getEffectiveVersion()
```
    Get the numeric value of the version number appearing as an attribute on this element, or inherited from its ancestors
    
    Returns:
    the version number times ten as an integer
  - validateValidationAttribute
```
protected int validateValidationAttribute(String value)
                                   throws XPathException
```
    Validate the value of the [xsl:]validation attribute
    
    Parameters:
    value - the raw value of the attribute
    
    Returns:
    the encoded value of the attribute
    
    Throws:
    
    XPathException - if the attribute value is invalid
  - forwardsCompatibleModeIsEnabled
```
public boolean forwardsCompatibleModeIsEnabled()
```
    Determine whether forwards-compatible mode is enabled for this element
    
    Returns:
    true if forwards-compatible mode is enabled
  - xPath10ModeIsEnabled
```
public boolean xPath10ModeIsEnabled()
```
    Determine whether 1.0-compatible mode is enabled for this element
    
    Returns:
    true if 1.0 compatable mode is enabled, that is, if this or an enclosing element specifies an [xsl:]version attribute whose value is less than 2.0
  - getProcessorVersion
```
public int getProcessorVersion()
```
    Determine what version of the XSLT the configured processor supports
    
    Returns:
    the version of XSLT supported by the processor, times ten as an integer
  - isXslt30Processor
```
public boolean isXslt30Processor()
```
    Ask whether the configured XSLT processor supports XSLT 3.0
    
    Returns:
    true if the configured XSLT processor supports XSLT 3.0
  - processDefaultCollationAttribute
```
protected void processDefaultCollationAttribute()
                                         throws XPathException
```
    Process the [xsl:]default-collation attribute if there is one
    
    Throws:
    
    XPathException - if the value is not a valid URI, or not a recognized collation URI
  - getDefaultCollationName
```
protected String getDefaultCollationName()
```
    Get the default collation for this stylesheet element. If no default collation is specified in the stylesheet, return the Unicode codepoint collation name.
    
    Returns:
    the name of the default collation
  - findCollation
```
public StringCollator findCollation(String name,
                           String baseURI)
                             throws XPathException
```
    Find a named collation. Note this method should only be used at compile-time, before declarations have been pre-processed. After that time, use getCollation().
    
    Parameters:
    name - identifies the name of the collation required
    baseURI - the base URI to be used for resolving the collation name if it is relative
    
    Returns:
    null if the collation is not found
    
    Throws:
    
    XPathException - if either URI is invalid as a URI
  - processDefaultMode
```
protected void processDefaultMode()
                           throws XPathException
```
    Process the [xsl:]default-mode attribute if there is one
    
    Throws:
    
    XPathException - if the value is not a valid EQName, or the token #unnamed
  - getDefaultMode
```
public StructuredQName getDefaultMode()
                               throws XPathException
```
    Get the default mode for this stylesheet element.
    
    Returns:
    the name of the default mode
    
    Throws:
    
    XPathException
  - definesExtensionElement
```
protected boolean definesExtensionElement(String uri)
```
    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:
    uri - the namespace URI being tested
    
    Returns:
    true if this namespace is defined on this element as an extension element namespace
  - isExtensionNamespace
```
public boolean isExtensionNamespace(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
  - definesExcludedNamespace
```
protected boolean definesExcludedNamespace(String uri)
```
    Check whether this node excludes a particular namespace from the result. This method checks this node only, not the ancestor nodes.
    
    Parameters:
    uri - the namespace URI being tested
    
    Returns:
    true if the namespace is excluded by virtue of an [xsl:]exclude-result-prefixes attribute
  - isExcludedNamespace
```
public boolean isExcludedNamespace(String uri)
```
    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:
    uri - the namespace URI being tested
    
    Returns:
    true if this namespace URI is a namespace excluded by virtue of exclude-result-prefixes on this element or on an ancestor element
  - processDefaultXPathNamespaceAttribute
```
protected void processDefaultXPathNamespaceAttribute(String ns)
```
    Process the [xsl:]xpath-default-namespace attribute if there is one
    
    Parameters:
    ns - the namespace URI of the attribute required (the default namespace or the XSLT namespace.)
  - getDefaultXPathNamespace
```
protected 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
  - processExpandTextAttribute
```
protected void processExpandTextAttribute(String ns)
                                   throws XPathException
```
    Process the [xsl:]expand-text attribute if there is one (and if XSLT 3.0 is enabled)
    
    Parameters:
    ns - the namespace URI of the attribute required (the default namespace or the XSLT namespace.)
    
    Throws:
    
    XPathException - if the value of the attribute is invalid
  - isExpandingText
```
public boolean isExpandingText()
```
    Ask whether content value templates are available within this element
    
    Returns:
    true if content value templates are enabled
  - getSchemaType
```
public SchemaType getSchemaType(String typeAtt)
                         throws XPathException
```
    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
    
    Throws:
    
    XPathException - if the type is not declared in an imported schema, or is not a built-in 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(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
  - allocateLocalSlots
```
public void allocateLocalSlots(Expression exp)
```
    Allocate slots in the local stack frame to range variables used in an XPath expression
    
    Parameters:
    exp - the XPath expression for which slots are to be allocated
  - typeCheck
```
public Pattern typeCheck(String name,
                Pattern pattern)
                  throws XPathException
```
    Type-check a pattern. This is called to check each pattern while the containing instruction is being validated. It is not just a static type-check, it also adds code to perform any necessary run-time type checking and/or conversion.
    
    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
  - checkSortComesFirst
```
protected void checkSortComesFirst(boolean sortRequired)
                            throws XPathException
```
    Check that among the children of this element, any xsl:sort elements precede any other elements
    
    Parameters:
    sortRequired - true if there must be at least one xsl:sort element
    
    Throws:
    
    XPathException - if invalid
  - checkTopLevel
```
public void checkTopLevel(String errorCode,
                 boolean allowOverride)
                   throws XPathException
```
    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
    
    Throws:
    
    XPathException - if not at top level
  - checkEmpty
```
public void checkEmpty()
                throws XPathException
```
    Convenience method to check that the stylesheet element is empty
    
    Throws:
    
    XPathException - if it is not empty
  - reportAbsence
```
public void reportAbsence(String attribute)
                   throws XPathException
```
    Convenience method to report the absence of a mandatory attribute
    
    Parameters:
    attribute - the name of the attribute whose absence is to be reported
    
    Throws:
    
    XPathException - if the attribute is missing
  - 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
  - generateId
```
protected 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
  - makeTraceInstruction
```
protected static Expression makeTraceInstruction(StyleElement source,
                              Expression child)
```
    Create a trace instruction to wrap a real instruction
    
    Parameters:
    source - the parent element
    child - the compiled expression tree for the instruction to be traced
    
    Returns:
    a wrapper instruction that performs the tracing (if activated at run-time)
  - fallbackProcessing
```
protected Expression fallbackProcessing(Compilation exec,
                            ComponentDeclaration decl,
                            StyleElement instruction)
                                 throws XPathException
```
    Perform fallback processing. Generate fallback code for an extension instruction that is not recognized by the implementation.
    
    Parameters:
    exec - the Executable
    decl - the Declaration of the top-level element containing the extension instruction
    instruction - The unknown extension instruction
    
    Returns:
    the expression tree representing the fallback code
    
    Throws:
    
    XPathException - if any error occurs
  - allocateLocation
```
protected Location allocateLocation()
```
    Allocate a location
    
    Returns:
    an location which can be used to report the location of the instruction
  - makeSortKeys
```
public SortKeyDefinitionList makeSortKeys(Compilation compilation,
                                 ComponentDeclaration decl)
                                   throws XPathException
```
    Construct sort keys for a SortedIterator
    
    Parameters:
    compilation - the compilation episode
    decl - the declaration containing the sort keys @throws XPathException if any error is detected
    
    Returns:
    an array of SortKeyDefinition objects if there are any sort keys; or null if there are none.
    
    Throws:
    
    XPathException - if an error is found
  - getUsedAttributeSets
```
protected StructuredQName[] getUsedAttributeSets(String use)
                                          throws XPathException
```
    Get the list of attribute-set names 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
    
    Returns:
    an array of names of the attribute sets
    
    Throws:
    
    XPathException - if any error is detected
  - interpretVisibilityValue
```
protected Visibility interpretVisibilityValue(String s,
                                  String flags)
                                       throws XPathException
```
    Process the value of the visibility attribute (XSLT 3.0)
    
    Parameters:
    s - the value of the attribute after whitespace collapsing
    flags - contains "h" if the value "hidden" is allowed, "a" if the value "absent" is allowed
    
    Returns:
    the corresponding visibility
    
    Throws:
    
    XPathException - if the value is invalid
  - getWithParamInstructions
```
protected 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(XPathException error)
                  throws XPathException
```
    Report an error with diagnostic information
    
    Parameters:
    error - contains information about the error
    
    Throws:
    
    XPathException - always, after reporting the error to the ErrorListener
  - compileError
```
public void compileError(String message)
                  throws XPathException
```
    Report a static error in the stylesheet
    
    Parameters:
    message - the error message
    
    Throws:
    
    XPathException - always, after reporting the error to the ErrorListener
  - compileError
```
public void compileError(String message,
                StructuredQName 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 - always, after reporting the error to the ErrorListener
  - compileError
```
public void compileError(String message,
                String errorCode)
                  throws XPathException
```
    Compile time error, specifying an error code
    
    Parameters:
    message - the error message
    errorCode - the error code. May be null if not known or not defined
    
    Throws:
    
    XPathException - always, after reporting the error to the ErrorListener
  - compileErrorInAttribute
```
public void compileErrorInAttribute(String message,
                           String errorCode,
                           String attributeName)
                             throws XPathException
```
    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.
    
    Throws:
    
    XPathException - always, after reporting the error to the ErrorListener
  - invalidAttribute
```
protected void invalidAttribute(String attributeName,
                    String allowedValues)
                         throws XPathException
```
    Throws:
    
    XPathException
  - undeclaredNamespaceError
```
protected void undeclaredNamespaceError(String prefix,
                            String errorCode,
                            String attributeName)
                                 throws XPathException
```
    Throws:
    
    XPathException
  - compileWarning
```
public void compileWarning(String message,
                  StructuredQName errorCode)
                    throws XPathException
```
    Throws:
    
    XPathException
  - compileWarning
```
public void compileWarning(String message,
                  String errorCode)
                    throws XPathException
```
    Throws:
    
    XPathException
  - 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(String message,
                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 saxon:catch
  - hasImplicitBinding
```
protected SourceBinding hasImplicitBinding(StructuredQName name)
```
    Ask whether this particular element implicitly binds a given variable (used for xsl:accumulator-rule)
  - getConstructType
```
public int getConstructType()
```
    Get the type of construct. This will be a constant in class LocationKind. This method is part of the InstructionInfo interface
  - 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
  - getProperty
```
public Object getProperty(String name)
```
    Get the value of a particular property of the instruction. This is part of the InstructionInfo interface for run-time tracing and debugging. The properties available include all the attributes of the source instruction (named by the attribute name): these are all provided as string values.
    
    Parameters:
    name - The name of the required property
    
    Returns:
    The value of the requested property, or null if the property is not available
  - getProperties
```
public Iterator<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.
  - getHostLanguage
```
public int getHostLanguage()
```
    Get the host language (XSLT, XQuery, XPath) used to implement the code in this container
    
    Returns:
    typically Configuration.XSLT or Configuration.XQUERY
  - isActionCompleted
```
public boolean isActionCompleted(int action)
```
    Ask if an action on this StyleElement has been completed
    
    Parameters:
    action - for example ACTION_VALIDATE
    
    Returns:
    true if the action has already been performed
  - setActionCompleted
```
public void setActionCompleted(int action)
```
    Say that an action on this StyleElement has been completed
    
    Parameters:
    action - for example ACTION_VALIDATE
  - getSequenceNumber
```
protected final long getSequenceNumber()
```
    Get the node sequence number (in document order). Sequence numbers are monotonic but not consecutive. In the current implementation, parent nodes (elements and document nodes) have a zero least-significant word, while namespaces, attributes, text nodes, comments, and PIs have the top word the same as their owner and the bottom half reflecting their relative position. For nodes added by XQUery Update, the sequence number is -1L
    
    Overrides:
    
    getSequenceNumber in class NodeImpl
    
    Returns:
    the sequence number if there is one, or -1L otherwise.
  - getRawSequenceNumber
```
protected final int getRawSequenceNumber()
```
  - setRawSequenceNumber
```
protected final void setRawSequenceNumber(int seq)
```
  - setChildren
```
protected final void setChildren(Object children)
```
    Set the children of this node
    
    Parameters:
    children - null if there are no children, a single NodeInfo if there is one child, an array of NodeInfo if there are multiple children
  - hasChildNodes
```
public final boolean hasChildNodes()
```
    Determine if the node has any children.
    
    Specified by:
    
    hasChildNodes in interface NodeInfo
    
    Overrides:
    
    hasChildNodes in class NodeImpl
    
    Returns:
    true if the node has any children, false if the node has no children.
  - getNumberOfChildren
```
public final int getNumberOfChildren()
```
    Determine how many children the node has
    
    Returns:
    the number of children of this parent node
  - iterateChildren
```
protected final AxisIterator iterateChildren(NodeTest test)
```
    Get an enumeration of the children of this node
    
    Parameters:
    test - A NodeTest to be satisfied by the child nodes, or null if all child node are to be returned
    
    Returns:
    an iterator over the children of this node
  - getFirstChild
```
public final NodeImpl getFirstChild()
```
    Get the first child node of the element
    
    Specified by:
    
    getFirstChild in interface SteppingNode<NodeImpl>
    
    Overrides:
    
    getFirstChild in class NodeImpl
    
    Returns:
    the first child node of the required type, or null if there are no children
  - getLastChild
```
public final NodeImpl getLastChild()
```
    Get the last child node of the element
    
    Overrides:
    
    getLastChild in class NodeImpl
    
    Returns:
    the last child of the element, or null if there are no children
  - getNthChild
```
protected final NodeImpl getNthChild(int n)
```
    Get the nth child node of the element (numbering from 0)
    
    Parameters:
    n - identifies the required child
    
    Returns:
    the last child of the element, or null if there is no n'th child
  - removeChild
```
protected void removeChild(NodeImpl child)
```
    Remove a given child
    
    Parameters:
    child - the child to be removed
  - getStringValue
```
public String getStringValue()
```
    Return the string-value of the node, that is, the concatenation of the character content of all descendent elements and text nodes.
    
    Returns:
    the accumulated character content of the element, including descendant elements.
    See Also:
    Item.getStringValueCS()
  - getStringValueCS
```
public CharSequence getStringValueCS()
```
    Description copied from class: NodeImpl
    
    Get the value of the item as a CharSequence. This is in some cases more efficient than the version of the method that returns a String.
    
    Specified by:
    
    getStringValueCS in interface Item
    
    Overrides:
    
    getStringValueCS in class NodeImpl
    
    Returns:
    the string value of the item
    See Also:
    Item.getStringValue()
  - addChild
```
protected void addChild(NodeImpl node,
            int index)
```
    Add a child node to this node. For system use only. Note: normalizing adjacent text nodes is the responsibility of the caller.
    
    Parameters:
    node - the node to be added as a child of this node. This must be an instance of NodeImpl. It will be modified as a result of this call (by setting its parent property and sibling position)
    index - the position where the child is to be added
  - insertChildren
```
public void insertChildren(NodeInfo[] source,
                  boolean atStart,
                  boolean inherit)
```
    Insert a sequence of nodes as children of this node.
    
    This method takes no action unless the target node is a document node or element node. It also takes no action in respect of any supplied nodes that are not elements, text nodes, comments, or processing instructions.
    
    The supplied nodes will form the new children. Adjacent text nodes will be merged, and zero-length text nodes removed. The supplied nodes may be modified in situ, for example to change their parent property and to add namespace bindings, or they may be copied, at the discretion of the implementation.
    
    Specified by:
    
    insertChildren in interface MutableNodeInfo
    
    Overrides:
    
    insertChildren in class NodeImpl
    
    Parameters:
    source - the nodes to be inserted. The implementation determines what implementation classes of node it will accept; this implementation will accept text, comment, and processing instruction nodes belonging to any implementation, but elements must be instances of ElementImpl. The supplied nodes will be modified in situ, for example to change their parent property and to add namespace bindings, if they are instances of ElementImpl; otherwise they will be copied. If the nodes are copied, then on return the supplied source array will contain the copy rather than the original.
    atStart - true if the new nodes are to be inserted before existing children; false if they are to be inserted after existing children
    inherit - true if the inserted nodes are to inherit the namespaces of their new parent; false if such namespaces are to be undeclared
    
    Throws:
    
    IllegalArgumentException - if the supplied nodes use a node implementation that this implementation does not accept.
  - insertChildrenAt
```
protected void insertChildrenAt(NodeInfo[] source,
                    int index,
                    boolean inherit)
```
    Insert children before or after a given existing child
    
    Parameters:
    source - the children to be inserted. We allow any kind of text, comment, or processing instruction node, but element nodes must be instances of this NodeInfo implementation.
    index - the position before which they are to be inserted: 0 indicates insertion before the first child, 1 insertion before the second child, and so on.
    inherit - true if the inserted nodes are to inherit the namespaces that are in-scope for their new parent; false if such namespaces should be undeclared on the children
  - replaceChildrenAt
```
protected void replaceChildrenAt(NodeInfo[] source,
                     int index,
                     boolean inherit)
```
    Replace child at a given index by new children
    
    Parameters:
    source - the children to be inserted
    index - the position at which they are to be inserted: 0 indicates replacement of the first child, replacement of the second child, and so on. The effect is undefined if index is out of range
    inherit - set to true if the new child elements are to inherit the in-scope namespaces of their new parent
    
    Throws:
    
    IllegalArgumentException - if any of the replacement nodes is not an element, text, comment, or processing instruction node
  - compact
```
public void compact(int size)
```
    Compact the space used by this node
    
    Parameters:
    size - the number of actual children

Class StyleElement

Field Summary

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

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

Constructor Summary

Method Summary

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

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

Methods inherited from class java.lang.Object

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

Field Detail

extensionNamespaces

version

staticContext

validationError

reportingCircumstances

defaultXPathNamespace

defaultCollationName

defaultMode

expandText

REPORT_ALWAYS

REPORT_UNLESS_FORWARDS_COMPATIBLE

REPORT_IF_INSTANTIATED

REPORT_UNLESS_FALLBACK_AVAILABLE

actionsCompleted

ACTION_VALIDATE

ACTION_COMPILE

ACTION_TYPECHECK

ACTION_OPTIMIZE

ACTION_FIXUP

ACTION_PROCESS_ATTRIBUTES

YES_NO

Constructor Detail

StyleElement

Method Detail

getCompilation

setCompilation

getPackageData

getStaticContext

getStaticContext

makeExpressionVisitor

isSchemaAware

isExplaining

substituteFor

setValidationError

isInstruction

isDeclaration

getVisibility

getDeclaredVisibility

markTailCalls

mayContainSequenceConstructor

mayContainFallback

mayContainParam

getContainingStylesheet

getDefaultValidation

makeQName

addXSLOverrideFunctionLibrary

findAncestorElement

getUsedPackage

getXslOriginal

getOverriddenComponent

makeNamespaceContext

makeRetainedStaticContext

changesRetainedStaticContext

getNamespaceResolver

processAllAttributes

processStandardAttributes

getAttributeValue

processAttributes

checkUnknownAttribute

check30attribute

prepareAttributes

getLastChildInstruction

makeExpression

makePattern

makeAttributeValueTemplate

getLocation

checkAttributeValue

processBooleanAttribute

makeSequenceType