///*DOTNETONLY*/  import org.orbeon.saxon.dotnet.DotNetPlatform;

* This class holds details of user-selected configuration options for a set of transformations

* and/or queries. When running XSLT, the preferred way of setting configuration options is via

* the JAXP TransformerFactory interface, but the Configuration object provides a finer

* level of control. As yet there is no standard API for XQuery, so the only way of setting

* Configuration information is to use the methods on this class directly.

* <p/>

* <p>As well as holding configuration settings, this class acts as a factory for classes

* providing service in particular areas: error handling, URI resolution, and the like. Some

* of these services are chosen on the basis of the current platform (Java or .NET), some vary

* depending whether the environment is schema-aware or not.</p>

* <p/>

* <p>The <code>Configuration</code> provides access to a {@link NamePool} which is used to manage

* all the names used in stylesheets, queries, schemas, and source and documents: the NamePool

* allocates integer codes to these names allowing efficient storage and comparison. Normally

* there will be a one-to-one relationship between a <code>NamePool</code> and a <code>Configuration</code>.

* It is possible, however, for several <code>Configuration</code> objects to share the same

* <code>NamePool</code>. Until Saxon 8.9, by default all <code>Configuration</code> objects

* shared a single <code>NamePool</code> unless configured otherwise; this changed in 8.9 so that

* the default is to allocate a new <code>NamePool</code> for each <code>Configuration</code>.</p>

* <p/>

* <p>The <code>Configuration</code> establishes the scope within which node identity is managed.

* Every document belongs to a <code>Configuration</code>, and every node has a distinct identity

* within that <code>Configuration</code>. In consequence, it is not possible for any query or

* transformation to manipulate multiple documents unless they all belong to the same

* <code>Configuration</code>.</p>

* <p/>

* <p>Saxon-SA has a subclass of the <code>Configuration</code> class which provides the additional

* services needed for schema-aware processing. The {@link com.saxonica.validate.SchemaAwareConfiguration}

* also holds a cache of loaded schema components used for compiling schema-aware transformations

* and queries, and for validating instance documents.</p>

* <p/>

* <p>Since Saxon 8.4, the JavaDoc documentation for Saxon attempts to identify interfaces

* that are considered stable, and will only be changed in a backwards-incompatible way

* if there is an overriding reason to do so. These interfaces and methods are labelled

* with the JavaDoc "since" tag. The value 8.n indicates a method in this category that

* was introduced in Saxon version 8.n: or in the case of 8.4, that was present in Saxon 8.4

* and possibly in earlier releases. (In some cases, these methods have been unchanged for

* a long time.) Methods without a "since" tag, although public, are provided for internal

* use or for use by advanced users, and are subject to change from one release to the next.

* The presence of a "since" tag on a class or interface indicates that there are one or more

* methods in the class that are considered stable; it does not mean that all methods are

* stable.

*

* @since 8.4

