diff -r 000000000000 -r 9a66ca7c79fa src/share/classes/javax/tools/ToolProvider.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/classes/javax/tools/ToolProvider.java Sat Dec 01 00:00:00 2007 +0000 @@ -0,0 +1,175 @@ +/* + * Copyright 2005-2006 Sun Microsystems, Inc. All Rights Reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Sun designates this + * particular file as subject to the "Classpath" exception as provided + * by Sun in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + */ + +package javax.tools; + +import java.io.File; +import java.net.URL; +import java.net.URLClassLoader; +import java.net.MalformedURLException; +import java.util.Locale; +import java.util.logging.Logger; +import java.util.logging.Level; +import static java.util.logging.Level.*; + +/** + * Provides methods for locating tool providers, for example, + * providers of compilers. This class complements the + * functionality of {@link java.util.ServiceLoader}. + * + * @author Peter von der Ahé + * @since 1.6 + */ +public class ToolProvider { + + private ToolProvider() {} + + private static final String propertyName = "sun.tools.ToolProvider"; + private static final String loggerName = "javax.tools"; + + /* + * Define the system property "sun.tools.ToolProvider" to enable + * debugging: + * + * java ... -Dsun.tools.ToolProvider ... + */ + static T trace(Level level, Object reason) { + // NOTE: do not make this method private as it affects stack traces + try { + if (System.getProperty(propertyName) != null) { + StackTraceElement[] st = Thread.currentThread().getStackTrace(); + String method = "???"; + String cls = ToolProvider.class.getName(); + if (st.length > 2) { + StackTraceElement frame = st[2]; + method = String.format((Locale)null, "%s(%s:%s)", + frame.getMethodName(), + frame.getFileName(), + frame.getLineNumber()); + cls = frame.getClassName(); + } + Logger logger = Logger.getLogger(loggerName); + if (reason instanceof Throwable) { + logger.logp(level, cls, method, + reason.getClass().getName(), (Throwable)reason); + } else { + logger.logp(level, cls, method, String.valueOf(reason)); + } + } + } catch (SecurityException ex) { + System.err.format((Locale)null, "%s: %s; %s%n", + ToolProvider.class.getName(), + reason, + ex.getLocalizedMessage()); + } + return null; + } + + /** + * Gets the Java™ programming language compiler provided + * with this platform. + * @return the compiler provided with this platform or + * {@code null} if no compiler is provided + */ + public static JavaCompiler getSystemJavaCompiler() { + if (Lazy.compilerClass == null) + return trace(WARNING, "Lazy.compilerClass == null"); + try { + return Lazy.compilerClass.newInstance(); + } catch (Throwable e) { + return trace(WARNING, e); + } + } + + /** + * Returns the class loader for tools provided with this platform. + * This does not include user-installed tools. Use the + * {@linkplain java.util.ServiceLoader service provider mechanism} + * for locating user installed tools. + * + * @return the class loader for tools provided with this platform + * or {@code null} if no tools are provided + */ + public static ClassLoader getSystemToolClassLoader() { + if (Lazy.compilerClass == null) + return trace(WARNING, "Lazy.compilerClass == null"); + return Lazy.compilerClass.getClassLoader(); + } + + /** + * This class will not be initialized until one of the above + * methods are called. This ensures that searching for the + * compiler does not affect platform start up. + */ + static class Lazy { + private static final String defaultJavaCompilerName + = "com.sun.tools.javac.api.JavacTool"; + private static final String[] defaultToolsLocation + = { "lib", "tools.jar" }; + static final Class compilerClass; + static { + Class c = null; + try { + c = findClass().asSubclass(JavaCompiler.class); + } catch (Throwable t) { + trace(WARNING, t); + } + compilerClass = c; + } + + private static Class findClass() + throws MalformedURLException, ClassNotFoundException + { + try { + return enableAsserts(Class.forName(defaultJavaCompilerName, false, null)); + } catch (ClassNotFoundException e) { + trace(FINE, e); + } + File file = new File(System.getProperty("java.home")); + if (file.getName().equalsIgnoreCase("jre")) + file = file.getParentFile(); + for (String name : defaultToolsLocation) + file = new File(file, name); + URL[] urls = {file.toURI().toURL()}; + trace(FINE, urls[0].toString()); + ClassLoader cl = URLClassLoader.newInstance(urls); + cl.setPackageAssertionStatus("com.sun.tools.javac", true); + return Class.forName(defaultJavaCompilerName, false, cl); + } + + private static Class enableAsserts(Class cls) { + try { + ClassLoader loader = cls.getClassLoader(); + if (loader != null) + loader.setPackageAssertionStatus("com.sun.tools.javac", true); + else + trace(FINE, "loader == null"); + } catch (SecurityException ex) { + trace(FINE, ex); + } + return cls; + } + } +}