bundles/org.eclipse.wst.xsl.core/src_validation/org/eclipse/wst/xsl/core/internal/compiler/xslt10/extensions/ObjectFactory.java - sourceediting/webtools.sourceediting.xsl - Git at Google

 /*******************************************************************************
  * Copyright (c) 2007 Standards for Technology in Automotive Retail
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     David Carver - STAR - bug 224197 - initial API and implementation
  *                    based on work from Apache Xalan 2.7.0
  *******************************************************************************/

 /*
  * Copyright 2001-2004 The Apache Software Foundation.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 /*
  * $Id: ObjectFactory.java,v 1.2 2008/03/28 02:38:18 dacarver Exp $
  */

 package org.eclipse.wst.xsl.core.internal.compiler.xslt10.extensions;

 import java.io.InputStream;
 import java.io.IOException;
 import java.io.File;
 import java.io.FileInputStream;

 import java.util.Properties;
 import java.io.BufferedReader;
 import java.io.InputStreamReader;

 /**
  * This class is duplicated for each JAXP subpackage so keep it in sync. It is
  * package private and therefore is not exposed as part of the JAXP API.
  * <p>
  * This code is designed to implement the JAXP 1.1 spec pluggability feature and
  * is designed to run on JDK version 1.1 and later, and to compile on JDK 1.2
  * and onward. The code also runs both as part of an unbundled jar file and when
  * bundled as part of the JDK.
  * <p>
  * This class was moved from the <code>javax.xml.parsers.ObjectFactory</code>
  * class and modified to be used as a general utility for creating objects
  * dynamically.
  *
  * @version $Id: ObjectFactory.java,v 1.2 2008/03/28 02:38:18 dacarver Exp $
  */
 class ObjectFactory {

 	//
 	// Constants
 	//

 	// name of default properties file to look for in JDK's jre/lib directory
 	private static final String DEFAULT_PROPERTIES_FILENAME = "xalan.properties";

 	private static final String SERVICES_PATH = "META-INF/services/";

 	/** Set to true for debugging */
 	private static final boolean DEBUG = false;

 	/**
 	 * cache the contents of the xalan.properties file. Until an attempt has
 	 * been made to read this file, this will be null; if the file does not
 	 * exist or we encounter some other error during the read, this will be
 	 * empty.
 	 */
 	private static Properties fXalanProperties = null;

 	/***************************************************************************
 	 * Cache the time stamp of the xalan.properties file so that we know if it's
 	 * been modified and can invalidate the cache when necessary.
 	 */
 	private static long fLastModified = -1;

 	//
 	// Public static methods
 	//

 	/**
 	 * Finds the implementation Class object in the specified order. The
 	 * specified order is the following:
 	 * <ol>
 	 * <li>query the system property using <code>System.getProperty</code>
 	 * <li>read <code>META-INF/services/<i>factoryId</i></code> file
 	 * <li>use fallback classname
 	 * </ol>
 	 *
 	 * @return instance of factory, never null
 	 *
 	 * @param factoryId
 	 *            Name of the factory to find, same as a property name
 	 * @param fallbackClassName
 	 *            Implementation class name, if nothing else is found. Use null
 	 *            to mean no fallback.
 	 *
 	 * @exception ObjectFactory.ConfigurationError
 	 */
 	static Object createObject(String factoryId, String fallbackClassName)
 			throws ConfigurationError {
 		return createObject(factoryId, null, fallbackClassName);
 	} // createObject(String,String):Object

 	/**
 	 * Finds the implementation Class object in the specified order. The
 	 * specified order is the following:
 	 * <ol>
 	 * <li>query the system property using <code>System.getProperty</code>
 	 * <li>read <code>$java.home/lib/<i>propertiesFilename</i></code> file
 	 * <li>read <code>META-INF/services/<i>factoryId</i></code> file
 	 * <li>use fallback classname
 	 * </ol>
 	 *
 	 * @return instance of factory, never null
 	 *
 	 * @param factoryId
 	 *            Name of the factory to find, same as a property name
 	 * @param propertiesFilename
 	 *            The filename in the $java.home/lib directory of the properties
 	 *            file. If none specified, ${java.home}/lib/xalan.properties
 	 *            will be used.
 	 * @param fallbackClassName
 	 *            Implementation class name, if nothing else is found. Use null
 	 *            to mean no fallback.
 	 *
 	 * @exception ObjectFactory.ConfigurationError
 	 */
 	static Object createObject(String factoryId, String propertiesFilename,
 			String fallbackClassName) throws ConfigurationError {
 		Class factoryClass = lookUpFactoryClass(factoryId, propertiesFilename,
 				fallbackClassName);

 		if (factoryClass == null) {
 			throw new ConfigurationError("Provider for " + factoryId
 					+ " cannot be found", null);
 		}

 		try {
 			Object instance = factoryClass.newInstance();
 			debugPrintln("created new instance of factory " + factoryId);
 			return instance;
 		} catch (Exception x) {
 			throw new ConfigurationError("Provider for factory " + factoryId
 					+ " could not be instantiated: " + x, x);
 		}
 	} // createObject(String,String,String):Object

 	/**
 	 * Finds the implementation Class object in the specified order. The
 	 * specified order is the following:
 	 * <ol>
 	 * <li>query the system property using <code>System.getProperty</code>
 	 * <li>read <code>$java.home/lib/<i>propertiesFilename</i></code> file
 	 * <li>read <code>META-INF/services/<i>factoryId</i></code> file
 	 * <li>use fallback classname
 	 * </ol>
 	 *
 	 * @return Class object of factory, never null
 	 *
 	 * @param factoryId
 	 *            Name of the factory to find, same as a property name
 	 * @param propertiesFilename
 	 *            The filename in the $java.home/lib directory of the properties
 	 *            file. If none specified, ${java.home}/lib/xalan.properties
 	 *            will be used.
 	 * @param fallbackClassName
 	 *            Implementation class name, if nothing else is found. Use null
 	 *            to mean no fallback.
 	 *
 	 * @exception ObjectFactory.ConfigurationError
 	 */
 	static Class lookUpFactoryClass(String factoryId) throws ConfigurationError {
 		return lookUpFactoryClass(factoryId, null, null);
 	} // lookUpFactoryClass(String):Class

 	/**
 	 * Finds the implementation Class object in the specified order. The
 	 * specified order is the following:
 	 * <ol>
 	 * <li>query the system property using <code>System.getProperty</code>
 	 * <li>read <code>$java.home/lib/<i>propertiesFilename</i></code> file
 	 * <li>read <code>META-INF/services/<i>factoryId</i></code> file
 	 * <li>use fallback classname
 	 * </ol>
 	 *
 	 * @return Class object that provides factory service, never null
 	 *
 	 * @param factoryId
 	 *            Name of the factory to find, same as a property name
 	 * @param propertiesFilename
 	 *            The filename in the $java.home/lib directory of the properties
 	 *            file. If none specified, ${java.home}/lib/xalan.properties
 	 *            will be used.
 	 * @param fallbackClassName
 	 *            Implementation class name, if nothing else is found. Use null
 	 *            to mean no fallback.
 	 *
 	 * @exception ObjectFactory.ConfigurationError
 	 */
 	static Class lookUpFactoryClass(String factoryId,
 			String propertiesFilename, String fallbackClassName)
 			throws ConfigurationError {
 		String factoryClassName = lookUpFactoryClassName(factoryId,
 				propertiesFilename, fallbackClassName);
 		ClassLoader cl = findClassLoader();

 		if (factoryClassName == null) {
 			factoryClassName = fallbackClassName;
 		}

 		// assert(className != null);
 		try {
 			Class providerClass = findProviderClass(factoryClassName, cl, true);
 			debugPrintln("created new instance of " + providerClass
 					+ " using ClassLoader: " + cl);
 			return providerClass;
 		} catch (ClassNotFoundException x) {
 			throw new ConfigurationError("Provider " + factoryClassName
 					+ " not found", x);
 		} catch (Exception x) {
 			throw new ConfigurationError("Provider " + factoryClassName
 					+ " could not be instantiated: " + x, x);
 		}
 	} // lookUpFactoryClass(String,String,String):Class

 	/**
 	 * Finds the name of the required implementation class in the specified
 	 * order. The specified order is the following:
 	 * <ol>
 	 * <li>query the system property using <code>System.getProperty</code>
 	 * <li>read <code>$java.home/lib/<i>propertiesFilename</i></code> file
 	 * <li>read <code>META-INF/services/<i>factoryId</i></code> file
 	 * <li>use fallback classname
 	 * </ol>
 	 *
 	 * @return name of class that provides factory service, never null
 	 *
 	 * @param factoryId
 	 *            Name of the factory to find, same as a property name
 	 * @param propertiesFilename
 	 *            The filename in the $java.home/lib directory of the properties
 	 *            file. If none specified, ${java.home}/lib/xalan.properties
 	 *            will be used.
 	 * @param fallbackClassName
 	 *            Implementation class name, if nothing else is found. Use null
 	 *            to mean no fallback.
 	 *
 	 * @exception ObjectFactory.ConfigurationError
 	 */
 	static String lookUpFactoryClassName(String factoryId,
 			String propertiesFilename, String fallbackClassName) {
 		SecuritySupport ss = SecuritySupport.getInstance();

 		// Use the system property first
 		try {
 			String systemProp = ss.getSystemProperty(factoryId);
 			if (systemProp != null) {
 				debugPrintln("found system property, value=" + systemProp);
 				return systemProp;
 			}
 		} catch (SecurityException se) {
 			// Ignore and continue w/ next location
 		}

 		// Try to read from propertiesFilename, or
 		// $java.home/lib/xalan.properties
 		String factoryClassName = null;
 		// no properties file name specified; use
 		// $JAVA_HOME/lib/xalan.properties:
 		if (propertiesFilename == null) {
 			File propertiesFile = null;
 			boolean propertiesFileExists = false;
 			try {
 				String javah = ss.getSystemProperty("java.home");
 				propertiesFilename = javah + File.separator + "lib"
 						+ File.separator + DEFAULT_PROPERTIES_FILENAME;
 				propertiesFile = new File(propertiesFilename);
 				propertiesFileExists = ss.getFileExists(propertiesFile);
 			} catch (SecurityException e) {
 				// try again...
 				fLastModified = -1;
 				fXalanProperties = null;
 			}

 			synchronized (ObjectFactory.class) {
 				boolean loadProperties = false;
 				FileInputStream fis = null;
 				try {
 					// file existed last time
 					if (fLastModified >= 0) {
 						if (propertiesFileExists
 								&& (fLastModified < (fLastModified = ss
 										.getLastModified(propertiesFile)))) {
 							loadProperties = true;
 						} else {
 							// file has stopped existing...
 							if (!propertiesFileExists) {
 								fLastModified = -1;
 								fXalanProperties = null;
 							} // else, file wasn't modified!
 						}
 					} else {
 						// file has started to exist:
 						if (propertiesFileExists) {
 							loadProperties = true;
 							fLastModified = ss.getLastModified(propertiesFile);
 						} // else, nothing's changed
 					}
 					if (loadProperties) {
 						// must never have attempted to read xalan.properties
 						// before (or it's outdeated)
 						fXalanProperties = new Properties();
 						fis = ss.getFileInputStream(propertiesFile);
 						fXalanProperties.load(fis);
 					}
 				} catch (Exception x) {
 					fXalanProperties = null;
 					fLastModified = -1;
 					// assert(x instanceof FileNotFoundException
 					// || x instanceof SecurityException)
 					// In both cases, ignore and continue w/ next location
 				} finally {
 					// try to close the input stream if one was opened.
 					if (fis != null) {
 						try {
 							fis.close();
 						}
 						// Ignore the exception.
 						catch (IOException exc) {
 						}
 					}
 				}
 			}
 			if (fXalanProperties != null) {
 				factoryClassName = fXalanProperties.getProperty(factoryId);
 			}
 		} else {
 			FileInputStream fis = null;
 			try {
 				fis = ss.getFileInputStream(new File(propertiesFilename));
 				Properties props = new Properties();
 				props.load(fis);
 				factoryClassName = props.getProperty(factoryId);
 			} catch (Exception x) {
 				// assert(x instanceof FileNotFoundException
 				// || x instanceof SecurityException)
 				// In both cases, ignore and continue w/ next location
 			} finally {
 				// try to close the input stream if one was opened.
 				if (fis != null) {
 					try {
 						fis.close();
 					}
 					// Ignore the exception.
 					catch (IOException exc) {
 					}
 				}
 			}
 		}
 		if (factoryClassName != null) {
 			debugPrintln("found in " + propertiesFilename + ", value="
 					+ factoryClassName);
 			return factoryClassName;
 		}

 		// Try Jar Service Provider Mechanism
 		return findJarServiceProviderName(factoryId);
 	} // lookUpFactoryClass(String,String):String

 	//
 	// Private static methods
 	//

 	/** Prints a message to standard error if debugging is enabled. */
 	private static void debugPrintln(String msg) {
 		if (DEBUG) {
 			System.err.println("JAXP: " + msg);
 		}
 	} // debugPrintln(String)

 	/**
 	 * Figure out which ClassLoader to use. For JDK 1.2 and later use the
 	 * context ClassLoader.
 	 */
 	static ClassLoader findClassLoader() throws ConfigurationError {
 		SecuritySupport ss = SecuritySupport.getInstance();

 		// Figure out which ClassLoader to use for loading the provider
 		// class. If there is a Context ClassLoader then use it.
 		ClassLoader context = ss.getContextClassLoader();
 		ClassLoader system = ss.getSystemClassLoader();

 		ClassLoader chain = system;
 		while (true) {
 			if (context == chain) {
 				// Assert: we are on JDK 1.1 or we have no Context ClassLoader
 				// or any Context ClassLoader in chain of system classloader
 				// (including extension ClassLoader) so extend to widest
 				// ClassLoader (always look in system ClassLoader if Xalan
 				// is in boot/extension/system classpath and in current
 				// ClassLoader otherwise); normal classloaders delegate
 				// back to system ClassLoader first so this widening doesn't
 				// change the fact that context ClassLoader will be consulted
 				ClassLoader current = ObjectFactory.class.getClassLoader();

 				chain = system;
 				while (true) {
 					if (current == chain) {
 						// Assert: Current ClassLoader in chain of
 						// boot/extension/system ClassLoaders
 						return system;
 					}
 					if (chain == null) {
 						break;
 					}
 					chain = ss.getParentClassLoader(chain);
 				}

 				// Assert: Current ClassLoader not in chain of
 				// boot/extension/system ClassLoaders
 				return current;
 			}

 			if (chain == null) {
 				// boot ClassLoader reached
 				break;
 			}

 			// Check for any extension ClassLoaders in chain up to
 			// boot ClassLoader
 			chain = ss.getParentClassLoader(chain);
 		}
 		;

 		// Assert: Context ClassLoader not in chain of
 		// boot/extension/system ClassLoaders
 		return context;
 	} // findClassLoader():ClassLoader

 	/**
 	 * Create an instance of a class using the specified ClassLoader
 	 */
 	static Object newInstance(String className, ClassLoader cl,
 			boolean doFallback) throws ConfigurationError {
 		// assert(className != null);
 		try {
 			Class providerClass = findProviderClass(className, cl, doFallback);
 			Object instance = providerClass.newInstance();
 			debugPrintln("created new instance of " + providerClass
 					+ " using ClassLoader: " + cl);
 			return instance;
 		} catch (ClassNotFoundException x) {
 			throw new ConfigurationError(
 					"Provider " + className + " not found", x);
 		} catch (Exception x) {
 			throw new ConfigurationError("Provider " + className
 					+ " could not be instantiated: " + x, x);
 		}
 	}

 	/**
 	 * Find a Class using the specified ClassLoader
 	 */
 	static Class findProviderClass(String className, ClassLoader cl,
 			boolean doFallback) throws ClassNotFoundException,
 			ConfigurationError {
 		// throw security exception if the calling thread is not allowed to
 		// access the
 		// class. Restrict the access to the package classes as specified in
 		// java.security policy.
 		SecurityManager security = System.getSecurityManager();
 		try {
 			if (security != null) {
 				final int lastDot = className.lastIndexOf(".");
 				String packageName = className;
 				if (lastDot != -1)
 					packageName = className.substring(0, lastDot);
 				security.checkPackageAccess(packageName);
 			}
 		} catch (SecurityException e) {
 			throw e;
 		}

 		Class providerClass;
 		if (cl == null) {
 			// XXX Use the bootstrap ClassLoader. There is no way to
 			// load a class using the bootstrap ClassLoader that works
 			// in both JDK 1.1 and Java 2. However, this should still
 			// work b/c the following should be true:
 			//
 			// (cl == null) iff current ClassLoader == null
 			//
 			// Thus Class.forName(String) will use the current
 			// ClassLoader which will be the bootstrap ClassLoader.
 			providerClass = Class.forName(className);
 		} else {
 			try {
 				providerClass = cl.loadClass(className);
 			} catch (ClassNotFoundException x) {
 				if (doFallback) {
 					// Fall back to current classloader
 					ClassLoader current = ObjectFactory.class.getClassLoader();
 					if (current == null) {
 						providerClass = Class.forName(className);
 					} else if (cl != current) {
 						cl = current;
 						providerClass = cl.loadClass(className);
 					} else {
 						throw x;
 					}
 				} else {
 					throw x;
 				}
 			}
 		}

 		return providerClass;
 	}

 	/**
 	 * Find the name of service provider using Jar Service Provider Mechanism
 	 *
 	 * @return instance of provider class if found or null
 	 */
 	private static String findJarServiceProviderName(String factoryId) {
 		SecuritySupport ss = SecuritySupport.getInstance();
 		String serviceId = SERVICES_PATH + factoryId;
 		InputStream is = null;

 		// First try the Context ClassLoader
 		ClassLoader cl = findClassLoader();

 		is = ss.getResourceAsStream(cl, serviceId);

 		// If no provider found then try the current ClassLoader
 		if (is == null) {
 			ClassLoader current = ObjectFactory.class.getClassLoader();
 			if (cl != current) {
 				cl = current;
 				is = ss.getResourceAsStream(cl, serviceId);
 			}
 		}

 		if (is == null) {
 			// No provider found
 			return null;
 		}

 		debugPrintln("found jar resource=" + serviceId + " using ClassLoader: "
 				+ cl);

 		// Read the service provider name in UTF-8 as specified in
 		// the jar spec. Unfortunately this fails in Microsoft
 		// VJ++, which does not implement the UTF-8
 		// encoding. Theoretically, we should simply let it fail in
 		// that case, since the JVM is obviously broken if it
 		// doesn't support such a basic standard. But since there
 		// are still some users attempting to use VJ++ for
 		// development, we have dropped in a fallback which makes a
 		// second attempt using the platform's default encoding. In
 		// VJ++ this is apparently ASCII, which is a subset of
 		// UTF-8... and since the strings we'll be reading here are
 		// also primarily limited to the 7-bit ASCII range (at
 		// least, in English versions), this should work well
 		// enough to keep us on the air until we're ready to
 		// officially decommit from VJ++. [Edited comment from
 		// jkesselm]
 		BufferedReader rd;
 		try {
 			rd = new BufferedReader(new InputStreamReader(is, "UTF-8"));
 		} catch (java.io.UnsupportedEncodingException e) {
 			rd = new BufferedReader(new InputStreamReader(is));
 		}

 		String factoryClassName = null;
 		try {
 			// XXX Does not handle all possible input as specified by the
 			// Jar Service Provider specification
 			factoryClassName = rd.readLine();
 		} catch (IOException x) {
 			// No provider found
 			return null;
 		} finally {
 			try {
 				// try to close the reader.
 				rd.close();
 			}
 			// Ignore the exception.
 			catch (IOException exc) {
 			}
 		}

 		if (factoryClassName != null && !"".equals(factoryClassName)) {
 			debugPrintln("found in resource, value=" + factoryClassName);

 			// Note: here we do not want to fall back to the current
 			// ClassLoader because we want to avoid the case where the
 			// resource file was found using one ClassLoader and the
 			// provider class was instantiated using a different one.
 			return factoryClassName;
 		}

 		// No provider found
 		return null;
 	}

 	//
 	// Classes
 	//

 	/**
 	 * A configuration error.
 	 */
 	static class ConfigurationError extends Error {
 		static final long serialVersionUID = 8564305128443551853L;
 		//
 		// Data
 		//

 		/** Exception. */
 		private Exception exception;

 		//
 		// Constructors
 		//

 		/**
 		 * Construct a new instance with the specified detail string and
 		 * exception.
 		 */
 		ConfigurationError(String msg, Exception x) {
 			super(msg);
 			this.exception = x;
 		} // <init>(String,Exception)

 		//
 		// Public methods
 		//

 		/** Returns the exception associated to this error. */
 		Exception getException() {
 			return exception;
 		} // getException():Exception

 	} // class ConfigurationError

 } // class ObjectFactory
	/*******************************************************************************
	* Copyright (c) 2007 Standards for Technology in Automotive Retail
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* David Carver - STAR - bug 224197 - initial API and implementation
	* based on work from Apache Xalan 2.7.0
	*******************************************************************************/

	/*
	* Copyright 2001-2004 The Apache Software Foundation.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	/*
	* $Id: ObjectFactory.java,v 1.2 2008/03/28 02:38:18 dacarver Exp $
	*/

	package org.eclipse.wst.xsl.core.internal.compiler.xslt10.extensions;

	import java.io.InputStream;
	import java.io.IOException;
	import java.io.File;
	import java.io.FileInputStream;

	import java.util.Properties;
	import java.io.BufferedReader;
	import java.io.InputStreamReader;

	/**
	* This class is duplicated for each JAXP subpackage so keep it in sync. It is
	* package private and therefore is not exposed as part of the JAXP API.
	* <p>
	* This code is designed to implement the JAXP 1.1 spec pluggability feature and
	* is designed to run on JDK version 1.1 and later, and to compile on JDK 1.2
	* and onward. The code also runs both as part of an unbundled jar file and when
	* bundled as part of the JDK.
	* <p>
	* This class was moved from the <code>javax.xml.parsers.ObjectFactory</code>
	* class and modified to be used as a general utility for creating objects
	* dynamically.
	*
	* @version $Id: ObjectFactory.java,v 1.2 2008/03/28 02:38:18 dacarver Exp $
	*/
	class ObjectFactory {

	//
	// Constants
	//

	// name of default properties file to look for in JDK's jre/lib directory
	private static final String DEFAULT_PROPERTIES_FILENAME = "xalan.properties";

	private static final String SERVICES_PATH = "META-INF/services/";

	/** Set to true for debugging */
	private static final boolean DEBUG = false;

	/**
	* cache the contents of the xalan.properties file. Until an attempt has
	* been made to read this file, this will be null; if the file does not
	* exist or we encounter some other error during the read, this will be
	* empty.
	*/
	private static Properties fXalanProperties = null;

	/***************************************************************************
	* Cache the time stamp of the xalan.properties file so that we know if it's
	* been modified and can invalidate the cache when necessary.
	*/
	private static long fLastModified = -1;

	//
	// Public static methods
	//

	/**
	* Finds the implementation Class object in the specified order. The
	* specified order is the following:
	* <ol>
	* <li>query the system property using <code>System.getProperty</code>
	* <li>read <code>META-INF/services/<i>factoryId</i></code> file
	* <li>use fallback classname
	* </ol>
	*
	* @return instance of factory, never null
	*
	* @param factoryId
	* Name of the factory to find, same as a property name
	* @param fallbackClassName
	* Implementation class name, if nothing else is found. Use null
	* to mean no fallback.
	*
	* @exception ObjectFactory.ConfigurationError
	*/
	static Object createObject(String factoryId, String fallbackClassName)
	throws ConfigurationError {
	return createObject(factoryId, null, fallbackClassName);
	} // createObject(String,String):Object

	/**
	* Finds the implementation Class object in the specified order. The
	* specified order is the following:
	* <ol>
	* <li>query the system property using <code>System.getProperty</code>
	* <li>read <code>$java.home/lib/<i>propertiesFilename</i></code> file
	* <li>read <code>META-INF/services/<i>factoryId</i></code> file
	* <li>use fallback classname
	* </ol>
	*
	* @return instance of factory, never null
	*
	* @param factoryId
	* Name of the factory to find, same as a property name
	* @param propertiesFilename
	* The filename in the $java.home/lib directory of the properties
	* file. If none specified, ${java.home}/lib/xalan.properties
	* will be used.
	* @param fallbackClassName
	* Implementation class name, if nothing else is found. Use null
	* to mean no fallback.
	*
	* @exception ObjectFactory.ConfigurationError
	*/
	static Object createObject(String factoryId, String propertiesFilename,
	String fallbackClassName) throws ConfigurationError {
	Class factoryClass = lookUpFactoryClass(factoryId, propertiesFilename,
	fallbackClassName);

	if (factoryClass == null) {
	throw new ConfigurationError("Provider for " + factoryId
	+ " cannot be found", null);
	}

	try {
	Object instance = factoryClass.newInstance();
	debugPrintln("created new instance of factory " + factoryId);
	return instance;
	} catch (Exception x) {
	throw new ConfigurationError("Provider for factory " + factoryId
	+ " could not be instantiated: " + x, x);
	}
	} // createObject(String,String,String):Object

	/**
	* Finds the implementation Class object in the specified order. The
	* specified order is the following:
	* <ol>
	* <li>query the system property using <code>System.getProperty</code>
	* <li>read <code>$java.home/lib/<i>propertiesFilename</i></code> file
	* <li>read <code>META-INF/services/<i>factoryId</i></code> file
	* <li>use fallback classname
	* </ol>
	*
	* @return Class object of factory, never null
	*
	* @param factoryId
	* Name of the factory to find, same as a property name
	* @param propertiesFilename
	* The filename in the $java.home/lib directory of the properties
	* file. If none specified, ${java.home}/lib/xalan.properties
	* will be used.
	* @param fallbackClassName
	* Implementation class name, if nothing else is found. Use null
	* to mean no fallback.
	*
	* @exception ObjectFactory.ConfigurationError
	*/
	static Class lookUpFactoryClass(String factoryId) throws ConfigurationError {
	return lookUpFactoryClass(factoryId, null, null);
	} // lookUpFactoryClass(String):Class

	/**
	* Finds the implementation Class object in the specified order. The
	* specified order is the following:
	* <ol>
	* <li>query the system property using <code>System.getProperty</code>
	* <li>read <code>$java.home/lib/<i>propertiesFilename</i></code> file
	* <li>read <code>META-INF/services/<i>factoryId</i></code> file
	* <li>use fallback classname
	* </ol>
	*
	* @return Class object that provides factory service, never null
	*
	* @param factoryId
	* Name of the factory to find, same as a property name
	* @param propertiesFilename
	* The filename in the $java.home/lib directory of the properties
	* file. If none specified, ${java.home}/lib/xalan.properties
	* will be used.
	* @param fallbackClassName
	* Implementation class name, if nothing else is found. Use null
	* to mean no fallback.
	*
	* @exception ObjectFactory.ConfigurationError
	*/
	static Class lookUpFactoryClass(String factoryId,
	String propertiesFilename, String fallbackClassName)
	throws ConfigurationError {
	String factoryClassName = lookUpFactoryClassName(factoryId,
	propertiesFilename, fallbackClassName);
	ClassLoader cl = findClassLoader();

	if (factoryClassName == null) {
	factoryClassName = fallbackClassName;
	}

	// assert(className != null);
	try {
	Class providerClass = findProviderClass(factoryClassName, cl, true);
	debugPrintln("created new instance of " + providerClass
	+ " using ClassLoader: " + cl);
	return providerClass;
	} catch (ClassNotFoundException x) {
	throw new ConfigurationError("Provider " + factoryClassName
	+ " not found", x);
	} catch (Exception x) {
	throw new ConfigurationError("Provider " + factoryClassName
	+ " could not be instantiated: " + x, x);
	}
	} // lookUpFactoryClass(String,String,String):Class

	/**
	* Finds the name of the required implementation class in the specified
	* order. The specified order is the following:
	* <ol>
	* <li>query the system property using <code>System.getProperty</code>
	* <li>read <code>$java.home/lib/<i>propertiesFilename</i></code> file
	* <li>read <code>META-INF/services/<i>factoryId</i></code> file
	* <li>use fallback classname
	* </ol>
	*
	* @return name of class that provides factory service, never null
	*
	* @param factoryId
	* Name of the factory to find, same as a property name
	* @param propertiesFilename
	* The filename in the $java.home/lib directory of the properties
	* file. If none specified, ${java.home}/lib/xalan.properties
	* will be used.
	* @param fallbackClassName
	* Implementation class name, if nothing else is found. Use null
	* to mean no fallback.
	*
	* @exception ObjectFactory.ConfigurationError
	*/
	static String lookUpFactoryClassName(String factoryId,
	String propertiesFilename, String fallbackClassName) {
	SecuritySupport ss = SecuritySupport.getInstance();

	// Use the system property first
	try {
	String systemProp = ss.getSystemProperty(factoryId);
	if (systemProp != null) {
	debugPrintln("found system property, value=" + systemProp);
	return systemProp;
	}
	} catch (SecurityException se) {
	// Ignore and continue w/ next location
	}

	// Try to read from propertiesFilename, or
	// $java.home/lib/xalan.properties
	String factoryClassName = null;
	// no properties file name specified; use
	// $JAVA_HOME/lib/xalan.properties:
	if (propertiesFilename == null) {
	File propertiesFile = null;
	boolean propertiesFileExists = false;
	try {
	String javah = ss.getSystemProperty("java.home");
	propertiesFilename = javah + File.separator + "lib"
	+ File.separator + DEFAULT_PROPERTIES_FILENAME;
	propertiesFile = new File(propertiesFilename);
	propertiesFileExists = ss.getFileExists(propertiesFile);
	} catch (SecurityException e) {
	// try again...
	fLastModified = -1;
	fXalanProperties = null;
	}

	synchronized (ObjectFactory.class) {
	boolean loadProperties = false;
	FileInputStream fis = null;
	try {
	// file existed last time
	if (fLastModified >= 0) {
	if (propertiesFileExists
	&& (fLastModified < (fLastModified = ss
	.getLastModified(propertiesFile)))) {
	loadProperties = true;
	} else {
	// file has stopped existing...
	if (!propertiesFileExists) {
	fLastModified = -1;
	fXalanProperties = null;
	} // else, file wasn't modified!
	}
	} else {
	// file has started to exist:
	if (propertiesFileExists) {
	loadProperties = true;
	fLastModified = ss.getLastModified(propertiesFile);
	} // else, nothing's changed
	}
	if (loadProperties) {
	// must never have attempted to read xalan.properties
	// before (or it's outdeated)
	fXalanProperties = new Properties();
	fis = ss.getFileInputStream(propertiesFile);
	fXalanProperties.load(fis);
	}
	} catch (Exception x) {
	fXalanProperties = null;
	fLastModified = -1;
	// assert(x instanceof FileNotFoundException
	// \|\| x instanceof SecurityException)
	// In both cases, ignore and continue w/ next location
	} finally {
	// try to close the input stream if one was opened.
	if (fis != null) {
	try {
	fis.close();
	}
	// Ignore the exception.
	catch (IOException exc) {
	}
	}
	}
	}
	if (fXalanProperties != null) {
	factoryClassName = fXalanProperties.getProperty(factoryId);
	}
	} else {
	FileInputStream fis = null;
	try {
	fis = ss.getFileInputStream(new File(propertiesFilename));
	Properties props = new Properties();
	props.load(fis);
	factoryClassName = props.getProperty(factoryId);
	} catch (Exception x) {
	// assert(x instanceof FileNotFoundException
	// \|\| x instanceof SecurityException)
	// In both cases, ignore and continue w/ next location
	} finally {
	// try to close the input stream if one was opened.
	if (fis != null) {
	try {
	fis.close();
	}
	// Ignore the exception.
	catch (IOException exc) {
	}
	}
	}
	}
	if (factoryClassName != null) {
	debugPrintln("found in " + propertiesFilename + ", value="
	+ factoryClassName);
	return factoryClassName;
	}

	// Try Jar Service Provider Mechanism
	return findJarServiceProviderName(factoryId);
	} // lookUpFactoryClass(String,String):String

	//
	// Private static methods
	//

	/** Prints a message to standard error if debugging is enabled. */
	private static void debugPrintln(String msg) {
	if (DEBUG) {
	System.err.println("JAXP: " + msg);
	}
	} // debugPrintln(String)

	/**
	* Figure out which ClassLoader to use. For JDK 1.2 and later use the
	* context ClassLoader.
	*/
	static ClassLoader findClassLoader() throws ConfigurationError {
	SecuritySupport ss = SecuritySupport.getInstance();

	// Figure out which ClassLoader to use for loading the provider
	// class. If there is a Context ClassLoader then use it.
	ClassLoader context = ss.getContextClassLoader();
	ClassLoader system = ss.getSystemClassLoader();

	ClassLoader chain = system;
	while (true) {
	if (context == chain) {
	// Assert: we are on JDK 1.1 or we have no Context ClassLoader
	// or any Context ClassLoader in chain of system classloader
	// (including extension ClassLoader) so extend to widest
	// ClassLoader (always look in system ClassLoader if Xalan
	// is in boot/extension/system classpath and in current
	// ClassLoader otherwise); normal classloaders delegate
	// back to system ClassLoader first so this widening doesn't
	// change the fact that context ClassLoader will be consulted
	ClassLoader current = ObjectFactory.class.getClassLoader();

	chain = system;
	while (true) {
	if (current == chain) {
	// Assert: Current ClassLoader in chain of
	// boot/extension/system ClassLoaders
	return system;
	}
	if (chain == null) {
	break;
	}
	chain = ss.getParentClassLoader(chain);
	}

	// Assert: Current ClassLoader not in chain of
	// boot/extension/system ClassLoaders
	return current;
	}

	if (chain == null) {
	// boot ClassLoader reached
	break;
	}

	// Check for any extension ClassLoaders in chain up to
	// boot ClassLoader
	chain = ss.getParentClassLoader(chain);
	}
	;

	// Assert: Context ClassLoader not in chain of
	// boot/extension/system ClassLoaders
	return context;
	} // findClassLoader():ClassLoader

	/**
	* Create an instance of a class using the specified ClassLoader
	*/
	static Object newInstance(String className, ClassLoader cl,
	boolean doFallback) throws ConfigurationError {
	// assert(className != null);
	try {
	Class providerClass = findProviderClass(className, cl, doFallback);
	Object instance = providerClass.newInstance();
	debugPrintln("created new instance of " + providerClass
	+ " using ClassLoader: " + cl);
	return instance;
	} catch (ClassNotFoundException x) {
	throw new ConfigurationError(
	"Provider " + className + " not found", x);
	} catch (Exception x) {
	throw new ConfigurationError("Provider " + className
	+ " could not be instantiated: " + x, x);
	}
	}

	/**
	* Find a Class using the specified ClassLoader
	*/
	static Class findProviderClass(String className, ClassLoader cl,
	boolean doFallback) throws ClassNotFoundException,
	ConfigurationError {
	// throw security exception if the calling thread is not allowed to
	// access the
	// class. Restrict the access to the package classes as specified in
	// java.security policy.
	SecurityManager security = System.getSecurityManager();
	try {
	if (security != null) {
	final int lastDot = className.lastIndexOf(".");
	String packageName = className;
	if (lastDot != -1)
	packageName = className.substring(0, lastDot);
	security.checkPackageAccess(packageName);
	}
	} catch (SecurityException e) {
	throw e;
	}

	Class providerClass;
	if (cl == null) {
	// XXX Use the bootstrap ClassLoader. There is no way to
	// load a class using the bootstrap ClassLoader that works
	// in both JDK 1.1 and Java 2. However, this should still
	// work b/c the following should be true:
	//
	// (cl == null) iff current ClassLoader == null
	//
	// Thus Class.forName(String) will use the current
	// ClassLoader which will be the bootstrap ClassLoader.
	providerClass = Class.forName(className);
	} else {
	try {
	providerClass = cl.loadClass(className);
	} catch (ClassNotFoundException x) {
	if (doFallback) {
	// Fall back to current classloader
	ClassLoader current = ObjectFactory.class.getClassLoader();
	if (current == null) {
	providerClass = Class.forName(className);
	} else if (cl != current) {
	cl = current;
	providerClass = cl.loadClass(className);
	} else {
	throw x;
	}
	} else {
	throw x;
	}
	}
	}

	return providerClass;
	}

	/**
	* Find the name of service provider using Jar Service Provider Mechanism
	*
	* @return instance of provider class if found or null
	*/
	private static String findJarServiceProviderName(String factoryId) {
	SecuritySupport ss = SecuritySupport.getInstance();
	String serviceId = SERVICES_PATH + factoryId;
	InputStream is = null;

	// First try the Context ClassLoader
	ClassLoader cl = findClassLoader();

	is = ss.getResourceAsStream(cl, serviceId);

	// If no provider found then try the current ClassLoader
	if (is == null) {
	ClassLoader current = ObjectFactory.class.getClassLoader();
	if (cl != current) {
	cl = current;
	is = ss.getResourceAsStream(cl, serviceId);
	}
	}

	if (is == null) {
	// No provider found
	return null;
	}

	debugPrintln("found jar resource=" + serviceId + " using ClassLoader: "
	+ cl);

	// Read the service provider name in UTF-8 as specified in
	// the jar spec. Unfortunately this fails in Microsoft
	// VJ++, which does not implement the UTF-8
	// encoding. Theoretically, we should simply let it fail in
	// that case, since the JVM is obviously broken if it
	// doesn't support such a basic standard. But since there
	// are still some users attempting to use VJ++ for
	// development, we have dropped in a fallback which makes a
	// second attempt using the platform's default encoding. In
	// VJ++ this is apparently ASCII, which is a subset of
	// UTF-8... and since the strings we'll be reading here are
	// also primarily limited to the 7-bit ASCII range (at
	// least, in English versions), this should work well
	// enough to keep us on the air until we're ready to
	// officially decommit from VJ++. [Edited comment from
	// jkesselm]
	BufferedReader rd;
	try {
	rd = new BufferedReader(new InputStreamReader(is, "UTF-8"));
	} catch (java.io.UnsupportedEncodingException e) {
	rd = new BufferedReader(new InputStreamReader(is));
	}

	String factoryClassName = null;
	try {
	// XXX Does not handle all possible input as specified by the
	// Jar Service Provider specification
	factoryClassName = rd.readLine();
	} catch (IOException x) {
	// No provider found
	return null;
	} finally {
	try {
	// try to close the reader.
	rd.close();
	}
	// Ignore the exception.
	catch (IOException exc) {
	}
	}

	if (factoryClassName != null && !"".equals(factoryClassName)) {
	debugPrintln("found in resource, value=" + factoryClassName);

	// Note: here we do not want to fall back to the current
	// ClassLoader because we want to avoid the case where the
	// resource file was found using one ClassLoader and the
	// provider class was instantiated using a different one.
	return factoryClassName;
	}

	// No provider found
	return null;
	}

	//
	// Classes
	//

	/**
	* A configuration error.
	*/
	static class ConfigurationError extends Error {
	static final long serialVersionUID = 8564305128443551853L;
	//
	// Data
	//

	/** Exception. */
	private Exception exception;

	//
	// Constructors
	//

	/**
	* Construct a new instance with the specified detail string and
	* exception.
	*/
	ConfigurationError(String msg, Exception x) {
	super(msg);
	this.exception = x;
	} // <init>(String,Exception)

	//
	// Public methods
	//

	/** Returns the exception associated to this error. */
	Exception getException() {
	return exception;
	} // getException():Exception

	} // class ConfigurationError

	} // class ObjectFactory