## net.sf.saxon.instruct
Class Executable

    java.lang.Object
      net.sf.saxon.instruct.Executable

All Implemented Interfaces:
  java.io.Serializable

    public class Executable

extends java.lang.Object
implements java.io.Serializable

A compiled stylesheet or a query in executable form. Note that the original stylesheet tree is not retained.

See Also:
  Serialized Form

Constructor Summary
`Executable(Configuration config)` Create a new Executable (a collection of stylesheet modules and/or query modules)

Method Summary
`void` `addQueryLibraryModule(QueryModule module)` Add an XQuery library module to the configuration.
`void` `addRequiredParam(StructuredQName qName)` Add a required parameter
`void` `checkAllRequiredParamsArePresent(GlobalParameterSet params)` Check that all required parameters have been supplied
`boolean` `createsSecondaryResult()` Ask whether this executable represents a stylesheet that uses xsl:result-document to create secondary output documents
`void` `explainGlobalVariables(ExpressionPresenter presenter)` Explain (that is, output an expression tree) the global variables
`void` `explainNamedTemplates(ExpressionPresenter presenter)` Explain the expression tree for named templates in a stylesheet
`void` `fixupQueryModules(QueryModule main)` Fix up global variables and functions in all query modules.
`java.util.HashMap` `getCharacterMapIndex()` Get the index of named character maps
`CollationMap` `getCollationTable()` Get the table of collations
`java.util.HashMap` `getCompiledGlobalVariables()` Get the index of global variables
`Configuration` `getConfiguration()` Get the configuration
`DecimalFormatManager` `getDecimalFormatManager()` Get the DecimalFormatManager which handles decimal-format definitions
`StringCollator` `getDefaultCollation()` Get the default collation
`java.lang.String` `getDefaultCollationName()` Get the name of the default collation
`java.util.Properties` `getDefaultOutputProperties()` Get the default output properties
`FunctionLibrary` `getFunctionLibrary()` Get the library containing all the in-scope functions in the static context
`SlotManager` `getGlobalVariableMap()` Get the global variable map
`int` `getHostLanguage()` Get the host language
`KeyManager` `getKeyManager()` Get the KeyManager which handles key definitions
`int` `getLargestPatternStackFrame()` Determine the size of the stack frame needed for evaluating match patterns
`LocationMap` `getLocationMap()` Get the location map
`StringCollator` `getNamedCollation(java.lang.String name)` Find a named collation.
`Template` `getNamedTemplate(StructuredQName qName)` Get the named template with a given name.
`java.util.Properties` `getOutputProperties(StructuredQName qName)` Get a named output format
`java.util.Iterator` `getQueryLibraryModules()` Get an iterator over all the query library modules (does not include the main module)
`java.util.List` `getQueryLibraryModules(java.lang.String namespace)` Locate the known XQuery library modules for a given module namespace.
`QueryModule` `getQueryModuleWithSystemId(java.lang.String systemId, QueryModule topModule)` Get the query library module with a given systemID
`java.lang.String` `getReasonUnableToCompile()` Determine whether this executable can be compiled; and if it can't, return the reason why
`RuleManager` `getRuleManager()` Get the RuleManager which handles template rules
`Mode` `getStripperRules()` Get the rules determining which nodes are to be stripped from the tree
`void` `initializeBindery(Bindery bindery)` Allocate space in bindery for all the variables needed
`java.util.Iterator` `iterateNamedTemplates()` Iterate over all the named templates defined in this Executable
`Stripper` `newStripper()` Create a Stripper which handles whitespace stripping definitions
`void` `putNamedTemplate(StructuredQName templateName, Template template)` Register the named template with a given name
`void` `registerGlobalVariable(GlobalVariable variable)` Register a global variable
`void` `setCharacterMapIndex(java.util.HashMap cmi)` Set the index of named character maps
`void` `setCollationTable(CollationMap table)` Set the table of collations
`void` `setConfiguration(Configuration config)` Set the configuration
`void` `setCreatesSecondaryResult(boolean flag)` Set whether this executable represents a stylesheet that uses xsl:result-document to create secondary output documents
`void` `setDecimalFormatManager(DecimalFormatManager dfm)` Set the DecimalFormatManager which handles decimal-format definitions
`void` `setDefaultCollationName(java.lang.String name)` Set the default collation
`void` `setDefaultOutputProperties(java.util.Properties properties)` Set the default output properties (the properties for the unnamed output format)
`void` `setFunctionLibrary(FunctionLibrary functionLibrary)` Set the library containing all the in-scope functions in the static context
`void` `setHostLanguage(int language)` Set the host language
`void` `setKeyManager(KeyManager km)` Set the KeyManager which handles key definitions
`void` `setLocationMap(LocationMap map)` Set the location map
`void` `setOutputProperties(StructuredQName qName, java.util.Properties properties)` Add a named output format
`void` `setPatternSlotSpace(int patternLocals)` Set the space requirements for variables used in template match patterns
`void` `setReasonUnableToCompile(java.lang.String reason)` If this Executable can't be compiled, set a message explaining why
`void` `setRuleManager(RuleManager rm)` Set the RuleManager that handles template rules
`void` `setStripperRules(Mode rules)` Set the rules determining which nodes are to be stripped from the tree
`void` `setStripsInputTypeAnnotations(boolean strips)` Set whether source documents are to have their type annotations stripped
`void` `setStripsWhitespace(boolean strips)` Indicate that the stylesheet does some whitespace stripping
`boolean` `stripsInputTypeAnnotations()` Ask whether source documents are to have their type annotations stripped
`boolean` `stripsWhitespace()` Determine whether this stylesheet does any whitespace stripping

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