*/

    private static Platform platform;

    private transient URIResolver uriResolver;

    private StandardURIResolver systemURIResolver = new StandardURIResolver(this);

    protected transient ErrorListener listener;

    private int xmlVersion = XML10;

    protected int xsdlVersion = XSD10;

    private int treeModel = Builder.TINY_TREE;

    private boolean lineNumbering = false;

    private boolean tracing = false;

    private boolean traceOptimizations = false;

    private transient TraceListener traceListener = null;

    private String traceListenerClass = null;

    private FunctionLibrary javaExtensionBinder;

    private FunctionLibrary dotNetExtensionBinder;

    private transient ExtensionFunctionFactory javaExtensionFunctionFactory;

    private transient ExtensionFunctionFactory dotNetExtensionFunctionFactory;

    private CollationURIResolver collationResolver = StandardCollationURIResolver.getInstance();

    private CollectionURIResolver collectionResolver = new StandardCollectionURIResolver();

    private ModuleURIResolver moduleURIResolver = null;

    private ModuleURIResolver standardModuleURIResolver = StandardModuleURIResolver.getInstance();

    private SchemaURIResolver schemaURIResolver = null;

    private transient SourceResolver sourceResolver = this;

    protected VendorFunctionLibrary vendorFunctionLibrary;

    protected int recoveryPolicy = RECOVER_WITH_WARNINGS;

    private String messageEmitterClass = "org.orbeon.saxon.event.MessageEmitter";

    private String sourceParserClass;

    private String styleParserClass;

    private boolean preferJaxpParser;

    private transient OutputURIResolver outputURIResolver;

    private boolean timing = false;

    private boolean versionWarning = false;

    private boolean allowExternalFunctions = true;

    private boolean traceExternalFunctions = false;

    private boolean validation = false;

    private boolean allNodesUntyped = false;

    private boolean lazyConstructionMode = false;

    private boolean allowMultiThreading = false;

    private boolean preEvaluateDocFunction = false;

    private boolean useXsiSchemaLocation = true;

    private int stripsWhiteSpace = Whitespace.IGNORABLE;

    private boolean xIncludeAware = false;

    private boolean useDisableOutputEscaping = false;

    private NamePool namePool = null;

    private DocumentNumberAllocator documentNumberAllocator = new DocumentNumberAllocator();

    private DocumentPool globalDocumentPool = new DocumentPool();

    private transient XPathContext conversionContext = null;

    private transient TypeHierarchy typeHierarchy;

    private int hostLanguage = XSLT;

    private int schemaValidationMode = Validation.PRESERVE;

    private boolean validationWarnings = false;

    private boolean expandDefaultAttributes = true;

    private boolean retainDTDattributeTypes = false;

    private transient Debugger debugger = null;

    protected Optimizer optimizer = null;

    private transient DynamicLoader dynamicLoader = new DynamicLoader();

    private SerializerFactory serializerFactory = new SerializerFactory();

    //private int implicitTimezone;

    private transient List sourceParserPool = new ArrayList(5);

    private transient List styleParserPool = new ArrayList(5);

    /**

     * The external object models are held in static so they are only loaded once in an application

     * that creates many Configurations repeatedly. This saves expensive searches of the classpath

     */

    private static List sharedExternalObjectModels = null;

    private List externalObjectModels = null;

    private int domLevel = 3;

    /**

     * Constant indicating that the processor should take the recovery action

     * when a recoverable error occurs, with no warning message.

     */

    public static final int RECOVER_SILENTLY = 0;

    /**

     * Constant indicating that the processor should produce a warning

     * when a recoverable error occurs, and should then take the recovery

     * action and continue.

     */

    public static final int RECOVER_WITH_WARNINGS = 1;

    /**

     * Constant indicating that when a recoverable error occurs, the

     * processor should not attempt to take the defined recovery action,

     * but should terminate with an error.

     */

    public static final int DO_NOT_RECOVER = 2;

    /**

     * Constant indicating the XML Version 1.0

     */

    public static final int XML10 = 10;

    /**

     * Constant indicating the XML Version 1.1

     */

    public static final int XML11 = 11;

    /**

     * Constant indicating that the host language is XSLT

     */

    public static final int XSLT = 50;

    /**

     * Constant indicating that the host language is XQuery

     */

    public static final int XQUERY = 51;

    /**

     * Constant indicating that the "host language" is XML Schema

     */

    public static final int XML_SCHEMA = 52;

    /**

     * Constant indicating that the host language is Java: that is, this is a free-standing

     * Java application with no XSLT or XQuery content

     */

    public static final int JAVA_APPLICATION = 53;

    /**

     * Constant indicating that the host language is XPATH itself - that is, a free-standing XPath environment

     */

    public static final int XPATH = 54;

    /**

     * Language versions for XML Schema

     */

    public static int XSD10 = 10;

    public static int XSD11 = 11;

    /**

     * Static initialization

     */

    static {

        // This code is designed to be modified by the build process so only the appropriate code for the

        // platform is included. However, it's also designed so that it can run correctly without any

        // special build action.

        /*JAVAONLY*/ platform = JavaPlatform.getInstance();

        /*DOTNETONLY*/ /*JAVAONLY*/ if (System.getProperty("java.vendor").equals("Jeroen Frijters")) {

            //System.err.println("Call to create .NET platform currently disabled in Configuration.java (needed for JDK1.4)");

// ORBEON

//            /*DOTNETONLY*/ platform = DotNetPlatform.getInstance();

            /*DOTNETONLY*/ /*JAVAONLY*/ }

//        System.err.println(platform.getClass().getName());

    }

    /**

     * Create a non-schema-aware configuration object with default settings for all options.

     *

     * @since 8.4

     */

    public Configuration() {

        init();

    }

    /**

     * Factory method to create a Configuration. The resulting configuration will be schema-aware if

     * Saxon-SA is installed and if a license is available; otherwise it will be non-schema-aware.

     * Note that the license might not permit all processing options.

     *

     * @param classLoader - the class loader to be used. If null, the context class loader for the current

     *                    thread is used.

     * @param className   - the name of the schema aware configuration class. Defaults to

     *                    "com.saxonica.validate.SchemaAwareConfiguration" if null is supplied. This allows an assembly

     *                    qualified name to be supplied under .NET. The class, once instantiated, must be an instance

     *                    of Configuration, but despite the name of this method there is nothing that requires it to

     *                    be schema-aware.

     * @return a schema-aware configuration object if Saxon-SA can be loaded and a valid license is

     *         installed; otherwise, a non-schema-aware configuration object

     * @since 9.0