net.sf.saxon.expr.instruct

## Class Executable

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

- All Implemented Interfaces:
    Serializable
  Direct Known Subclasses:
    PreparedStylesheet

      public class Executable
      extends Object
      implements 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

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

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addQueryLibraryModule(QueryModule module)` Add an XQuery library module to the configuration.
    `void` | `addQueryLocationHintProcessed(String uri)` Add a name to the list of query module location hints that have been processed during the construction of this executable
    `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` | `fixupQueryModules(QueryModule main, boolean checkForCycles)` Fix up global variables and functions in all query modules.
    `CharacterMapIndex` | `getCharacterMapIndex()` Get the index of named character maps
    `CollationMap` | `getCollationTable()` Get the table of collations
    `HashMap<StructuredQName,GlobalVariable>` | `getCompiledGlobalVariables()` Get the index of global variables
    `Configuration` | `getConfiguration()` Get the configuration
    `Properties` | `getDefaultOutputProperties()` Get the default output properties
    `FunctionLibraryList` | `getFunctionLibrary()` Get the library containing all the in-scope functions in the static context
    `GlobalVariable` | `getGlobalVariable(StructuredQName name)` Get the global variable with a given name
    `SlotManager` | `getGlobalVariableMap()` Get the global variable map
    `int` | `getHostLanguage()` Get the host language
    `StructuredQName` | `getInitialContextItemVariableName()` Get the the name of the variable that will implicitly contain the value of the initial context item.
    `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(String name)` Find a named collation.
    `Properties` | `getOutputProperties(StructuredQName qName)` Get a named output format
    `Iterator` | `getQueryLibraryModules()` Get an iterator over all the query library modules (does not include the main module)
    `List<QueryModule>` | `getQueryLibraryModules(String namespace)` Locate the known XQuery library modules for a given module namespace.
    `QueryModule` | `getQueryModuleWithSystemId(String systemId, QueryModule topModule)` Get the query library module with a given systemID
    `SpaceStrippingRule` | `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
    `boolean` | `isAllowXPath30()` Ask whether XPath 3.0 functionality is enabled
    `boolean` | `isQueryLocationHintProcessed(String uri)` Ask whether a query module location hint has already been processed
    `boolean` | `isSchemaAware()` Ask whether this executable is schema-aware, that is, whether the query or transformation imports a schema.
    `void` | `registerGlobalVariable(GlobalVariable variable)` Register a global variable
    `void` | `setCharacterMapIndex(CharacterMapIndex cmi)` Set the index of named character maps
    `void` | `setCollationMap(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` | `setDefaultOutputProperties(Properties properties)` Set the default output properties (the properties for the unnamed output format)
    `void` | `setFunctionLibrary(FunctionLibraryList functionLibrary)` Set the library containing all the in-scope functions in the static context
    `void` | `setHostLanguage(int language, boolean allowXPath30)` Set the host language
    `void` | `setInitialContextItemVariableName(StructuredQName name)` Set the name of the variable that will implicitly contain the value of the initial context item.
    `void` | `setKeyManager(KeyManager km)` Set the KeyManager which handles key definitions
    `void` | `setLocationMap(LocationMap map)` Set the location map
    `void` | `setOutputProperties(StructuredQName qName, Properties properties)` Add a named output format
    `void` | `setPatternSlotSpace(int patternLocals)` Set the space requirements for variables used in template match patterns
    `void` | `setSchemaAware(boolean aware)` Set whether this executable is schema-aware.
    `void` | `setStripperRules(SpaceStrippingRule 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,
                             boolean allowXPath30)

      Set the host language
      Parameters:
        `language` - the host language, as a constant such as `Configuration.XSLT` or `Configuration.XQUERY`
        `allowXPath30` - true if functionality defined in XPath 3.0 (for example, new casting options) is enabled

    - #### getHostLanguage

          public int getHostLanguage()

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

    - #### isAllowXPath30

          public boolean isAllowXPath30()

      Ask whether XPath 3.0 functionality is enabled
      Returns:
        true of XPath 3.0 (and/or XSLT 3.0, XQuery 3.0) functionality can be used

    - #### getFunctionLibrary

          public FunctionLibraryList getFunctionLibrary()

      Get the library containing all the in-scope functions in the static context
      Returns:
        the function libary

    - #### setFunctionLibrary

          public void setFunctionLibrary(FunctionLibraryList functionLibrary)

      Set the library containing all the in-scope functions in the static context
      Parameters:
        `functionLibrary` - the function libary

    - #### setCharacterMapIndex

          public void setCharacterMapIndex(CharacterMapIndex 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 CharacterMapIndex getCharacterMapIndex()

      Get the index of named character maps
      Returns:
        the hash table that maps the names of character maps to the IntHashMap objects representing the character maps

    - #### setStripperRules

          public void setStripperRules(SpaceStrippingRule 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 SpaceStrippingRule getStripperRules()

      Get the rules determining which nodes are to be stripped from the tree
      Returns:
        a SpaceStrippingRule object containing the whitespace 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.

    - #### 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(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 Properties getDefaultOutputProperties()

      Get the default output properties
      Returns:
        the properties for the unnamed output format

    - #### setOutputProperties

          public void setOutputProperties(StructuredQName qName,
                                 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 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

    - #### setCollationMap

          public void setCollationMap(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(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 List<QueryModule> getQueryLibraryModules(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(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 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`

    - #### addQueryLocationHintProcessed

          public void addQueryLocationHintProcessed(String uri)

      Add a name to the list of query module location hints that have been processed during the construction of this executable
      Parameters:
        `uri` - the name to be added (the location URI as it appears in the "import module" declaration, expanded to an absolute URI by resolving against the base URI, but before passing to the Module Resolver)

    - #### isQueryLocationHintProcessed

          public boolean isQueryLocationHintProcessed(String uri)

      Ask whether a query module location hint has already been processed
      Parameters:
        `uri` - the query location hint (the location URI as it appears in the "import module" declaration, expanded to an absolute URI by resolving against the base URI, but before passing to the Module Resolver)
      Returns:
        true if the location hint has already been processed

    - #### fixupQueryModules

          public void fixupQueryModules(QueryModule main,
                               boolean checkForCycles)
                                 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
        `checkForCycles` - if a check for cyclicity among modules is to be performed. This is a check for cycles at the level of a module (error XQST0093)
      Throws:
        `XPathException` - if an error occurs

    - #### 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

    - #### getGlobalVariable

          public GlobalVariable getGlobalVariable(StructuredQName name)

      Get the global variable with a given name
      Parameters:
        `name` - the name of the required variable
      Returns:
        the GlobalVariable with this name, or null if not found

    - #### getGlobalVariableMap

          public SlotManager getGlobalVariableMap()

      Get the global variable map
      Returns:
        the SlotManager defining the allocation of slots to global variables

    - #### getCompiledGlobalVariables

          public HashMap<StructuredQName,GlobalVariable> 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. Used in XSLT only.
      Parameters:
        `qName` - the name of the required parameter

    - #### checkAllRequiredParamsArePresent

          public void checkAllRequiredParamsArePresent(GlobalParameterSet params)
                                                throws XPathException

      Check that all required parameters have been supplied. Used in XSLT only.
      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

    - #### 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

    - #### setInitialContextItemVariableName

          public void setInitialContextItemVariableName(StructuredQName name)

      Set the name of the variable that will implicitly contain the value of the initial context item. The properties of this variable, such as its required type and initial value, automatically apply to the initial context item
      Parameters:
        `name` - the name of the global variable that mirrors the initial context item; or null if there is no such variable

    - #### getInitialContextItemVariableName

          public StructuredQName getInitialContextItemVariableName()

      Get the the name of the variable that will implicitly contain the value of the initial context item. The properties of this variable, such as its required type and initial value, automatically apply to the initial context item
      Returns:
        the name of the global variable that mirrors the initial context item

    - #### setSchemaAware

          public void setSchemaAware(boolean aware)

      Set whether this executable is schema-aware. The initial value is false; it is set to true at compile time if the query or transformation imports a schema. If the value is false, then all documents used at run-time must be untyped
      Parameters:
        `aware` - true if the executable is schema-aware
      Throws:
        `IllegalArgumentException` - if schema-aware processing is requested in a Configuration that is not schema-aware

    - #### isSchemaAware

          public boolean isSchemaAware()

      Ask whether this executable is schema-aware, that is, whether the query or transformation imports a schema.
      Returns:
        true if the executable is schema-aware, false if not.

Copyright (c) 2004-2013 Saxonica Limited. All rights reserved.