Constructor Detail

### Executable

    public Executable(Configuration config)

  Create a new Executable (a collection of stylesheet modules and/or query modules)

  Parameters:
    `config` - the Saxon Configuration

Method Detail

### setConfiguration

    public void setConfiguration(Configuration config)

  Set the configuration

  Parameters:
    `config` - the Configuration

### getConfiguration

    public Configuration getConfiguration()

  Get the configuration

  Returns:
    the Configuration

### setHostLanguage

    public void setHostLanguage(int language)

  Set the host language

  Parameters:
    `language` - the host language, as a constant such as `Configuration.XSLT` or `Configuration.XQUERY`

### getHostLanguage

    public int getHostLanguage()

  Get the host language

  Returns:
    a value identifying the host language: `Configuration.XQUERY` or `Configuration.XSLT` or `Configuration.JAVA_APPLICATION`

### setRuleManager

    public void setRuleManager(RuleManager rm)

  Set the RuleManager that handles template rules

  Parameters:
    `rm` - the RuleManager containing details of all the template rules

### getRuleManager

    public RuleManager getRuleManager()

  Get the RuleManager which handles template rules

  Returns:
    the RuleManager registered with setRuleManager

### getNamedTemplate

    public Template getNamedTemplate(StructuredQName qName)

  Get the named template with a given name.

  Parameters:
    `qName` - The template name
  Returns:
    The template (of highest import precedence) with this name if there is one; null if none is found.

### putNamedTemplate

    public void putNamedTemplate(StructuredQName templateName,
                                 Template template)

  Register the named template with a given name

  Parameters:
    `templateName` - the name of a named XSLT template
    `template` - the template

### iterateNamedTemplates

    public java.util.Iterator iterateNamedTemplates()

  Iterate over all the named templates defined in this Executable

  Returns:
    an iterator, the items returned being of class `Template`

### getFunctionLibrary

    public FunctionLibrary getFunctionLibrary()

  Get the library containing all the in-scope functions in the static context

  Returns:
    the function libary

### setFunctionLibrary

    public void setFunctionLibrary(FunctionLibrary functionLibrary)

  Set the library containing all the in-scope functions in the static context

  Parameters:
    `functionLibrary` - the function libary

### setCharacterMapIndex

    public void setCharacterMapIndex(java.util.HashMap cmi)

  Set the index of named character maps

  Parameters:
    `cmi` - a hash table that maps the names of character maps to the HashMap objects representing the character maps

### getCharacterMapIndex

    public java.util.HashMap getCharacterMapIndex()

  Get the index of named character maps

  Returns:
    the hash table that maps the names of character maps to the HashMap objects representing the character maps

### setStripperRules

    public void setStripperRules(Mode rules)

  Set the rules determining which nodes are to be stripped from the tree

  Parameters:
    `rules` - a Mode object containing the whitespace stripping rules. A Mode is generally a collection of template rules, but it is reused here to represent a collection of stripping rules.

### getStripperRules

    public Mode getStripperRules()

  Get the rules determining which nodes are to be stripped from the tree

  Returns:
    a Mode object containing the whitespace stripping rules. A Mode is generally a collection of template rules, but it is reused here to represent a collection of stripping rules.

