Class Feature<T>


  • public class Feature<T>
    extends java.lang.Object
    Feature defines a set of constants, representing the details of Saxon configuration options which can be supplied to the Saxon method Configuration.setProperty(), and to other interfaces
    • Field Summary

      Fields 
      Modifier and Type Field Description
      static Feature<java.lang.Boolean> ALLOW_EXTERNAL_FUNCTIONS
      ALLOW_EXTERNAL_FUNCTIONS has rather wider effect than the name might suggest.
      static Feature<java.lang.Boolean> ALLOW_MULTITHREADING
      ALLOW_MULTITHREADING determines whether multi-threading is allowed.
      static Feature<java.lang.Boolean> ALLOW_OLD_JAVA_URI_FORMAT
      ALLOW_OLD_JAVA_URI_FORMAT determines whether extension function calls to dynamically-loaded Java extension functions may use the URI format supported in older Saxon releases.
      static Feature<java.lang.Boolean> ALLOW_SYNTAX_EXTENSIONS
      This flag must be set to enable use of extensions to XPath, XQuery and XSLT syntax that go beyond what is allowed by the extensibility mechanisms in the spec.
      static Feature<java.lang.Boolean> ALLOW_UNRESOLVED_SCHEMA_COMPONENTS
      The W3C XSD specification (both 1.0 and 1.1) states that an unresolved reference to an absent schema component does not automatically make the schema invalid; the schema should be usable for validation provided that the missing components are not actually needed in a particular validation episode.
      static Feature<java.lang.Object> ALLOWED_PROTOCOLS
      The value is a comma-separated list of permitted protocols.
      static Feature<java.lang.Boolean> ASSERTIONS_CAN_SEE_COMMENTS
      ASSERTIONS_CAN_SEE_COMMENTS determines whether comment and processing instructions in a document being validated are visible to assertions in an XSD 1.1 schema.
      int code  
      static Feature<CollationURIResolver> COLLATION_URI_RESOLVER
      The supplied CollationURIResolver is used to process any collation URIs found in the query or stylesheet, returning an object of class StringCollator that implements the requested collation.
      static Feature<java.lang.String> COLLATION_URI_RESOLVER_CLASS
      The supplied class is instantiated and the resulting instance is used as the value of the COLLATION_URI_RESOLVER property.
      static Feature<CollectionFinder> COLLECTION_FINDER
      The supplied CollectionFinder is used to retrieve a ResourceCollection object given by any URI defined in calls to the collection() or the uri-collection() function.
      static Feature<java.lang.String> COLLECTION_FINDER_CLASS
      The supplied class is instantiated and the resulting instance is used as the value of the COLLECTION_FINDER property.
      static Feature<java.lang.Boolean> COMPILE_WITH_TRACING
      If run-time tracing of stylesheet or query execution is required, then the code must be compiled with tracing enabled.
      static Feature<Configuration> CONFIGURATION
      This attribute cannot be set on the Configuration itself, but it can be set on various JAXP factory objects such as a TransformerFactory or DocumentBuilderFactory, to ensure that several such factories use the same Configuration.
      static Feature<java.lang.String> CONFIGURATION_FILE
      Defines a configuration file to be applied to the configuration.
      static Feature<java.lang.Boolean> DEBUG_BYTE_CODE
      Obsolete and ignored from Saxon 12.0.
      static Feature<java.lang.String> DEBUG_BYTE_CODE_DIR
      Obsolete and ignored from Saxon 12.0.
      static Feature<java.lang.String> DEFAULT_COLLATION
      This option determines the collation that is used for comparing strings when no explicit collation is requested.
      static Feature<java.lang.String> DEFAULT_COLLECTION
      This determines the collection that is used when the fn:collection() function is called with no arguments; the effect is the same as if it were called passing the URI that is the value of this configuration property.
      static Feature<java.lang.String> DEFAULT_COUNTRY
      This determines the country that is used by format-date() and similar functions if no country code is supplied explicitly.
      static Feature<java.lang.String> DEFAULT_LANGUAGE
      This option determines the language that is used by format-date(), xsl:number and similar constructs if no language code is supplied explicitly.
      static Feature<java.lang.String> DEFAULT_REGEX_ENGINE
      Determines which regular expression engine should be used for evaluating regular expressions occuring in constructs such as fn:matches(), fn:replace, and xsl:analyze-string, and also in the pattern facet of a schema.
      static Feature<java.lang.Boolean> DISABLE_XSL_EVALUATE
      This option disables the xsl:evaluate instruction.
      static Feature<java.lang.Boolean> DISPLAY_BYTE_CODE
      Obsolete and ignored from Saxon 12.0.
      static Feature<java.lang.Boolean> DTD_VALIDATION
      If true, the XML parser is requested to perform validation of source documents against their DTD.
      static Feature<java.lang.Boolean> DTD_VALIDATION_RECOVERABLE
      This option determines whether DTD validation failures should be treated as recoverable.
      static Feature<java.lang.Boolean> EAGER_EVALUATION
      Forces Saxon to do eager evaluation of expressions in contexts where normally it would do lazy evaluation, for example when evaluating variables and function results.
      static Feature<java.lang.String> ENTITY_RESOLVER_CLASS
      The supplied class is instantiated and the resulting EntityResolver is used whenever Saxon itself creates an XMLReader for parsing source documents.
      static Feature<EnvironmentVariableResolver> ENVIRONMENT_VARIABLE_RESOLVER
      Setting the ENVIRONMENT_VARIABLE_RESOLVER causes the supplied object to be registered as the environment variable resolver for the Configuration.
      static Feature<java.lang.String> ENVIRONMENT_VARIABLE_RESOLVER_CLASS
      Setting ENVIRONMENT_VARIABLE_RESOLVER_CLASS causes an instance of the supplied class to be created, and registered as the environment variable resolver for the Configuration.
      static Feature<java.lang.String> ERROR_LISTENER_CLASS
      ERROR_LISTENER_CLASS is the name of the class used to implement the JAXP ErrorListener.
      static Feature<java.lang.Boolean> EXPAND_ATTRIBUTE_DEFAULTS
      EXPAND_ATTRIBUTE_DEFAULTS determines whether fixed and default values defined in a schema or DTD will be expanded (both on input and on output documents, if validation is requested).
      static Feature<java.lang.Boolean> EXPATH_FILE_DELETE_TEMPORARY_FILES
      EXPATH_FILE_DELETE_TEMPORARY_FILES determines whether temporary files and directories created in the EXPath File module should be automatically deleted on closure of the JVM.
      static Feature<java.lang.Boolean> GENERATE_BYTE_CODE
      Obsolete and ignored from Saxon 12.0.
      static Feature<java.lang.Boolean> IGNORE_SAX_SOURCE_PARSER
      If this option is set to true, then when a SAXSource is supplied as the input to an XSLT transformation, Saxon will ignore the XMLReader supplied in the SAXSource (in fact, it will modify the supplied SAXSource setting the XMLReader to null) and use an XMLReader created using the value of the SOURCE_PARSER_CLASS option in preference.
      static Feature<java.lang.Boolean> IMPLICIT_SCHEMA_IMPORTS
      IMPLICIT_SCHEMA_IMPORTS allows reference to schema components without an xs:import for the relevant namespace being present in the containing schema document.
      static Feature<java.lang.Boolean> LAZY_CONSTRUCTION_MODE
      Obsolete and ignored from Saxon 9.8.
      static Feature<java.lang.String> LICENSE_FILE_LOCATION
      LICENSE_FILE_LOCATION holds the filename in which the Saxon license file is held.
      static Feature<java.lang.Boolean> LINE_NUMBERING
      Default is false.
      static Feature<java.lang.Boolean> MARK_DEFAULTED_ATTRIBUTES
      Setting the MARK_DEFAULTED_ATTRIBUTES option causes Saxon to retain details of attributes that were notified by the XML parser as being defaulted (that is, the attribute was not present in the instance document but was defined by a default value in a DTD or schema).
      static Feature<java.lang.Integer> MAX_COMPILED_CLASSES
      Obsolete and ignored from Saxon 12.0.
      static Feature<java.lang.Object> MESSAGE_EMITTER_CLASS
      From Saxon 11.1, this option has no effect.
      static Feature<ModuleURIResolver> MODULE_URI_RESOLVER
      Affects XQuery only.
      static Feature<java.lang.String> MODULE_URI_RESOLVER_CLASS
      Affects XQuery only.
      static Feature<java.lang.Boolean> MONITOR_HOT_SPOT_BYTE_CODE
      Obsolete and ignored from Saxon 12.0.
      static Feature<java.lang.Boolean> MULTIPLE_SCHEMA_IMPORTS
      Affects schema construction (whether for standalone validation, or in the context of XSLT or XQuery).
      java.lang.String name  
      static Feature<NamePool> NAME_POOL
      Indicates that the supplied NamePool should be used as the target (run-time) NamePool by all stylesheets compiled (using newTemplates()) after this call on setAttribute.
      static Feature<java.lang.Object> OCCURRENCE_LIMITS
      OCCURRENCE_LIMITS determines the largest values of minOccurs and maxOccurs that can be accommodated when compiling an "expanded" finite state machine to represent an XSD content model grammar.
      static Feature<java.lang.Object> OPTIMIZATION_LEVEL
      Allows individual optimizations to be enabled or disabled selectively.
      static Feature<OutputURIResolver> OUTPUT_URI_RESOLVER
      The supplied OutputURIResolver will be used to resolve URIs of secondary result documents selected in the href attribute of the XSLT xsl:result-document instruction.
      static Feature<java.lang.String> OUTPUT_URI_RESOLVER_CLASS
      The supplied class will be instantiated, and the resulting OutputURIResolver will be used to resolve URIs of secondary result documents selected in the href attribute of the XSLT xsl:result-document instruction.
      static Feature<java.lang.Boolean> PRE_EVALUATE_DOC_FUNCTION
      If true, calls on the doc() and document() functions, if their arguments are known at compile time, will be evaluated at compile time, and the resulting document will be stored as part of the Saxon Configuration and shared by all queries and transformations running within that Configuration.
      static Feature<java.lang.Boolean> RECOGNIZE_URI_QUERY_PARAMETERS
      True if the doc() or document() are to recognize query parameters included in the URI (for example, ?validation=strict).
      static Feature<java.lang.Integer> RECOVERY_POLICY
      At one time this property controlled how recoverable errors were handled (fatal error, warning, or ignored).
      static Feature<java.lang.String> RECOVERY_POLICY_NAME
      At one time this property controlled how recoverable errors were handled (fatal error, warning, or ignored).
      static Feature<java.lang.Integer> REGEX_BACKTRACKING_LIMIT
      This property sets a limit on the amount of backtracking performed during regular expression evaluation.
      static Feature<java.lang.Object> RESOURCE_RESOLVER
      The supplied implementation of ResourceResolver is used to resolve URIs.
      static Feature<java.lang.String> RESOURCE_RESOLVER_CLASS
      The supplied class is instantiated and the resulting instance is used as the value of the RESOURCE_RESOLVER property.
      static Feature<java.lang.Integer> RESULT_DOCUMENT_THREADS
      Indicates the maximum number of threads to be used for processing xsl:result-document instructions in parallel.
      static Feature<java.lang.Boolean> RETAIN_DTD_ATTRIBUTE_TYPES
      If set to true, indicates that when input is obtained from a SAX parser, the DTD-based attribute type notified by the XML parser should be used to set the type annotation of the resulting node: for example a DTD type of NMTOKENS results in a type annotation of xs:NMTOKENS.
      static Feature<java.lang.Boolean> RETAIN_NODE_FOR_DIAGNOSTICS
      By default, Saxon attempts to ensure that the run-time code contains no links to the original source stylesheet tree.
      static Feature<SchemaURIResolver> SCHEMA_URI_RESOLVER
      The supplied SchemaURIResolver will be used to resolve URIs of schema documents referenced in xsl:import-schema declarations in XSLT, import schema in XQuery, references from one schema document to another using xs:include or xs:import, and references from an instance document to a schema using xsi:schemaLocation.
      static Feature<java.lang.String> SCHEMA_URI_RESOLVER_CLASS
      The name of a class that implements the interface SchemaURIResolver; this class will be instantiated and the resulting instance will be used as the value of the SCHEMA_URI_RESOLVER property.
      static Feature<java.lang.Integer> SCHEMA_VALIDATION
      Indicates whether and how schema validation should be applied to source documents.
      static Feature<java.lang.String> SCHEMA_VALIDATION_MODE
      Indicates whether and how schema validation should be applied to source documents.
      static Feature<java.lang.String> SERIALIZER_FACTORY_CLASS
      The class will be instantiated and the resulting SerializerFactory will be used to create the serialization pipeline for XSLT and XQuery results.
      static Feature<java.lang.String> SOURCE_PARSER_CLASS
      XML parser used for source documents.
      static Feature<java.lang.String> SOURCE_RESOLVER_CLASS
      On interfaces that allow an org.xml.sax.Source to be supplied, if a kind of Source is provided that Saxon does not recognize, it will be passed to the user-supplied SourceResolver, which has the opportunity to convert it to a kind of Source that Saxon does recognize.
      static Feature<java.lang.Boolean> STABLE_COLLECTION_URI
      STABLE_COLLECTION_URI, if set, indicates that collections returned by the fn:collection() and fn:uri-collection() functions should be stable, that is, repeated calls on these functions with the same collection URI (within the scope of a single query or transformation) should return identical results.
      static Feature<java.lang.Boolean> STABLE_UNPARSED_TEXT
      STABLE_UNPARSED_TEXT, if set, indicates that the results returned by repeated calls of unparsed-text(), unparsed-text-lines(), and unparsed-text-available() are consistent: calling these functions twice during the evaluation of a stylesheet or query will return the same results.
      static Feature<java.lang.String> STANDARD_ERROR_OUTPUT_FILE
      STANDARD_ERROR_OUTPUT_FILE is the name of a file to which Saxon will redirect output that would otherwise go to the operating system standard error stream (System.err).
      static Feature<java.lang.String> STREAMABILITY
      The STREAMABILITY option can be used to disable streaming.
      static Feature<java.lang.Boolean> STREAMING_FALLBACK
      If the STREAMING_FALLBACK option is set, then constructs for which streaming is requested (such as templates in a streaming mode, the xsl:source-document instruction with attribute streamable="yes", and streamable accumulators) will be executed in non-streaming mode if the code is not actually streamable.
      static Feature<java.lang.Boolean> STRICT_STREAMABILITY
      Causes the XSLT processor to verify that constructs that are declared streamable are in fact "guaranteed streamable" according to the W3C rules.
      static Feature<java.lang.String> STRIP_WHITESPACE
      Indicates whether all whitespace, no whitespace, or whitespace in elements defined in a DTD or schema as having element-only content should be stripped from source documents.
      static Feature<java.lang.String> STYLE_PARSER_CLASS
      XML parser used for stylesheets and schema documents.
      static Feature<java.lang.Boolean> SUPPRESS_EVALUATION_EXPIRY_WARNING
      This is set to true to suppress the warning otherwise issued by command-line interfaces indicating that an evaluation license is in use and is due to expire in a set number of days.
      static Feature<java.lang.Boolean> SUPPRESS_XPATH_WARNINGS
      Suppresses all warnings issued by the XPath and XQuery parsers.
      static Feature<java.lang.Boolean> SUPPRESS_XSLT_NAMESPACE_CHECK
      This is set to true to suppress the warning when there is no commonality between the namespaces used in stylesheet match patterns and the namespaces used in the source document.
      static Feature<java.lang.Integer> THRESHOLD_FOR_COMPILING_TYPES
      Obsolete and ignored from Saxon 12.0.
      static Feature<java.lang.Integer> THRESHOLD_FOR_FUNCTION_INLINING
      Saxon-EE performs inlining of user-defined functions that are sufficiently simple: they must not be recursive, and they must be below a certain size.
      static Feature<java.lang.Integer> THRESHOLD_FOR_HOTSPOT_BYTE_CODE
      Obsolete and ignored from Saxon 12.0.
      static Feature<java.lang.Boolean> TIMING
      This is set to true to cause basic timing and tracing information to be output to the standard error output stream.
      static Feature<java.lang.Boolean> TRACE_EXTERNAL_FUNCTIONS
      If this option is set, Saxon will output (to the standard error output) progress information about its attempts to locate and disambiguate references to reflexive Java extension functions.
      static Feature<TraceListener> TRACE_LISTENER
      The TraceListener will be notified of significant events occurring during a query or transformation, for tracing or debugging purposes.
      static Feature<java.lang.String> TRACE_LISTENER_CLASS
      The class will be instantiated once for each query or transformation, and the resulting TraceListener will be notified of significant events occurring during that query or transformation, for tracing or debugging purposes.
      static Feature<java.lang.String> TRACE_LISTENER_OUTPUT_FILE
      When trace listening is switched on (for example by using -T on the command line), this file will be supplied to the trace listener to use as the output destination.
      static Feature<java.lang.Boolean> TRACE_OPTIMIZER_DECISIONS
      If this option is set, Saxon will output (to the standard error output) detailed information about the rewrites to the expression tree made by the optimizer.
      static Feature<java.lang.Integer> TREE_MODEL
      Selects an implementation of the Saxon tree model.
      static Feature<java.lang.String> TREE_MODEL_NAME
      Selects an implementation of the Saxon tree model.
      static Feature<UnparsedTextURIResolver> UNPARSED_TEXT_URI_RESOLVER
      The supplied UnparsedTextURIResolver will be used to resolve (dereference) all URIs specifed in calls to the unparsed-text(), unparsed-text-lines(), and unparsed-text-available() functions.
      static Feature<java.lang.String> UNPARSED_TEXT_URI_RESOLVER_CLASS
      An instance of the specified UnparsedTextURIResolver class will be created, and used to resolve (dereference) all URIs specifed in calls to the unparsed-text(), unparsed-text-lines(), and unparsed-text-available() functions.
      static Feature<java.lang.String> URI_RESOLVER_CLASS
      An instance of the specified URIResolver class will be created, and used to resolve (dereference) all URIs specifed in calls to the doc() and document() functions, as well as URIs used in xsl:include and xsl:import and location hints for XQuery modules and XSD schema documents.
      static Feature<java.lang.Boolean> USE_PI_DISABLE_OUTPUT_ESCAPING
      This option determines whether a TransformerHandler created with this TransformerFactory or Configuration recognizes the JAXP-defined processing instructions Result.PI_DISABLE_OUTPUT_ESCAPING and Result.PI_ENABLE_OUTPUT_ESCAPING in the input stream as instructions to disable or to re-enable output escaping.
      static Feature<java.lang.Boolean> USE_TYPED_VALUE_CACHE
      This option is relevant only when the TinyTree is used; it determines whether (for a validated document) a cache will be maintained containing the typed values of nodes.
      static Feature<java.lang.Boolean> USE_XSI_SCHEMA_LOCATION
      This option determines whether or not to use the xsi:schemaLocation and xsi:noNamespaceSchemaLocation attributes in an instance document to locate a schema for validation.
      static Feature<java.lang.Boolean> VALIDATION_COMMENTS
      This option determines whether non-fatal validation errors in XQuery or XSLT result documents should result in comments being inserted into the result tree.
      static Feature<java.lang.Boolean> VALIDATION_WARNINGS
      This option indicates (if true) that errors occuring while validating a final result tree are not to be treated as fatal.
      static Feature<java.lang.Boolean> VERSION_WARNING
      Indicates whether a warning message should be notified (to the ErrorListener) if running Saxon against an XSLT stylesheet that specifies version="1.0".
      static Feature<java.lang.Boolean> XINCLUDE
      Indicates whether XML documents should have any XInclude directives expanded.
      static Feature<java.lang.Boolean> XML_PARSER_FEATURE
      Sets the value of a parser feature flag.
      static Feature<java.lang.Boolean> XML_PARSER_PROPERTY
      Sets the value of a parser property flag.
      static Feature<java.lang.String> XML_VERSION
      This determines the XML version used by the Configuration.
      static Feature<java.lang.Integer> XPATH_VERSION_FOR_XSD
      The XSD 1.1 specification states that XPath version 2.0 is used for expressions appearing in assertions and type alternatives.
      static Feature<java.lang.Integer> XPATH_VERSION_FOR_XSLT
      The XSLT 3.0 specification states that processors are required to support XPath 3.0 expressions within stylesheets, together with some extensions (maps) selected from the XPath 3.1 specification.
      static Feature<java.lang.Boolean> XQUERY_ALLOW_UPDATE
      Determines whether XQuery Update syntax is accepted.
      static Feature<java.lang.String> XQUERY_CONSTRUCTION_MODE
      This option defines the default value of the construction mode in the XQuery static context (overridable in the query prolog).
      static Feature<java.lang.Object> XQUERY_DEFAULT_ELEMENT_NAMESPACE
      This property defines the default namespace for elements and types that are not qualified by a namespace prefix.
      static Feature<java.lang.Object> XQUERY_DEFAULT_FUNCTION_NAMESPACE
      This property defines the default namespace for function names that are not qualified by a namespace prefix.
      static Feature<java.lang.Boolean> XQUERY_EMPTY_LEAST
      This property defines how the empty sequence is handled in XQuery sorting (the "order by" clause).
      static Feature<java.lang.Boolean> XQUERY_INHERIT_NAMESPACES
      This property defines the default value of the inherit-namespaces property in the XQuery static context.
      static Feature<java.lang.Boolean> XQUERY_MULTIPLE_MODULE_IMPORTS
      If the value is false, then when an import module declaration is encountered for a module URI that is already among the known loaded modules (or modules in the process of being compiled), the import module is treated as a reference to the existing module.
      static Feature<java.lang.Boolean> XQUERY_PRESERVE_BOUNDARY_SPACE
      This property defines whether "boundary space" (insignificant space in direct element constructors) should be retained or not.
      static Feature<java.lang.Boolean> XQUERY_PRESERVE_NAMESPACES
      This property defines whether unused namespace declarations are retained by XQuery element copy operations.
      static Feature<java.lang.String> XQUERY_REQUIRED_CONTEXT_ITEM_TYPE
      This property defines the default expected context item type for a query.
      static Feature<java.lang.Boolean> XQUERY_SCHEMA_AWARE
      A query will automatically be schema-aware if it contains an import schema declaration.
      static Feature<java.lang.String> XQUERY_STATIC_ERROR_LISTENER_CLASS
      The specified class is instantiated to create an ErrorListener, and all reports of static errors in a query will go to this ErrorListener.
      static Feature<java.lang.String> XQUERY_VERSION
      This property determines the version of XQuery used by the Configuration.
      static Feature<java.lang.String> XSD_VERSION
      This property determines the version of XML Schema used by the Configuration.
      static Feature<java.lang.Boolean> XSLT_ENABLE_ASSERTIONS
      This property indicates whether assertions (XSLT 3.0 xsl:assert instructions) are enabled or disabled.
      static Feature<java.lang.String> XSLT_INITIAL_MODE
      This property indicates the name of a mode within a stylesheet in which execution (using template rules) should begin.
      static Feature<java.lang.String> XSLT_INITIAL_TEMPLATE
      This property indicates the name of a named template within a stylesheet where execution should begin.
      static Feature<java.lang.Boolean> XSLT_SCHEMA_AWARE
      This property indicates whether stylesheets should be compiled with the ability to handle schema-typed input documents.
      static Feature<java.lang.String> XSLT_STATIC_ERROR_LISTENER_CLASS
      The specified class is instantiated to create an ErrorListener, and all reports of static errors in a stylesheet will go to this ErrorListener.
      static Feature<java.lang.String> XSLT_STATIC_URI_RESOLVER_CLASS
      This property defines a URIResolver used when dereferencing the URIs that appear in the href attributes of the xsl:include and xsl:import declarations.
      static Feature<java.lang.String> XSLT_VERSION
      This property determines the version of XSLT to be supported by default.
      static Feature<java.lang.String> ZIP_URI_PATTERN
      The value of this property is a regular expression used to decide whether a collection URI is to be treated as representing a ZIP file.
    • Method Summary

      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    • Field Detail

      • code

        public final int code
      • name

        public final java.lang.String name
      • ALLOW_EXTERNAL_FUNCTIONS

        public static final Feature<java.lang.Boolean> ALLOW_EXTERNAL_FUNCTIONS

        ALLOW_EXTERNAL_FUNCTIONS has rather wider effect than the name might suggest. It controls whether stylesheets are able to access external resources in the server environment.

        More specifically, if set to false it disallows all of the following:

        • With SaxonJ, calls to reflexive Java extension functions
        • Use of the XSLT system-property() function to access Java system properties
        • Use of the Saxon SQL extension library
        • Use of the EXPath File library
        • Use of a URI in the href attribute of an xsl:result-document instruction
        • Calls to XSLT extension instructions

        The default value is true. The setting false is recommended in an environment where untrusted stylesheets may be executed.

        This option does not disable use of the doc() function or similar functions to access the filestore of the machine where the transformation or query is running. That should be done using a user-supplied URIResolver.

        Note that integrated extension functions are trusted; calls to such functions are allowed even if this configuration option is false. In cases where an integrated extension function is used to load and execute untrusted code, it should check this configuration option before doing so.

        If the value of the property is false, then it will also be set to false on any new Configuration created using the fn:transform() function.

      • ALLOW_MULTITHREADING

        public static final Feature<java.lang.Boolean> ALLOW_MULTITHREADING

        ALLOW_MULTITHREADING determines whether multi-threading is allowed.

        If true (the default), the presence of the attribute saxon:threads="N" on an xsl:for-each instruction, when running under Saxon-EE, causes multi-threaded execution. If set to false, the value of the saxon:threads argument is ignored.

        Setting the value to false also disables asynchronous processing of xsl:result-document instructions.

        The default value is true if Saxon-EE is in use, false otherwise.

      • ALLOW_OLD_JAVA_URI_FORMAT

        public static final Feature<java.lang.Boolean> ALLOW_OLD_JAVA_URI_FORMAT

        ALLOW_OLD_JAVA_URI_FORMAT determines whether extension function calls to dynamically-loaded Java extension functions may use the URI format supported in older Saxon releases.

        If the value is false (the default), the only URI format accepted is (for example) "java:java.util.Date" - that is, a URI consisting of the string "java:" followed by the Java qualified class name of the class containing the implementation of the extension function.

        If the value is true, then in addition to this format, the following are accepted: (a) the Java class name on its own ("java.util.Date"), and (b) any URI in which the Java class name follows the last "/" character (for example "http://my.com/extensions/java.util.Date"). This last format was originally provided for compatibility with xt and xalan, but it causes problems because it leads to unnecessary attempts to load spurious classes when the user did not intend the URI to represent a dynamically-loaded Java class.

      • ALLOW_SYNTAX_EXTENSIONS

        public static final Feature<java.lang.Boolean> ALLOW_SYNTAX_EXTENSIONS

        This flag must be set to enable use of extensions to XPath, XQuery and XSLT syntax that go beyond what is allowed by the extensibility mechanisms in the spec. In some cases these extensions are experimental and may not be carried forward to future Saxon releases.

        Syntax extensions in Saxon 10 include the use of type aliases (type(...) where an item type is expected, and declare type NAME = item-type in the XQuery Prolog); and simple inline functions (for example .{. + 1}).

      • ASSERTIONS_CAN_SEE_COMMENTS

        public static final Feature<java.lang.Boolean> ASSERTIONS_CAN_SEE_COMMENTS

        ASSERTIONS_CAN_SEE_COMMENTS determines whether comment and processing instructions in a document being validated are visible to assertions in an XSD 1.1 schema.

        If the value is false (the default), comments and processing instructions are stripped from the view of the document that is made visible to the XPath expression that implements the assertion. If this creates adjacent text nodes, they are collapsed into a single text node.

        If the value is true, then comments and processing instructions are visible to the XPath assertion.

      • COLLATION_URI_RESOLVER

        public static final Feature<CollationURIResolver> COLLATION_URI_RESOLVER

        The supplied CollationURIResolver is used to process any collation URIs found in the query or stylesheet, returning an object of class StringCollator that implements the requested collation.

      • COLLATION_URI_RESOLVER_CLASS

        public static final Feature<java.lang.String> COLLATION_URI_RESOLVER_CLASS

        The supplied class is instantiated and the resulting instance is used as the value of the COLLATION_URI_RESOLVER property.

      • COLLECTION_FINDER

        public static final Feature<CollectionFinder> COLLECTION_FINDER

        The supplied CollectionFinder is used to retrieve a ResourceCollection object given by any URI defined in calls to the collection() or the uri-collection() function.

        If the argument is not specified then a default ResourceCollection should be handled. CollectionFinder returns a ResourceCollection which is used to map the URI of collection into a sequence of Resource objects (which are then resolved in the same way as URIs passed to the doc() function), or it may return an item (typically a node but can handle JSON documents).

      • COLLECTION_FINDER_CLASS

        public static final Feature<java.lang.String> COLLECTION_FINDER_CLASS

        The supplied class is instantiated and the resulting instance is used as the value of the COLLECTION_FINDER property.

      • COMPILE_WITH_TRACING

        public static final Feature<java.lang.Boolean> COMPILE_WITH_TRACING

        If run-time tracing of stylesheet or query execution is required, then the code must be compiled with tracing enabled.

        Default is false. This option causes code to be compiled that makes calls to a TraceListener, but this has no effect unless a TraceListener is registered at execution time.

      • CONFIGURATION

        public static final Feature<Configuration> CONFIGURATION

        This attribute cannot be set on the Configuration itself, but it can be set on various JAXP factory objects such as a TransformerFactory or DocumentBuilderFactory, to ensure that several such factories use the same Configuration.

        Note that other configuration options are held in the Configuration object, so setting this attribute will cancel all others that have been set. Also, if two factories share the same Configuration, then setting an attribute on one affects all the others.

      • CONFIGURATION_FILE

        public static final Feature<java.lang.String> CONFIGURATION_FILE

        Defines a configuration file to be applied to the configuration.

        This attribute cannot be set on the Configuration itself, but it can be set on various JAXP factory objects such as a TransformerFactory or DocumentBuilderFactory. It is particularly useful when running transformations via the Ant xslt task, where it can be set as follows to define all configuration settings:

        <factory name="net.sf.saxon.TransformerFactoryImpl"> <attribute name="http://saxon.sf.net/feature/configuration-file" value="c:/saxon/config.xml"/> </factory>

      • DEBUG_BYTE_CODE

        public static final Feature<java.lang.Boolean> DEBUG_BYTE_CODE

        Obsolete and ignored from Saxon 12.0.

      • DEBUG_BYTE_CODE_DIR

        public static final Feature<java.lang.String> DEBUG_BYTE_CODE_DIR

        Obsolete and ignored from Saxon 12.0.

      • DEFAULT_COLLATION

        public static final Feature<java.lang.String> DEFAULT_COLLATION

        This option determines the collation that is used for comparing strings when no explicit collation is requested. It is not necessary for this collation to exist (or to have been registered) when setting this option; it only needs to exist by the time it is used.

        In XSLT it is possible to override this setting using the [xsl:]default-collation attribute on any stylesheet element. In XQuery, it can be overridden using the declare default collation declaration in the query prolog, or via a setter method in class StaticQueryContext.

        If no value is specified, the Unicode codepoint collation is used.

      • DEFAULT_COLLECTION

        public static final Feature<java.lang.String> DEFAULT_COLLECTION

        This determines the collection that is used when the fn:collection() function is called with no arguments; the effect is the same as if it were called passing the URI that is the value of this configuration property.

      • DEFAULT_COUNTRY

        public static final Feature<java.lang.String> DEFAULT_COUNTRY

        This determines the country that is used by format-date() and similar functions if no country code is supplied explicitly. If no value is given for this property, the default is taken from the Java Locale, which in turn typically depends on settings for the current user in the operating system.

      • DEFAULT_LANGUAGE

        public static final Feature<java.lang.String> DEFAULT_LANGUAGE

        This option determines the language that is used by format-date(), xsl:number and similar constructs if no language code is supplied explicitly. If no value is given for this property, the default is taken from the Java Locale, which in turn typically depends on settings for the current user in the operating system.

      • DEFAULT_REGEX_ENGINE

        public static final Feature<java.lang.String> DEFAULT_REGEX_ENGINE

        Determines which regular expression engine should be used for evaluating regular expressions occuring in constructs such as fn:matches(), fn:replace, and xsl:analyze-string, and also in the pattern facet of a schema.

        On the Java platform the permitted values are "S" (default), and "J". The value "J" selects the regex engine provided in the JDK in preference to the Saxon regular expression engine. This means that regular expressions must follow the Java syntax and semantics rather than the XPath syntax and semantics.

        On the .NET platform the permitted values are "S" (default), "J", and "N". The value "J" selects the regex engine provided in the IKVMC run-time, which is derived from OpenJDK. The value "N" selects the regex engine provided in the Microsoft .NET platform. In each case, the regular expression must follow the syntax and semantics of the selected regex engine.

        The choice of regular expression may be overridden in a particular invocation by appending the value ";s", ";j", or ";n" to the flags argument of the relevant call. (This does not apply to XSD patterns, where no flags argument is available)

        Use of this feature is not conformant with W3C specifications. Use of the setting "N", however, can be useful when schemas have been written with the Microsoft schema processor in mind, since this uses the Microsoft regular expression dialect rather than the W3C dialect.

      • DISABLE_XSL_EVALUATE

        public static final Feature<java.lang.Boolean> DISABLE_XSL_EVALUATE

        This option disables the xsl:evaluate instruction.

        If set at stylesheet compile time, the feature is statically disabled. If set at run-time it is dynamically disabled. (These terms are defined in the XSLT 3.0 spec.) By default, the feature is enabled.

        The XSLT 3.0 specification requires conformant processors to provide a way of disabling xsl:evaluate. This shouldn't be taken as meaning that xsl:evaluate poses particular security risks. The main reason for disabling it is if you want to carry out static analysis or inspection of stylesheet code to see what features it uses. But if you're doing such inspection, it's not difficult to check that xsl:evaluate is only being used to execute trusted code. Note also that fn:transform() can similarly be used to execute dynamically-constructed code, and there is no switch to disable that function.

      • DISPLAY_BYTE_CODE

        public static final Feature<java.lang.Boolean> DISPLAY_BYTE_CODE

        Obsolete and ignored from Saxon 12.0.

      • DTD_VALIDATION

        public static final Feature<java.lang.Boolean> DTD_VALIDATION

        If true, the XML parser is requested to perform validation of source documents against their DTD. Default is false.

        This option establishes a default for use whenever source documents (not stylesheets or schema documents) are parsed. The option can be overridden for individual documents by setting the ParseOptions for that individual document, for example from a URIResolver.

      • DTD_VALIDATION_RECOVERABLE

        public static final Feature<java.lang.Boolean> DTD_VALIDATION_RECOVERABLE

        This option determines whether DTD validation failures should be treated as recoverable. If the option is set, a validation failure is reported as a warning rather than an error. The default is false.

        This option establishes a default for use whenever source documents (not stylesheets or schema documents) are parsed. The option can be overridden for individual documents by setting the ParseOptions for that individual document, for example from a URIResolver.

      • EAGER_EVALUATION

        public static final Feature<java.lang.Boolean> EAGER_EVALUATION

        Forces Saxon to do eager evaluation of expressions in contexts where normally it would do lazy evaluation, for example when evaluating variables and function results. This can make for easier debugging.

        Note that this only applies to situations where Saxon would normally save a Closure object as the result of an expression. It does not prevent Saxon from using pipelined evaluation of intermediate expressions using iterators.

      • ENTITY_RESOLVER_CLASS

        public static final Feature<java.lang.String> ENTITY_RESOLVER_CLASS

        The supplied class is instantiated and the resulting EntityResolver is used whenever Saxon itself creates an XMLReader for parsing source documents. It is not used with a user-supplied XMLReader.

        By default Saxon uses an EntityResolver that invokes the ResourceResolver registered with the Configuration. Unless overridden by a user-supplied ResourceResolver, this invokes the org.xml.resolver library, which attempts to look up the resource URI in a catalog. The default catalog recognizes the names of many standard W3C DTDs and external entity files, and resolves them against local copies issued with the resolver library, to avoid the need to fetch them from the web.

        The property can be set to a zero-length string, which resets the property to its default setting.

      • ENVIRONMENT_VARIABLE_RESOLVER

        public static final Feature<EnvironmentVariableResolver> ENVIRONMENT_VARIABLE_RESOLVER

        Setting the ENVIRONMENT_VARIABLE_RESOLVER causes the supplied object to be registered as the environment variable resolver for the Configuration. The setting is global: it affects all queries and transformations using this configuration.

        The environment variable resolver is used when the XPath functions available-environment-variables() or environment-variable() are called. Saxon essentially delegates the evaluation of the function to the external resolver.

      • ENVIRONMENT_VARIABLE_RESOLVER_CLASS

        public static final Feature<java.lang.String> ENVIRONMENT_VARIABLE_RESOLVER_CLASS

        Setting ENVIRONMENT_VARIABLE_RESOLVER_CLASS causes an instance of the supplied class to be created, and registered as the environment variable resolver for the Configuration. The setting is global: it affects all queries and transformations using this configuration.

        The environment variable resolver is used when the XPath functions available-environment-variables() or environment-variable() are called. Saxon essentially delegates the evaluation of the function to the external resolver.

      • ERROR_LISTENER_CLASS

        public static final Feature<java.lang.String> ERROR_LISTENER_CLASS

        ERROR_LISTENER_CLASS is the name of the class used to implement the JAXP ErrorListener. This is used both at compile time and at run-time.

        Currently if this option is specified, the class is instantiated, and the same instance is used for all processes running under this configuration. This may change in future so that a new instance is created for each compilation or evaluation.

        Finer control can be obtained by setting the ErrorListener for a specific XSLT or XQuery compilation or evaluation.

      • EXPAND_ATTRIBUTE_DEFAULTS

        public static final Feature<java.lang.Boolean> EXPAND_ATTRIBUTE_DEFAULTS

        EXPAND_ATTRIBUTE_DEFAULTS determines whether fixed and default values defined in a schema or DTD will be expanded (both on input and on output documents, if validation is requested).

        By default (and for conformance with the specification) validation against a DTD or schema will cause default values defined in the schema or DTD to be inserted into the document. Setting this feature to false suppresses this behavior. In the case of DTD-defined defaults this only works if the XML parser reports whether each attribute was specified in the source or generated by expanding a default value. Not all XML parsers report this information.

      • EXPATH_FILE_DELETE_TEMPORARY_FILES

        public static final Feature<java.lang.Boolean> EXPATH_FILE_DELETE_TEMPORARY_FILES

        EXPATH_FILE_DELETE_TEMPORARY_FILES determines whether temporary files and directories created in the EXPath File module should be automatically deleted on closure of the JVM.

        The default value is false, to align with the standard. The setting false is recommended when external 'sweep-up' features aren't available.

      • GENERATE_BYTE_CODE

        public static final Feature<java.lang.Boolean> GENERATE_BYTE_CODE

        Obsolete and ignored from Saxon 12.0.

      • IGNORE_SAX_SOURCE_PARSER

        public static final Feature<java.lang.Boolean> IGNORE_SAX_SOURCE_PARSER

        If this option is set to true, then when a SAXSource is supplied as the input to an XSLT transformation, Saxon will ignore the XMLReader supplied in the SAXSource (in fact, it will modify the supplied SAXSource setting the XMLReader to null) and use an XMLReader created using the value of the SOURCE_PARSER_CLASS option in preference.

        The defining use case for this feature is when calling a Saxon transformation from Ant. Ant always supplies the source document as a SAXSource using a parser instantiated using the default JAXP mechanism. A different parser set using the property http://saxon.sf.net/feature/sourceParserClass will normally be ignored in this case; setting the ignoreSAXSourceParser option overrides this. This is especially useful if the input format is not in fact XML, but some other format converted to a SAX event stream by means of a custom parser.

      • IMPLICIT_SCHEMA_IMPORTS

        public static final Feature<java.lang.Boolean> IMPLICIT_SCHEMA_IMPORTS

        IMPLICIT_SCHEMA_IMPORTS allows reference to schema components without an xs:import for the relevant namespace being present in the containing schema document.

        This only works if the referenced components are already present among the schema components known to the configuration, perhaps because they were part of a different schema, or because there are cyclic references within a schema.

        This option is not conformant with the XSD specification, which requires explicit xs:import declarations for all cross-namespace component references. However, some "industry-standard" schemas are known to violate this rule, and setting this option allows such schemas to be loaded by Saxon.

      • LAZY_CONSTRUCTION_MODE

        public static final Feature<java.lang.Boolean> LAZY_CONSTRUCTION_MODE

        Obsolete and ignored from Saxon 9.8.

      • LICENSE_FILE_LOCATION

        public static final Feature<java.lang.String> LICENSE_FILE_LOCATION

        LICENSE_FILE_LOCATION holds the filename in which the Saxon license file is held.

        This is the full file name, for example c:/saxon/license/license.lic. Setting this property causes Saxon to immediately read the specified file and register the license data, assuming it can be found at this location. The property is not recognized for reading, and it is not recognized for writing except in Saxon-PE and Saxon-EE.

      • LINE_NUMBERING

        public static final Feature<java.lang.Boolean> LINE_NUMBERING

        Default is false. If true, line and column number information is retained for all source documents. This information is accessible using the saxon:line-number() and saxon:column-number() extension functions.

        Note that the information is only as good as the XML parser supplies. SAX parsers generally report the position of an element node using the line and column number of the ">" character that forms the last character of the start tag.

        When this option is set, location information attached to a node (system ID, line number, and column number) is retained when the node is copied. This has the side effect that the base URI of a node is also copied, which in some cases runs contrary to the XSLT or XQuery specification.

      • MARK_DEFAULTED_ATTRIBUTES

        public static final Feature<java.lang.Boolean> MARK_DEFAULTED_ATTRIBUTES

        Setting the MARK_DEFAULTED_ATTRIBUTES option causes Saxon to retain details of attributes that were notified by the XML parser as being defaulted (that is, the attribute was not present in the instance document but was defined by a default value in a DTD or schema). This information is available to applications via the saxon:is-defaulted() extension function.

        Note: information about defaulted attributes is retained automatically where the attribute is processed using Saxon's schema processor; but in the case where the information comes from an external XML parser, it is retained only if this option is set.

      • MAX_COMPILED_CLASSES

        public static final Feature<java.lang.Integer> MAX_COMPILED_CLASSES

        Obsolete and ignored from Saxon 12.0.

      • MESSAGE_EMITTER_CLASS

        public static final Feature<java.lang.Object> MESSAGE_EMITTER_CLASS

        From Saxon 11.1, this option has no effect.

      • MODULE_URI_RESOLVER

        public static final Feature<ModuleURIResolver> MODULE_URI_RESOLVER

        Affects XQuery only. An instance of a user-written class implementing Saxon's ModuleURIResolver interface. This is used to process any URIs used in import module directives in XQuery.

      • MODULE_URI_RESOLVER_CLASS

        public static final Feature<java.lang.String> MODULE_URI_RESOLVER_CLASS

        Affects XQuery only. The name of a user-written class implementing Saxon's ModuleURIResolver interface. This is used to process any URIs used in import module directives in XQuery.

      • MONITOR_HOT_SPOT_BYTE_CODE

        public static final Feature<java.lang.Boolean> MONITOR_HOT_SPOT_BYTE_CODE

        Obsolete and ignored from Saxon 12.0.

      • MULTIPLE_SCHEMA_IMPORTS

        public static final Feature<java.lang.Boolean> MULTIPLE_SCHEMA_IMPORTS

        Affects schema construction (whether for standalone validation, or in the context of XSLT or XQuery).

        If set to true, the schema processor attempts to fetch a schema document appearing in an xs:import directive, whether or not a schema for that namespace has already been loaded, unless the absolute URI formed from the schemaLocation is the same as the absolute URI that was used to load that namespace. If set to false, the schema processor ignores the schemaLocation on an xs:import declaration if schema components for the requested namespace are already available. Note that setting the value to true might cause spurious errors due to like-named schema components being loaded more than once. On the other hand, setting the value to false might result in validation failing because schema components are missing.

        Note: Both settings are conformant with the W3C recommendation, which leaves the details implementation-defined. It is possible (and advisable) to write schemas in such a way that this setting makes no difference, by ensuring that all imports for a particular namespace go via a "home" schema document for that namespace, where the home schema document contains xs:include declarations for all the schema documents defining components in that namespace.

      • NAME_POOL

        public static final Feature<NamePool> NAME_POOL

        Indicates that the supplied NamePool should be used as the target (run-time) NamePool by all stylesheets compiled (using newTemplates()) after this call on setAttribute.

        Normally a single system-allocated NamePool is used for all stylesheets compiled while the Java VM remains loaded; this attribute allows user control over the allocation of name pools. Note that source trees used as input to a transformation must be built using the same NamePool that is used when the stylesheet is compiled: this will happen automatically if the input to a transformation is supplied as a SAXSource or StreamSource but it is under user control if you build the source tree yourself.

        This option can be used to make two Configuration objects share a NamePool even though they differ in other respects.

      • OCCURRENCE_LIMITS

        public static final Feature<java.lang.Object> OCCURRENCE_LIMITS

        OCCURRENCE_LIMITS determines the largest values of minOccurs and maxOccurs that can be accommodated when compiling an "expanded" finite state machine to represent an XSD content model grammar.

        These limits do not apply in the common cases where the grammar can be implemented using a counting finite-state-machine, but in those cases where this is not possible, any minOccurs value greater than the first integer is reduced to the value of the first integer, and any maxOccurs value greater than the second integer is treated as "unbounded".

        Setting these values too high may cause an OutOfMemoryException since the size of the finite state machine constructed by Saxon increases linearly with the values of minOccurs and maxOccurs.

      • OPTIMIZATION_LEVEL

        public static final Feature<java.lang.Object> OPTIMIZATION_LEVEL

        Allows individual optimizations to be enabled or disabled selectively.

        There is a set of single-letter flags identifying particular optimizations:

        • c: no longer used
        • e: cache regular expressions
        • f: inline functions
        • g: extract global variables
        • j: just-in-time compilation of template rules
        • k: create keys
        • l: loop lifting
        • m: miscellaneous
        • n: constant folding
        • r: template rule-sets
        • s: extract common subexpressions
        • v: inline variables
        • w: create switch statements
        • x: index predicates

        A value such as gs runs with only the selected optimizations; -gs runs with the selected optimizations disabled and all others enabled. The value 0 suppresses all optimizations. The default is full optimization; this feature allows optimization to be suppressed in cases where reducing compile time is important, or where optimization gets in the way of debugging, or causes extension functions with side-effects to behave unpredictably. (Note however, that even with no optimization, lazy evaluation may still cause the evaluation order to be not as expected.)

        Note that disabling optimizations may prevent streamed execution. This is because there are cases where streamed execution is only possible because the optimizer is able to detect that sorting nodes into document order is unnecessary.

      • OUTPUT_URI_RESOLVER

        public static final Feature<OutputURIResolver> OUTPUT_URI_RESOLVER

        The supplied OutputURIResolver will be used to resolve URIs of secondary result documents selected in the href attribute of the XSLT xsl:result-document instruction.

      • OUTPUT_URI_RESOLVER_CLASS

        public static final Feature<java.lang.String> OUTPUT_URI_RESOLVER_CLASS

        The supplied class will be instantiated, and the resulting OutputURIResolver will be used to resolve URIs of secondary result documents selected in the href attribute of the XSLT xsl:result-document instruction.

      • PRE_EVALUATE_DOC_FUNCTION

        public static final Feature<java.lang.Boolean> PRE_EVALUATE_DOC_FUNCTION

        If true, calls on the doc() and document() functions, if their arguments are known at compile time, will be evaluated at compile time, and the resulting document will be stored as part of the Saxon Configuration and shared by all queries and transformations running within that Configuration.

        This is useful for reference documents that have stable content and are used by many different queries and transformations. The default is false, which means each query or transformation will reload the document from disk.

        In XSLT 3.0 a better way of having external documents pre-loaded at stylesheet compile time is to use the new facility of static global variables.

        This feature should not be enabled when stylesheets are exported to a SEF file, since embedded source documents within a SEF file cannot always be accurately reconstructed.

        When URIs are pre-evaluated, neither the ResourceResolver associated with the relevant Compiler, nor the relevant run-time ResourceResolver are used to resolve the URI. Only the Configuration-level ResourceResolver is used.

      • RECOGNIZE_URI_QUERY_PARAMETERS

        public static final Feature<java.lang.Boolean> RECOGNIZE_URI_QUERY_PARAMETERS

        True if the doc() or document() are to recognize query parameters included in the URI (for example, ?validation=strict). The default is false.

        The allowed parameters are: validation=strict|lax|strip to perform schema validation (see Validation of source documents); strip-space=yes|ignorable|no to control whitespace stripping (see Whitespace stripping in source documents); parser=full.class.name to determine the name of the parser (XMLReader) to be used (see Controlling parsing of source documents); and xinclude=yes|no to control whether XInclude processing takes place, assuming the XML parser supports it (see XInclude processing).

      • RECOVERY_POLICY

        public static final Feature<java.lang.Integer> RECOVERY_POLICY

        At one time this property controlled how recoverable errors were handled (fatal error, warning, or ignored). XSLT 3.0 has eliminated all recoverable errors from the specification, so the property is deprecated from Saxon 10.0.

      • RECOVERY_POLICY_NAME

        public static final Feature<java.lang.String> RECOVERY_POLICY_NAME

        At one time this property controlled how recoverable errors were handled (fatal error, warning, or ignored). XSLT 3.0 has eliminated all recoverable errors from the specification, so the property is deprecated from Saxon 10.0.

      • RESULT_DOCUMENT_THREADS

        public static final Feature<java.lang.Integer> RESULT_DOCUMENT_THREADS

        Indicates the maximum number of threads to be used for processing xsl:result-document instructions in parallel. If the maximum number of threads are already in use, the xsl:result-document instruction will be executed synchronously within its parent thread.

        The default value is initialized to Runtime.getRuntime().availableProcessors() which is intended to represent the number of "processors" (under some definition) available from the hardware.

        The limit applies per Configuration. If multiple workloads are running on the same server under separate Saxon Configuration objects, then it may be desirable to lower the limit.

        Setting a value of zero or one suppresses multithreading entirely. This can also be achieved (for a specific xsl:result-document instruction) by setting the attribute saxon:asynchronous="no" in the stylesheet. Suppressing multithreading may be desirable in a stylesheet that calls extension functions with side-effects.

      • RETAIN_DTD_ATTRIBUTE_TYPES

        public static final Feature<java.lang.Boolean> RETAIN_DTD_ATTRIBUTE_TYPES

        If set to true, indicates that when input is obtained from a SAX parser, the DTD-based attribute type notified by the XML parser should be used to set the type annotation of the resulting node: for example a DTD type of NMTOKENS results in a type annotation of xs:NMTOKENS.

        This option is retained for backwards compatibility (at some time in the past, it was the default), but is deprecated.

      • SCHEMA_URI_RESOLVER

        public static final Feature<SchemaURIResolver> SCHEMA_URI_RESOLVER

        The supplied SchemaURIResolver will be used to resolve URIs of schema documents referenced in xsl:import-schema declarations in XSLT, import schema in XQuery, references from one schema document to another using xs:include or xs:import, and references from an instance document to a schema using xsi:schemaLocation.

      • SCHEMA_URI_RESOLVER_CLASS

        public static final Feature<java.lang.String> SCHEMA_URI_RESOLVER_CLASS

        The name of a class that implements the interface SchemaURIResolver; this class will be instantiated and the resulting instance will be used as the value of the SCHEMA_URI_RESOLVER property.

      • SCHEMA_VALIDATION

        public static final Feature<java.lang.Integer> SCHEMA_VALIDATION

        Indicates whether and how schema validation should be applied to source documents.

      • SCHEMA_VALIDATION_MODE

        public static final Feature<java.lang.String> SCHEMA_VALIDATION_MODE

        Indicates whether and how schema validation should be applied to source documents.

      • SERIALIZER_FACTORY_CLASS

        public static final Feature<java.lang.String> SERIALIZER_FACTORY_CLASS

        The class will be instantiated and the resulting SerializerFactory will be used to create the serialization pipeline for XSLT and XQuery results.

        By subclassing the standard SerializerFactory it is possible to customize many aspects of the output produced by the Serializer, or to introduce new serialization methods and parameters.

      • SOURCE_PARSER_CLASS

        public static final Feature<java.lang.String> SOURCE_PARSER_CLASS

        XML parser used for source documents.

        If the property is set to "#DEFAULT" then the JDK default parser will be instantiated.

        Otherwise, the requested class will be instantiated. If it is an XMLReader it is used directly; if it is a SAXParserFactory it is used to instantiate an XMLReader. The resulting XMLReader will be used to parse source documents (that is, the principal source document plus any secondary source documents read using the doc(), document(), or collection() function).

        Note that the selected parser is used only when the input is supplied in the form of a StreamSource; it is ignored when a SAXSource with a pre-initialized XMLReader is supplied. A consequence is that this configuration option has no effect when running transformations from an Ant script, since the Ant xslt task always supplies the input in the form of a SAXSource.

      • SOURCE_RESOLVER_CLASS

        public static final Feature<java.lang.String> SOURCE_RESOLVER_CLASS

        On interfaces that allow an org.xml.sax.Source to be supplied, if a kind of Source is provided that Saxon does not recognize, it will be passed to the user-supplied SourceResolver, which has the opportunity to convert it to a kind of Source that Saxon does recognize. This allows new kinds of input to be supplied as input to Saxon's query, transformation, and validation engines.

      • STABLE_COLLECTION_URI

        public static final Feature<java.lang.Boolean> STABLE_COLLECTION_URI

        STABLE_COLLECTION_URI, if set, indicates that collections returned by the fn:collection() and fn:uri-collection() functions should be stable, that is, repeated calls on these functions with the same collection URI (within the scope of a single query or transformation) should return identical results.

        Setting this option may be expensive because it requires that the entire collection be saved in memory; it is rarely necessary in practice, but is required for strict conformance with the W3C specifications.

        It is also possible to indicate that a collection is stable by means of the CollectionFinder API.

      • STABLE_UNPARSED_TEXT

        public static final Feature<java.lang.Boolean> STABLE_UNPARSED_TEXT

        STABLE_UNPARSED_TEXT, if set, indicates that the results returned by repeated calls of unparsed-text(), unparsed-text-lines(), and unparsed-text-available() are consistent: calling these functions twice during the evaluation of a stylesheet or query will return the same results.

        Setting this option may be expensive because it requires that the file contents be saved in memory; it is rarely necessary in practice, but is required for strict conformance with the W3C specifications.

      • STANDARD_ERROR_OUTPUT_FILE

        public static final Feature<java.lang.String> STANDARD_ERROR_OUTPUT_FILE

        STANDARD_ERROR_OUTPUT_FILE is the name of a file to which Saxon will redirect output that would otherwise go to the operating system standard error stream (System.err). This is the fallback destination for various tracing and diagnostic output. In some cases a more specific mechanism exists to select the destination for particular kinds of output.

        Note that if the Configuration is used in more than one processing thread, the messages from different threads will be interleaved in the output file. A more selective approach is to use a different ErrorListener in different processing threads, and arrange for each ErrorListener to write to its own logging destination.

      • STREAMABILITY

        public static final Feature<java.lang.String> STREAMABILITY

        The STREAMABILITY option can be used to disable streaming.

        In earlier Saxon releases a third value "extended" was supported, to enable Saxon streaming extensions. Since nearly all these extensions found their way into the W3C specification, the distinction between "standard" and "extended" became meaningless, so the value "extended" has been dropped.

        The value "off" causes Saxon to behave as a non-streaming processor; that is, it does not analyze constructs that are declared streamable, and it processes them as if streaming were not requested. This is the only option available when using a Saxon version or license that does not enable streaming.

        The value "standard" is a misnomer. For strict adherence to W3C streamability rules, set the property STRICT_STREAMABILITY. The streamability rules applied by default are (in nearly all cases) identical to the W3C rules, but by default they are applied to the expression tree after type-checking and optimization, which makes some constructs streamable that would not be so otherwise.

        Whichever option is chosen, the STREAMING_FALLBACK option can be used to control what happens when code is deemed non-streamable; it provides a choice between throwing a static (compile-time) error, and falling back to a non-streaming implementation.

      • STRICT_STREAMABILITY

        public static final Feature<java.lang.Boolean> STRICT_STREAMABILITY

        Causes the XSLT processor to verify that constructs that are declared streamable are in fact "guaranteed streamable" according to the W3C rules.

        Normally, Saxon performs a variety of simplifications and optimizations on the expression tree before performing streamability analysis. Sometimes these tree rewrites will turn a non-streamable expression into a streamable one. An obvious example is variable inlining: the expression let $x := ./item/price return sum($x) is not streamable, but the rewritten form sum(./item/price) is.

        The XSLT 3.0 specification requires conformant streaming processors to have a mode of operation in which the streamability rules are enforced as they appear in the spec, and this option enables this mode.

        This analysis is expensive, and should only be used during development when testing stylesheet code for portability. When this mode is enabled, Saxon applies the streamability rules at the earliest possible stage of processing; it then performs its normal type checking and optimization phases, before doing a second stage of streamability analysis to construct a streamed execution plan.

      • STREAMING_FALLBACK

        public static final Feature<java.lang.Boolean> STREAMING_FALLBACK

        If the STREAMING_FALLBACK option is set, then constructs for which streaming is requested (such as templates in a streaming mode, the xsl:source-document instruction with attribute streamable="yes", and streamable accumulators) will be executed in non-streaming mode if the code is not actually streamable. A compile-time warning will always be given when the fallback option is taken.

      • STRIP_WHITESPACE

        public static final Feature<java.lang.String> STRIP_WHITESPACE

        Indicates whether all whitespace, no whitespace, or whitespace in elements defined in a DTD or schema as having element-only content should be stripped from source documents.

        The default is "ignorable". This whitespace stripping is additional to any stripping done as a result of the xsl:strip-space declaration in an XSLT stylesheet.

      • STYLE_PARSER_CLASS

        public static final Feature<java.lang.String> STYLE_PARSER_CLASS

        XML parser used for stylesheets and schema documents.

        If the property is set to "#DEFAULT" then the JDK default parser will be instantiated.

        Otherwise, the requested class will be instantiated. If it is an XMLReader it is used directly; if it is a SAXParserFactory it is used to instantiate an XMLReader. The resulting XMLReader will be used to parse stylesheet documents (that is, the principal stylesheet module plus any secondary source documents read using xsl:include or xsl:import) and also schema documents.

      • SUPPRESS_EVALUATION_EXPIRY_WARNING

        public static final Feature<java.lang.Boolean> SUPPRESS_EVALUATION_EXPIRY_WARNING

        This is set to true to suppress the warning otherwise issued by command-line interfaces indicating that an evaluation license is in use and is due to expire in a set number of days.

      • SUPPRESS_XPATH_WARNINGS

        public static final Feature<java.lang.Boolean> SUPPRESS_XPATH_WARNINGS

        Suppresses all warnings issued by the XPath and XQuery parsers.

        Examples of warnings that are suppressed are the warning produced when keywords such as true and return are interpreted as element names.

      • SUPPRESS_XSLT_NAMESPACE_CHECK

        public static final Feature<java.lang.Boolean> SUPPRESS_XSLT_NAMESPACE_CHECK

        This is set to true to suppress the warning when there is no commonality between the namespaces used in stylesheet match patterns and the namespaces used in the source document.

      • THRESHOLD_FOR_COMPILING_TYPES

        public static final Feature<java.lang.Integer> THRESHOLD_FOR_COMPILING_TYPES

        Obsolete and ignored from Saxon 12.0.

      • TIMING

        public static final Feature<java.lang.Boolean> TIMING

        This is set to true to cause basic timing and tracing information to be output to the standard error output stream.

        The name of the feature is poorly chosen, since much of the information that is output has nothing to do with timing, for example the names of output files for xsl:result-document are traced, as are the names of schema documents loaded.

      • TRACE_EXTERNAL_FUNCTIONS

        public static final Feature<java.lang.Boolean> TRACE_EXTERNAL_FUNCTIONS

        If this option is set, Saxon will output (to the standard error output) progress information about its attempts to locate and disambiguate references to reflexive Java extension functions. This is useful for diagnostics if the XQuery or XSLT compiler is failing to locate user-written extension functions.

      • TRACE_LISTENER

        public static final Feature<TraceListener> TRACE_LISTENER

        The TraceListener will be notified of significant events occurring during a query or transformation, for tracing or debugging purposes.

        Setting a TraceListener automatically sets the COMPILE_WITH_TRACING option.

        Avoid this option if more than one transformation or query is running concurrently: use the feature TRACE_LISTENER_CLASS instead. Alternatively, it is possible to set a TraceListener for an individual query or transformation.

      • TRACE_LISTENER_CLASS

        public static final Feature<java.lang.String> TRACE_LISTENER_CLASS

        The class will be instantiated once for each query or transformation, and the resulting TraceListener will be notified of significant events occurring during that query or transformation, for tracing or debugging purposes.

        Setting a TraceListener automatically sets the COMPILE_WITH_TRACING option.

      • TRACE_LISTENER_OUTPUT_FILE

        public static final Feature<java.lang.String> TRACE_LISTENER_OUTPUT_FILE

        When trace listening is switched on (for example by using -T on the command line), this file will be supplied to the trace listener to use as the output destination. If the option is not supplied, trace listener output is sent to the standard error stream.

      • TRACE_OPTIMIZER_DECISIONS

        public static final Feature<java.lang.Boolean> TRACE_OPTIMIZER_DECISIONS

        If this option is set, Saxon will output (to the standard error output) detailed information about the rewrites to the expression tree made by the optimizer. This information is mainly useful for internal system debugging, but it is also possible to digest it to analyze the ways in which the expression has been optimized for the purpose of performance analysis and tuning.

      • TREE_MODEL

        public static final Feature<java.lang.Integer> TREE_MODEL

        Selects an implementation of the Saxon tree model. The default is TINY_TREE.

        For running XQuery Update, use the linked tree, because it is the only implementation that is updateable.

      • TREE_MODEL_NAME

        public static final Feature<java.lang.String> TREE_MODEL_NAME

        Selects an implementation of the Saxon tree model. The default is tinyTree.

        For running XQuery Update, use the linked tree, because it is the only implementation that is updateable.

      • UNPARSED_TEXT_URI_RESOLVER

        public static final Feature<UnparsedTextURIResolver> UNPARSED_TEXT_URI_RESOLVER

        The supplied UnparsedTextURIResolver will be used to resolve (dereference) all URIs specifed in calls to the unparsed-text(), unparsed-text-lines(), and unparsed-text-available() functions.

      • UNPARSED_TEXT_URI_RESOLVER_CLASS

        public static final Feature<java.lang.String> UNPARSED_TEXT_URI_RESOLVER_CLASS

        An instance of the specified UnparsedTextURIResolver class will be created, and used to resolve (dereference) all URIs specifed in calls to the unparsed-text(), unparsed-text-lines(), and unparsed-text-available() functions.

      • URI_RESOLVER_CLASS

        public static final Feature<java.lang.String> URI_RESOLVER_CLASS

        An instance of the specified URIResolver class will be created, and used to resolve (dereference) all URIs specifed in calls to the doc() and document() functions, as well as URIs used in xsl:include and xsl:import and location hints for XQuery modules and XSD schema documents.

      • USE_PI_DISABLE_OUTPUT_ESCAPING

        public static final Feature<java.lang.Boolean> USE_PI_DISABLE_OUTPUT_ESCAPING

        This option determines whether a TransformerHandler created with this TransformerFactory or Configuration recognizes the JAXP-defined processing instructions Result.PI_DISABLE_OUTPUT_ESCAPING and Result.PI_ENABLE_OUTPUT_ESCAPING in the input stream as instructions to disable or to re-enable output escaping. The default value is false.

      • USE_TYPED_VALUE_CACHE

        public static final Feature<java.lang.Boolean> USE_TYPED_VALUE_CACHE

        This option is relevant only when the TinyTree is used; it determines whether (for a validated document) a cache will be maintained containing the typed values of nodes.

        Typed values are held in the cache only for elements and attributes whose type is other than string, untypedAtomic, or anyURI. The default value is true. Setting this value to false can reduce memory requirements at the cost of requiring recomputation of typed values on each access.

      • USE_XSI_SCHEMA_LOCATION

        public static final Feature<java.lang.Boolean> USE_XSI_SCHEMA_LOCATION

        This option determines whether or not to use the xsi:schemaLocation and xsi:noNamespaceSchemaLocation attributes in an instance document to locate a schema for validation.

        Note, these attribute are only consulted if validation is requested; the presence of one of these attributes never by itself triggers validation.

      • VALIDATION_COMMENTS

        public static final Feature<java.lang.Boolean> VALIDATION_COMMENTS

        This option determines whether non-fatal validation errors in XQuery or XSLT result documents should result in comments being inserted into the result tree. The command-line flag -outval:recover sets both this option and the VALIDATION_WARNINGS option.

      • VALIDATION_WARNINGS

        public static final Feature<java.lang.Boolean> VALIDATION_WARNINGS

        This option indicates (if true) that errors occuring while validating a final result tree are not to be treated as fatal.

        Regardless of the setting of this option, all validation errors are reported to the error() method of the ErrorListener, and validation is terminated if the error() method throws an exception, or if the error limit set in the ParseOptions object is reached.

        This option primarily controls what happens at the end of a validation episode. If the validation episode detected one or more validation errors, then when this option is off, an exception is thrown, which will normally result in any query or stylesheet failing with a dynamic error, and no output file being written. If the option is on, no exception is thrown, and the output is written as if validation had been successful. Note in this case that any type annotations present in a result document are unreliable.

        If this option is set when running XSLT or XQuery, it is ignored as far as input files are concerned: validation errors in input files are still fatal. However, if the option is set and a validation error occurs in a final output file, the output file is still written and the process terminates as if successful.

        The detailed interpretation of this option changed in Saxon 9.5.

      • VERSION_WARNING

        public static final Feature<java.lang.Boolean> VERSION_WARNING

        Indicates whether a warning message should be notified (to the ErrorListener) if running Saxon against an XSLT stylesheet that specifies version="1.0".

        From Saxon 9.8, the warning is no longer output (since XSLT 3.0 does not require it), so this option is ignored.

      • XINCLUDE

        public static final Feature<java.lang.Boolean> XINCLUDE

        Indicates whether XML documents should have any XInclude directives expanded. The default is false.

        This option relies on support in the underlying XML parser. If the XML parser does not support XInclude processing, setting this option results in a parsing failure.

        The effect of the option is to set a flag to request XInclude expansion in the default parse options held at Configuration level. These options are used on most occasions that an XML document is parsed (including parsing of XSD schema documents), but with one notable exception: XSLT stylesheet documents. XInclude directives are never expanded in stylesheet modules, except of course when they are processed using APIs (such as the DocumentBuilder, or a call on fn:document("")) that treat them as generic XML documents. The default options can be overridden in many APIs by custom parsing options.

      • XML_VERSION

        public static final Feature<java.lang.String> XML_VERSION

        This determines the XML version used by the Configuration.

        Note that source documents specifying xml version="1.0" or "1.1" are accepted regardless of this setting. The effect of this switch is to change the validation rules for types such as xs:Name and xs:NCName, to change the characters allowed in names within XPath expressions (etc.), to change the meaning of \i and \c in regular expressions, and to determine whether the serializer allows XML 1.1 documents to be constructed.

        The default is 1.0.

        SaxonCS uses the System.Xml parser, which does not support XML 1.1.

      • XML_PARSER_FEATURE

        public static final Feature<java.lang.Boolean> XML_PARSER_FEATURE

        Sets the value of a parser feature flag. The feature name is any fully-qualified URI.

        For example if the parser supports a feature http://xml.org/sax/features/external-parameter-entities then this can be set by setting the value of the Configuration property: http://saxon.sf.net/feature/parserFeature?uri=http%3A//xml.org/sax/features/external-parameter-entities to true.

      • XML_PARSER_PROPERTY

        public static final Feature<java.lang.Boolean> XML_PARSER_PROPERTY

        Sets the value of a parser property flag. The property name is any fully-qualified URI.

        For example if the parser supports a property http://apache.org/xml/properties/schema/external-schemaLocation then this can be set using the value of the Configuration property: http://saxon.sf.net/feature/parserProperty?uri=http%3A//apache.org/xml/properties/schema/external-schemaLocation to the required value.

      • XQUERY_ALLOW_UPDATE

        public static final Feature<java.lang.Boolean> XQUERY_ALLOW_UPDATE

        Determines whether XQuery Update syntax is accepted.

        If true, update syntax is accepted, if false, it is not accepted. Setting the value to true does not mean that the query has to use update syntax, only that it may do so.

        From Saxon 9.6, XQuery Update syntax and XQuery 3.0 syntax can be mixed, although this combination is not defined by any W3C specification at the time of writing.

        This option can be set for a particular XQuery compilation. When the option is set at the Configuration level, it acts as a default.

        On the command line, this option is combined with the option "discard" which indicates that updates are allowed, but the updates are not written back to filestore. This does not correspond to any option in the Java API, where writing an updated document back to filestore only happens if explicitly requested.

      • XQUERY_CONSTRUCTION_MODE

        public static final Feature<java.lang.String> XQUERY_CONSTRUCTION_MODE

        This option defines the default value of the construction mode in the XQuery static context (overridable in the query prolog).

        This option can be set for a particular XQuery compilation. When the option is set at the Configuration level, it acts as a default.

      • XQUERY_DEFAULT_ELEMENT_NAMESPACE

        public static final Feature<java.lang.Object> XQUERY_DEFAULT_ELEMENT_NAMESPACE

        This property defines the default namespace for elements and types that are not qualified by a namespace prefix.

        This option can be set for a particular XQuery compilation. When the option is set at the Configuration level, it acts as a default.

      • XQUERY_DEFAULT_FUNCTION_NAMESPACE

        public static final Feature<java.lang.Object> XQUERY_DEFAULT_FUNCTION_NAMESPACE

        This property defines the default namespace for function names that are not qualified by a namespace prefix.

        This option can be set for a particular XQuery compilation. When the option is set at the Configuration level, it acts as a default.

      • XQUERY_EMPTY_LEAST

        public static final Feature<java.lang.Boolean> XQUERY_EMPTY_LEAST

        This property defines how the empty sequence is handled in XQuery sorting (the "order by" clause). If true, () comes at the start of the sorted sequence; if false, it comes last.

        This option can be set for a particular XQuery compilation. When the option is set at the Configuration level, it acts as a default.

      • XQUERY_INHERIT_NAMESPACES

        public static final Feature<java.lang.Boolean> XQUERY_INHERIT_NAMESPACES

        This property defines the default value of the inherit-namespaces property in the XQuery static context.

        This option can be set for a particular XQuery compilation. When the option is set at the Configuration level, it acts as a default.

      • XQUERY_MULTIPLE_MODULE_IMPORTS

        public static final Feature<java.lang.Boolean> XQUERY_MULTIPLE_MODULE_IMPORTS

        If the value is false, then when an import module declaration is encountered for a module URI that is already among the known loaded modules (or modules in the process of being compiled), the import module is treated as a reference to the existing module. If the value is true, the system first checks whether the supplied "location hints" match the known location of the existing module, and the existing module is used only if there is a match.

      • XQUERY_PRESERVE_BOUNDARY_SPACE

        public static final Feature<java.lang.Boolean> XQUERY_PRESERVE_BOUNDARY_SPACE

        This property defines whether "boundary space" (insignificant space in direct element constructors) should be retained or not.

        This option can be set for a particular XQuery compilation. When the option is set at the Configuration level, it acts as a default.

      • XQUERY_PRESERVE_NAMESPACES

        public static final Feature<java.lang.Boolean> XQUERY_PRESERVE_NAMESPACES

        This property defines whether unused namespace declarations are retained by XQuery element copy operations.

        This option can be set for a particular XQuery compilation. When the option is set at the Configuration level, it acts as a default.

      • XQUERY_REQUIRED_CONTEXT_ITEM_TYPE

        public static final Feature<java.lang.String> XQUERY_REQUIRED_CONTEXT_ITEM_TYPE

        This property defines the default expected context item type for a query.

        This option can be set for a particular XQuery compilation. When the option is set at the Configuration level, it acts as a default.

      • XQUERY_SCHEMA_AWARE

        public static final Feature<java.lang.Boolean> XQUERY_SCHEMA_AWARE

        A query will automatically be schema-aware if it contains an import schema declaration. This property allows a query to be marked as schema-aware even if it contains no import schema declaration. It is necessary for a query to be compiled as schema-aware if it is to handle typed (validated) input documents in which nodes have type annotations based on their schema-defined type.

        This option can be set for a particular XQuery compilation. When the option is set at the Configuration level, it acts as a default.

      • XQUERY_STATIC_ERROR_LISTENER_CLASS

        public static final Feature<java.lang.String> XQUERY_STATIC_ERROR_LISTENER_CLASS

        The specified class is instantiated to create an ErrorListener, and all reports of static errors in a query will go to this ErrorListener.

        This option can be set for a particular XQuery compilation. When the option is set at the Configuration level, it acts as a default.

        In the absence of this property, the global ErrorListener specified as the value of the ERROR_LISTENER_CLASS property is used.

      • XQUERY_VERSION

        public static final Feature<java.lang.String> XQUERY_VERSION

        This property determines the version of XQuery used by the Configuration.

        Indicates the version of XQuery syntax that is accepted. From Saxon 9.8, an XQuery 3.1 processor is always used by default. So setting this property to a value less than 3.1 is no longer allowed. The value "4.0" enables experimental syntax extensions that are under discussion in the XML community, and subject to change.

      • XSD_VERSION

        public static final Feature<java.lang.String> XSD_VERSION

        This property determines the version of XML Schema used by the Configuration.

        From Saxon 9.8, the default is XSD 1.1. If XSD 1.0 is selected, XSD 1.1 features will be rejected, with the exception of the version control attributes that allow sections of the schema to be marked as requiring XSD 1.0 or XSD 1.1.

      • XSLT_ENABLE_ASSERTIONS

        public static final Feature<java.lang.Boolean> XSLT_ENABLE_ASSERTIONS

        This property indicates whether assertions (XSLT 3.0 xsl:assert instructions) are enabled or disabled. They are disabled by default. Setting this property on causes assertions to be enabled at compile time for all XSLT packages compiled using the default configuration options.

        This option can be set for a particular XSLT compilation. When the option is set at the Configuration level (or on a TransformerFactory), it acts as a default.

        If assertions have been enabled at compile time for a particular package, they can still be disabled at run-time (for all packages) by setting an option on the Xslt30Transformer. But if assertions were disabled at compile time, enabling them at run-time has no effect.

      • XSLT_INITIAL_MODE

        public static final Feature<java.lang.String> XSLT_INITIAL_MODE

        This property indicates the name of a mode within a stylesheet in which execution (using template rules) should begin.

        This option can be set for a particular XSLT transformation. When the option is set at the Configuration (or on a TransformerFactory), it acts as a default.

      • XSLT_INITIAL_TEMPLATE

        public static final Feature<java.lang.String> XSLT_INITIAL_TEMPLATE

        This property indicates the name of a named template within a stylesheet where execution should begin.

        This option can be set for a particular XSLT transformation. When the option is set at the Configuration level (or on a TransformerFactory), it acts as a default.

        Specifically, if the transformation is performed using the transform() method of class net.sf.saxon.s9api.XsltTransformer, then the transformation will proceed by calling the relevant named template, rather than by applying templates to the supplied source node. It will also affect other APIs built on top of the XsltTransformer, notably the JAXP transformation interface, which in turn is used by many higher-level interfaces such as Ant. Indeed, the main purpose of this configuration option is to allow named-template stylesheet invocation using the JAXP interface, which was designed without this feature in mind.

        This configuration option is ignored when using an net.sf.saxon.s9api.Xslt30Transformer, or other interfaces built on top of an Xslt30Transformer, for example the net.sf.saxon.Transform command line interface.

      • XSLT_SCHEMA_AWARE

        public static final Feature<java.lang.Boolean> XSLT_SCHEMA_AWARE

        This property indicates whether stylesheets should be compiled with the ability to handle schema-typed input documents. By default a stylesheet is compiled to handle such input if it contains an xsl:import-schema instruction, and not otherwise. It is necessary for a stylesheet to be compiled as schema-aware if it is to handle typed (validated) input documents in which nodes have type annotations based on their schema-defined type.

        This option can be set for a particular XSLT compilation. When the option is set at the Configuration level (or on a TransformerFactory), it acts as a default.

      • XSLT_STATIC_ERROR_LISTENER_CLASS

        public static final Feature<java.lang.String> XSLT_STATIC_ERROR_LISTENER_CLASS

        The specified class is instantiated to create an ErrorListener, and all reports of static errors in a stylesheet will go to this ErrorListener.

        This option can be set for a particular XSLT compilation. When the option is set at the Configuration level (or on a TransformerFactory), it acts as a default.

        In the absence of this property, the global ErrorListener specified as the value of the ERROR_LISTENER_CLASS property is used.

      • XSLT_STATIC_URI_RESOLVER_CLASS

        public static final Feature<java.lang.String> XSLT_STATIC_URI_RESOLVER_CLASS

        This property defines a URIResolver used when dereferencing the URIs that appear in the href attributes of the xsl:include and xsl:import declarations. Note that this defaults to the setting of the global URI_RESOLVER property.

        This option can be set for a particular XSLT compilation. When the option is set at the Configuration level (or on a TransformerFactory), it acts as a default.

        In the absence of this property, the global URIResolver specified as the value of the URI_RESOLVER_CLASS property is used.

      • XSLT_VERSION

        public static final Feature<java.lang.String> XSLT_VERSION

        This property determines the version of XSLT to be supported by default.

        From Saxon 9.8, an XSLT 3.0 processor is always used by default. So setting this property to a value less than 3.0 has no effect.

        The value 4.0 enables experimental syntax extensions, under discussion in the XML community, which are subject to change.

      • REGEX_BACKTRACKING_LIMIT

        public static final Feature<java.lang.Integer> REGEX_BACKTRACKING_LIMIT

        This property sets a limit on the amount of backtracking performed during regular expression evaluation.

        The default is 10000000 (ten million) which typically represents an evaluation time of about ten seconds. After this time, evaluation of the regular expression will fail rather than making further attempts to find a match. If this limit is reached, it often suggests that there might be a better way of writing the regular expression. The value can be set to -1 (minus one) to mean "unlimited".

        Excessive backtracking is usually caused by nested loops in the regular expression, combined with processing of long input strings. Try to ensure that when nested loops are used, there is an unambiguous condition that causes the inner loop to terminate. For example (/[^/]*)+ is fine (it matches a sequence of path segments separated by / characters), because the presence of / forces the inner loop to terminate. By contrast, (/.*)+ matches the same input, but in many different ways, which could lead to excessive backtracking to no useful purpose.

      • XPATH_VERSION_FOR_XSD

        public static final Feature<java.lang.Integer> XPATH_VERSION_FOR_XSD

        The XSD 1.1 specification states that XPath version 2.0 is used for expressions appearing in assertions and type alternatives. This option allows XPath 3.0 or 3.1 to be used instead.

        The recognized values are the integers 20, 30, and 31 representing versions 2.0, 3.0, and 3.1 respectively.

      • XPATH_VERSION_FOR_XSLT

        public static final Feature<java.lang.Integer> XPATH_VERSION_FOR_XSLT

        The XSLT 3.0 specification states that processors are required to support XPath 3.0 expressions within stylesheets, together with some extensions (maps) selected from the XPath 3.1 specification. Support for the full syntax of XPath 3.1 is optional, but it is the default in Saxon. This option allows a different XPath language level to be selected.

        The integer values 20, 30, and 31 denote XPath 2.0, 3.0, and 3.1 respectively, while the value 305 denotes XPath 3.0 with the extensions defined in the XSLT 3.0 specification.

      • THRESHOLD_FOR_FUNCTION_INLINING

        public static final Feature<java.lang.Integer> THRESHOLD_FOR_FUNCTION_INLINING

        Saxon-EE performs inlining of user-defined functions that are sufficiently simple: they must not be recursive, and they must be below a certain size. This option defines the size.

        The value is (roughly) the number of nodes in the expression tree representing the function body. This includes both explicit subexpressions, and subexpressions added by Saxon itself to perform implicit operations such as type checking or conversion of function arguments. The default value is 100.

      • THRESHOLD_FOR_HOTSPOT_BYTE_CODE

        public static final Feature<java.lang.Integer> THRESHOLD_FOR_HOTSPOT_BYTE_CODE

        Obsolete and ignored from Saxon 12.0.

      • ALLOWED_PROTOCOLS

        public static final Feature<java.lang.Object> ALLOWED_PROTOCOLS

        The value is a comma-separated list of permitted protocols. A protocol is the scheme portion of a URI, or in the case of the JAR protocol, "jar" plus the scheme portion separated by colon. The value "all" gives access to all protocols (which is the default). The value "" (empty string) disallows all external resource access. (The format is thus the same as for XMLConstants.ACCESS_EXTERNAL_SCHEMA and similar attributes.)

        The value constrains access by Saxon (but not by underlying software, such as the XML parser) to resources including the following:

        • Stylesheet modules
        • Schema documents
        • Query modules
        • Documents referenced from a stylesheet or query using functions such as fn:doc, fn:document, fn:unparsed-text, fn:collection, fn:json-doc, fn:transform, or by the xsl:source-document instruction.
        • Resources obtained using Saxon-supplied extension functions such as those in the EXPath file library (but it does not affect user-supplied extension functions).

        The constraint applies to the URI used to request the resource; the constraint is applied by the standard URI resolvers, but if user-supplied resolvers are used (such as a URIResolver), they can decide whether to apply the restrictions or not.

        The constraint applies to URIs used as locations or location hints, not to URIs used as names. So for XSD it applies to a schemaLocation, not a targetNamespace; for XQuery it applies to module location hints, not to module URIs. In the case of XSLT packages, resolution from a package name to a location is always under user/application control, so Saxon imposes no restrictions.

        The format is the same as for XMLConstants.ACCESS_EXTERNAL_SCHEMA: either "all" to allow all schemes/protocols, or a comma-separated list of scheme names such as "http", "file", "ftp". For a JAR file scheme, use the format "jar:scheme", for example "jar:file". A zero-length string disallows all schemes.

      • RETAIN_NODE_FOR_DIAGNOSTICS

        public static final Feature<java.lang.Boolean> RETAIN_NODE_FOR_DIAGNOSTICS

        By default, Saxon attempts to ensure that the run-time code contains no links to the original source stylesheet tree. This allows the garbage collector to free memory.

        If this option is set, then Location objects held in the run-time expression tree may contain a link to an element node in the source stylesheet, enabling a user-written ErrorReporter to produce improved diagnostics. This may be an appropriate setting to use, for example, in an IDE.

        This setting can also be useful to get improved location information for compile-time errors in cases where reliable line numbers are not available for the source stylesheet. This might happen, for example, if the source stylesheet is preprocessed before compilation, or if it is retrieved from an XML database.

        Links to source nodes are not retained in an exported SEF file, regardless of this setting.

      • ALLOW_UNRESOLVED_SCHEMA_COMPONENTS

        public static final Feature<java.lang.Boolean> ALLOW_UNRESOLVED_SCHEMA_COMPONENTS

        The W3C XSD specification (both 1.0 and 1.1) states that an unresolved reference to an absent schema component does not automatically make the schema invalid; the schema should be usable for validation provided that the missing components are not actually needed in a particular validation episode.

        However, the W3C XSD conformance tests treat such an unresolved reference as an error; the test is expected to report the schema as invalid. And this is the way most schema processors actually operate, and probably what most users would expect.

        By default, the Saxon schema processor reports an unresolved reference as an error in the schema.

        If this option is set, then Saxon attempts to repair the schema so that it is usable for validation, by substituting the missing components with default components: for example if an attribute declaration refers to a type that has not been defined, then xs:error is substituted, making any instance of the attribute invalid.

      • ZIP_URI_PATTERN

        public static final Feature<java.lang.String> ZIP_URI_PATTERN

        The value of this property is a regular expression used to decide whether a collection URI is to be treated as representing a ZIP file. The default pattern is "^jar:|\.jar$|\.zip$\.docx$\.xlsx$" which matches a URI that starts with "jar:" or that ends with ".jar", ".zip", ".docx", or ".xlsx".

        This is used by the standard Collection Finder and may not be relevant if a custom Collection Finder is in use.

        If the absolutized URI passed to the collection() function matches this pattern, then the URI will be treated as a reference to a ZIP file (and will therefore fail if the URI does not resolve to a resource that can be opened as a ZIP file).

      • RESOURCE_RESOLVER

        public static final Feature<java.lang.Object> RESOURCE_RESOLVER

        The supplied implementation of ResourceResolver is used to resolve URIs. The default implementation uses XML Catalog files. The Saxon resource resolver is used by the entity resolver, URI resolver, unparsed text resolver, and other resolvers that resolve URIs to resources.

      • RESOURCE_RESOLVER_CLASS

        public static final Feature<java.lang.String> RESOURCE_RESOLVER_CLASS

        The supplied class is instantiated and the resulting instance is used as the value of the RESOURCE_RESOLVER property.