### setStripsWhitespace

    public void setStripsWhitespace(boolean strips)

  Indicate that the stylesheet does some whitespace stripping

  Parameters:
    `strips` - true if the stylesheet performs whitespace stripping of one or more elements.

### newStripper

    public Stripper newStripper()

  Create a Stripper which handles whitespace stripping definitions

  Returns:
    the constructed Stripper object

### stripsWhitespace

    public boolean stripsWhitespace()

  Determine whether this stylesheet does any whitespace stripping

  Returns:
    true if the stylesheet performs whitespace stripping of one or more elements.

### setStripsInputTypeAnnotations

    public void setStripsInputTypeAnnotations(boolean strips)

  Set whether source documents are to have their type annotations stripped

  Parameters:
    `strips` - true if type annotations are to be stripped

### stripsInputTypeAnnotations

    public boolean stripsInputTypeAnnotations()

  Ask whether source documents are to have their type annotations stripped

  Returns:
    true if type annotations are stripped from source documents

### setKeyManager

    public void setKeyManager(KeyManager km)

  Set the KeyManager which handles key definitions

  Parameters:
    `km` - the KeyManager containing the xsl:key definitions

### getKeyManager

    public KeyManager getKeyManager()

  Get the KeyManager which handles key definitions

  Returns:
    the KeyManager containing the xsl:key definitions

### setDefaultOutputProperties

    public void setDefaultOutputProperties(java.util.Properties properties)

  Set the default output properties (the properties for the unnamed output format)

  Parameters:
    `properties` - the output properties to be used when the unnamed output format is selected

### getDefaultOutputProperties

    public java.util.Properties getDefaultOutputProperties()

  Get the default output properties

  Returns:
    the properties for the unnamed output format

### setOutputProperties

    public void setOutputProperties(StructuredQName qName,
                                    java.util.Properties properties)

  Add a named output format

  Parameters:
    `qName` - the structured QName of the output format
    `properties` - the properties of the output format

### getOutputProperties

    public java.util.Properties getOutputProperties(StructuredQName qName)

  Get a named output format

  Parameters:
    `qName` - the name of the output format
  Returns:
    properties the properties of the output format. Return null if there are no output properties with the given name

### setDecimalFormatManager

    public void setDecimalFormatManager(DecimalFormatManager dfm)

  Set the DecimalFormatManager which handles decimal-format definitions

  Parameters:
    `dfm` - the DecimalFormatManager containing the named xsl:decimal-format definitions

### getDecimalFormatManager

    public DecimalFormatManager getDecimalFormatManager()

  Get the DecimalFormatManager which handles decimal-format definitions

  Returns:
    the DecimalFormatManager containing the named xsl:decimal-format definitions

### setDefaultCollationName

    public void setDefaultCollationName(java.lang.String name)

  Set the default collation

  Parameters:
    `name` - the name of the default collation

### getDefaultCollationName

    public java.lang.String getDefaultCollationName()

  Get the name of the default collation

  Returns:
    the name of the default collation; this is the code point collation URI if no other default has been set up.

### getDefaultCollation

    public StringCollator getDefaultCollation()

  Get the default collation

  Returns:
    a StringCollator that implements the default collation

### setCollationTable

    public void setCollationTable(CollationMap table)

  Set the table of collations

  Parameters:
    `table` - a hash table that maps collation names (URIs) to objects representing the collation information

### getCollationTable

    public CollationMap getCollationTable()

  Get the table of collations

  Returns:
    a hash table that maps collation names (URIs) to objects representing the collation information

### getNamedCollation

    public StringCollator getNamedCollation(java.lang.String name)

  Find a named collation.

  Parameters:
    `name` - identifies the name of the collation required; null indicates that the default collation is required
  Returns:
    the requested collation, or null if the collation is not found

### addQueryLibraryModule

    public void addQueryLibraryModule(QueryModule module)

  Add an XQuery library module to the configuration. The Executable maintains a table indicating for each module namespace, the set of modules that have been loaded from that namespace. If a module import is encountered that specifies no location hint, all the known modules for that namespace are imported.

  Parameters:
    `module` - the library module to be added to this executable

### getQueryLibraryModules

    public java.util.List getQueryLibraryModules(java.lang.String namespace)

  Locate the known XQuery library modules for a given module namespace.

  Parameters:
    `namespace` - the module namespace URI
  Returns:
    a list of items each of which is the StaticQueryContext representing a module, or null if the module namespace is unknown

### getQueryModuleWithSystemId

    public QueryModule getQueryModuleWithSystemId(java.lang.String systemId,
                                                  QueryModule topModule)

  Get the query library module with a given systemID

  Parameters:
    `systemId` - the SystemId of the required module
    `topModule` - the top-level query module (usually a main module, except when importing library modules into XSLT)
  Returns:
    the module with that system id if found, otherwise null

### getQueryLibraryModules

    public java.util.Iterator getQueryLibraryModules()

  Get an iterator over all the query library modules (does not include the main module)

  Returns:
    an iterator whose returned items are instances of `QueryModule`

### fixupQueryModules

    public void fixupQueryModules(QueryModule main)
                           throws XPathException

  Fix up global variables and functions in all query modules. This is done right at the end, because recursive imports are permitted

  Parameters:
    `main` - the main query module
  Throws:
    `XPathException`

### setPatternSlotSpace

    public void setPatternSlotSpace(int patternLocals)

  Set the space requirements for variables used in template match patterns

  Parameters:
    `patternLocals` - The largest number of local variables used in the match pattern of any template rule

### getGlobalVariableMap

    public SlotManager getGlobalVariableMap()

  Get the global variable map

  Returns:
    the SlotManager defining the allocation of slots to global variables

### getCompiledGlobalVariables

    public java.util.HashMap getCompiledGlobalVariables()

  Get the index of global variables

  Returns:
    the index of global variables. This is a HashMap in which the key is the `StructuredQName` of the variable name, and the value is the GlobalVariable object representing the compiled global variable. If there are no global variables, the method may return null.

### explainGlobalVariables

    public void explainGlobalVariables(ExpressionPresenter presenter)

  Explain (that is, output an expression tree) the global variables

  Parameters:
    `presenter` - the destination for the explanation of the global variables

### registerGlobalVariable

    public void registerGlobalVariable(GlobalVariable variable)

  Register a global variable

  Parameters:
    `variable` - the global variable to be registered

### initializeBindery

    public void initializeBindery(Bindery bindery)

  Allocate space in bindery for all the variables needed

  Parameters:
    `bindery` - The bindery to be initialized

### getLargestPatternStackFrame

    public int getLargestPatternStackFrame()

  Determine the size of the stack frame needed for evaluating match patterns

  Returns:
    the size of the largest stack frame needed for evaluating the match patterns that appear in XSLT template rules

### setLocationMap

    public void setLocationMap(LocationMap map)

  Set the location map

  Parameters:
    `map` - the location map, which is used to identify the module URI and line number of locations of errors

### getLocationMap

    public LocationMap getLocationMap()

  Get the location map

  Returns:
    the location map, which is used to identify the locations of errors

### addRequiredParam

    public void addRequiredParam(StructuredQName qName)

  Add a required parameter

  Parameters:
    `qName` - the name of the required parameter

### checkAllRequiredParamsArePresent

    public void checkAllRequiredParamsArePresent(GlobalParameterSet params)
                                          throws XPathException

  Check that all required parameters have been supplied

  Parameters:
    `params` - the set of parameters that have been supplied
  Throws:
    `XPathException` - if there is a required parameter for which no value has been supplied

### setReasonUnableToCompile

    public void setReasonUnableToCompile(java.lang.String reason)

  If this Executable can't be compiled, set a message explaining why

  Parameters:
    `reason` - a message explaining why compilation is not possible

### getReasonUnableToCompile

    public java.lang.String getReasonUnableToCompile()

  Determine whether this executable can be compiled; and if it can't, return the reason why

  Returns:
    null if the executable can be compiled, or a message otherwise

### explainNamedTemplates

    public void explainNamedTemplates(ExpressionPresenter presenter)

  Explain the expression tree for named templates in a stylesheet

  Parameters:
    `presenter` - destination for the explanatory output

### setCreatesSecondaryResult

    public void setCreatesSecondaryResult(boolean flag)

  Set whether this executable represents a stylesheet that uses xsl:result-document to create secondary output documents

  Parameters:
    `flag` - true if the executable uses xsl:result-document

### createsSecondaryResult

    public boolean createsSecondaryResult()

  Ask whether this executable represents a stylesheet that uses xsl:result-document to create secondary output documents

  Returns:
    true if the executable uses xsl:result-document

Copyright (c) Saxonica Limited. All rights reserved.