700 lines
25 KiB
Java
700 lines
25 KiB
Java
/*
|
|
* Copyright (c) 1999, 2013, Oracle and/or its affiliates. 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. Oracle designates this
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
package com.sun.tools.javac.main;
|
|
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.io.PrintWriter;
|
|
import java.net.URL;
|
|
import java.security.DigestInputStream;
|
|
import java.security.MessageDigest;
|
|
import java.util.Arrays;
|
|
import java.util.Collection;
|
|
import java.util.Iterator;
|
|
import java.util.LinkedHashSet;
|
|
import java.util.Set;
|
|
|
|
import javax.annotation.processing.Processor;
|
|
import javax.tools.JavaFileManager;
|
|
import javax.tools.JavaFileObject;
|
|
|
|
import com.sun.source.util.JavacTask;
|
|
import com.sun.source.util.Plugin;
|
|
import com.sun.tools.doclint.DocLint;
|
|
import com.sun.tools.javac.api.BasicJavacTask;
|
|
import com.sun.tools.javac.code.Source;
|
|
import com.sun.tools.javac.file.CacheFSInfo;
|
|
import com.sun.tools.javac.file.JavacFileManager;
|
|
import com.sun.tools.javac.jvm.Profile;
|
|
import com.sun.tools.javac.jvm.Target;
|
|
import com.sun.tools.javac.processing.AnnotationProcessingError;
|
|
import com.sun.tools.javac.processing.JavacProcessingEnvironment;
|
|
import com.sun.tools.javac.util.*;
|
|
import com.sun.tools.javac.util.Log.PrefixKind;
|
|
import com.sun.tools.javac.util.Log.WriterKind;
|
|
import com.sun.tools.javac.util.ServiceLoader;
|
|
import static com.sun.tools.javac.main.Option.*;
|
|
|
|
/** This class provides a command line interface to the javac compiler.
|
|
*
|
|
* <p><b>This is NOT part of any supported API.
|
|
* If you write code that depends on this, you do so at your own risk.
|
|
* This code and its internal interfaces are subject to change or
|
|
* deletion without notice.</b>
|
|
*/
|
|
public class Main {
|
|
|
|
/** The name of the compiler, for use in diagnostics.
|
|
*/
|
|
String ownName;
|
|
|
|
/** The writer to use for diagnostic output.
|
|
*/
|
|
PrintWriter out;
|
|
|
|
/** The log to use for diagnostic output.
|
|
*/
|
|
public Log log;
|
|
|
|
/**
|
|
* If true, certain errors will cause an exception, such as command line
|
|
* arg errors, or exceptions in user provided code.
|
|
*/
|
|
boolean apiMode;
|
|
|
|
|
|
/** Result codes.
|
|
*/
|
|
public enum Result {
|
|
OK(0), // Compilation completed with no errors.
|
|
ERROR(1), // Completed but reported errors.
|
|
CMDERR(2), // Bad command-line arguments
|
|
SYSERR(3), // System error or resource exhaustion.
|
|
ABNORMAL(4); // Compiler terminated abnormally
|
|
|
|
Result(int exitCode) {
|
|
this.exitCode = exitCode;
|
|
}
|
|
|
|
public boolean isOK() {
|
|
return (exitCode == 0);
|
|
}
|
|
|
|
public final int exitCode;
|
|
}
|
|
|
|
private Option[] recognizedOptions =
|
|
Option.getJavaCompilerOptions().toArray(new Option[0]);
|
|
|
|
private OptionHelper optionHelper = new OptionHelper() {
|
|
@Override
|
|
public String get(Option option) {
|
|
return options.get(option);
|
|
}
|
|
|
|
@Override
|
|
public void put(String name, String value) {
|
|
options.put(name, value);
|
|
}
|
|
|
|
@Override
|
|
public void remove(String name) {
|
|
options.remove(name);
|
|
}
|
|
|
|
@Override
|
|
public Log getLog() {
|
|
return log;
|
|
}
|
|
|
|
@Override
|
|
public String getOwnName() {
|
|
return ownName;
|
|
}
|
|
|
|
@Override
|
|
public void error(String key, Object... args) {
|
|
Main.this.error(key, args);
|
|
}
|
|
|
|
@Override
|
|
public void addFile(File f) {
|
|
filenames.add(f);
|
|
}
|
|
|
|
@Override
|
|
public void addClassName(String s) {
|
|
classnames.append(s);
|
|
}
|
|
|
|
};
|
|
|
|
/**
|
|
* Construct a compiler instance.
|
|
*/
|
|
public Main(String name) {
|
|
this(name, new PrintWriter(System.err, true));
|
|
}
|
|
|
|
/**
|
|
* Construct a compiler instance.
|
|
*/
|
|
public Main(String name, PrintWriter out) {
|
|
this.ownName = name;
|
|
this.out = out;
|
|
}
|
|
|
|
/** A table of all options that's passed to the JavaCompiler constructor. */
|
|
private Options options = null;
|
|
|
|
/** The list of source files to process
|
|
*/
|
|
public Set<File> filenames = null; // XXX sb protected
|
|
|
|
/** List of class files names passed on the command line
|
|
*/
|
|
public ListBuffer<String> classnames = null; // XXX sb protected
|
|
|
|
/** Report a usage error.
|
|
*/
|
|
void error(String key, Object... args) {
|
|
if (apiMode) {
|
|
String msg = log.localize(PrefixKind.JAVAC, key, args);
|
|
throw new PropagatedException(new IllegalStateException(msg));
|
|
}
|
|
warning(key, args);
|
|
log.printLines(PrefixKind.JAVAC, "msg.usage", ownName);
|
|
}
|
|
|
|
/** Report a warning.
|
|
*/
|
|
void warning(String key, Object... args) {
|
|
log.printRawLines(ownName + ": " + log.localize(PrefixKind.JAVAC, key, args));
|
|
}
|
|
|
|
public Option getOption(String flag) {
|
|
for (Option option : recognizedOptions) {
|
|
if (option.matches(flag))
|
|
return option;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public void setOptions(Options options) {
|
|
if (options == null)
|
|
throw new NullPointerException();
|
|
this.options = options;
|
|
}
|
|
|
|
public void setAPIMode(boolean apiMode) {
|
|
this.apiMode = apiMode;
|
|
}
|
|
|
|
/** Process command line arguments: store all command line options
|
|
* in `options' table and return all source filenames.
|
|
* @param flags The array of command line arguments.
|
|
*/
|
|
public Collection<File> processArgs(String[] flags) { // XXX sb protected
|
|
return processArgs(flags, null);
|
|
}
|
|
|
|
public Collection<File> processArgs(String[] flags, String[] classNames) { // XXX sb protected
|
|
int ac = 0;
|
|
while (ac < flags.length) {
|
|
String flag = flags[ac];
|
|
ac++;
|
|
|
|
Option option = null;
|
|
|
|
if (flag.length() > 0) {
|
|
// quick hack to speed up file processing:
|
|
// if the option does not begin with '-', there is no need to check
|
|
// most of the compiler options.
|
|
int firstOptionToCheck = flag.charAt(0) == '-' ? 0 : recognizedOptions.length-1;
|
|
for (int j=firstOptionToCheck; j<recognizedOptions.length; j++) {
|
|
if (recognizedOptions[j].matches(flag)) {
|
|
option = recognizedOptions[j];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (option == null) {
|
|
error("err.invalid.flag", flag);
|
|
return null;
|
|
}
|
|
|
|
if (option.hasArg()) {
|
|
if (ac == flags.length) {
|
|
error("err.req.arg", flag);
|
|
return null;
|
|
}
|
|
String operand = flags[ac];
|
|
ac++;
|
|
if (option.process(optionHelper, flag, operand))
|
|
return null;
|
|
} else {
|
|
if (option.process(optionHelper, flag))
|
|
return null;
|
|
}
|
|
}
|
|
|
|
if (options.get(PROFILE) != null && options.get(BOOTCLASSPATH) != null) {
|
|
error("err.profile.bootclasspath.conflict");
|
|
return null;
|
|
}
|
|
|
|
if (this.classnames != null && classNames != null) {
|
|
this.classnames.addAll(Arrays.asList(classNames));
|
|
}
|
|
|
|
if (!checkDirectory(D))
|
|
return null;
|
|
if (!checkDirectory(S))
|
|
return null;
|
|
|
|
String sourceString = options.get(SOURCE);
|
|
Source source = (sourceString != null)
|
|
? Source.lookup(sourceString)
|
|
: Source.DEFAULT;
|
|
String targetString = options.get(TARGET);
|
|
Target target = (targetString != null)
|
|
? Target.lookup(targetString)
|
|
: Target.DEFAULT;
|
|
// We don't check source/target consistency for CLDC, as J2ME
|
|
// profiles are not aligned with J2SE targets; moreover, a
|
|
// single CLDC target may have many profiles. In addition,
|
|
// this is needed for the continued functioning of the JSR14
|
|
// prototype.
|
|
if (Character.isDigit(target.name.charAt(0))) {
|
|
if (target.compareTo(source.requiredTarget()) < 0) {
|
|
if (targetString != null) {
|
|
if (sourceString == null) {
|
|
warning("warn.target.default.source.conflict",
|
|
targetString,
|
|
source.requiredTarget().name);
|
|
} else {
|
|
warning("warn.source.target.conflict",
|
|
sourceString,
|
|
source.requiredTarget().name);
|
|
}
|
|
return null;
|
|
} else {
|
|
target = source.requiredTarget();
|
|
options.put("-target", target.name);
|
|
}
|
|
} else {
|
|
if (targetString == null && !source.allowGenerics()) {
|
|
target = Target.JDK1_4;
|
|
options.put("-target", target.name);
|
|
}
|
|
}
|
|
}
|
|
|
|
String profileString = options.get(PROFILE);
|
|
if (profileString != null) {
|
|
Profile profile = Profile.lookup(profileString);
|
|
if (!profile.isValid(target)) {
|
|
warning("warn.profile.target.conflict", profileString, target.name);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// handle this here so it works even if no other options given
|
|
String showClass = options.get("showClass");
|
|
if (showClass != null) {
|
|
if (showClass.equals("showClass")) // no value given for option
|
|
showClass = "com.sun.tools.javac.Main";
|
|
showClass(showClass);
|
|
}
|
|
|
|
options.notifyListeners();
|
|
|
|
return filenames;
|
|
}
|
|
// where
|
|
private boolean checkDirectory(Option option) {
|
|
String value = options.get(option);
|
|
if (value == null)
|
|
return true;
|
|
File file = new File(value);
|
|
if (!file.exists()) {
|
|
error("err.dir.not.found", value);
|
|
return false;
|
|
}
|
|
if (!file.isDirectory()) {
|
|
error("err.file.not.directory", value);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/** Programmatic interface for main function.
|
|
* @param args The command line parameters.
|
|
*/
|
|
public Result compile(String[] args) {
|
|
Context context = new Context();
|
|
JavacFileManager.preRegister(context); // can't create it until Log has been set up
|
|
Result result = compile(args, context);
|
|
if (fileManager instanceof JavacFileManager) {
|
|
// A fresh context was created above, so jfm must be a JavacFileManager
|
|
((JavacFileManager)fileManager).close();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public Result compile(String[] args, Context context) {
|
|
return compile(args, context, List.<JavaFileObject>nil(), null);
|
|
}
|
|
|
|
/** Programmatic interface for main function.
|
|
* @param args The command line parameters.
|
|
*/
|
|
public Result compile(String[] args,
|
|
Context context,
|
|
List<JavaFileObject> fileObjects,
|
|
Iterable<? extends Processor> processors)
|
|
{
|
|
return compile(args, null, context, fileObjects, processors);
|
|
}
|
|
|
|
public Result compile(String[] args,
|
|
String[] classNames,
|
|
Context context,
|
|
List<JavaFileObject> fileObjects,
|
|
Iterable<? extends Processor> processors)
|
|
{
|
|
context.put(Log.outKey, out);
|
|
log = Log.instance(context);
|
|
|
|
if (options == null)
|
|
options = Options.instance(context); // creates a new one
|
|
|
|
filenames = new LinkedHashSet<File>();
|
|
classnames = new ListBuffer<String>();
|
|
JavaCompiler comp = null;
|
|
/*
|
|
* TODO: Logic below about what is an acceptable command line
|
|
* should be updated to take annotation processing semantics
|
|
* into account.
|
|
*/
|
|
try {
|
|
if (args.length == 0
|
|
&& (classNames == null || classNames.length == 0)
|
|
&& fileObjects.isEmpty()) {
|
|
Option.HELP.process(optionHelper, "-help");
|
|
return Result.CMDERR;
|
|
}
|
|
|
|
Collection<File> files;
|
|
try {
|
|
files = processArgs(CommandLine.parse(args), classNames);
|
|
if (files == null) {
|
|
// null signals an error in options, abort
|
|
return Result.CMDERR;
|
|
} else if (files.isEmpty() && fileObjects.isEmpty() && classnames.isEmpty()) {
|
|
// it is allowed to compile nothing if just asking for help or version info
|
|
if (options.isSet(HELP)
|
|
|| options.isSet(X)
|
|
|| options.isSet(VERSION)
|
|
|| options.isSet(FULLVERSION))
|
|
return Result.OK;
|
|
if (JavaCompiler.explicitAnnotationProcessingRequested(options)) {
|
|
error("err.no.source.files.classes");
|
|
} else {
|
|
error("err.no.source.files");
|
|
}
|
|
return Result.CMDERR;
|
|
}
|
|
} catch (java.io.FileNotFoundException e) {
|
|
warning("err.file.not.found", e.getMessage());
|
|
return Result.SYSERR;
|
|
}
|
|
|
|
boolean forceStdOut = options.isSet("stdout");
|
|
if (forceStdOut) {
|
|
log.flush();
|
|
log.setWriters(new PrintWriter(System.out, true));
|
|
}
|
|
|
|
// allow System property in following line as a Mustang legacy
|
|
boolean batchMode = (options.isUnset("nonBatchMode")
|
|
&& System.getProperty("nonBatchMode") == null);
|
|
if (batchMode)
|
|
CacheFSInfo.preRegister(context);
|
|
|
|
// FIXME: this code will not be invoked if using JavacTask.parse/analyze/generate
|
|
// invoke any available plugins
|
|
String plugins = options.get(PLUGIN);
|
|
if (plugins != null) {
|
|
JavacProcessingEnvironment pEnv = JavacProcessingEnvironment.instance(context);
|
|
ClassLoader cl = pEnv.getProcessorClassLoader();
|
|
ServiceLoader<Plugin> sl = ServiceLoader.load(Plugin.class, cl);
|
|
Set<List<String>> pluginsToCall = new LinkedHashSet<List<String>>();
|
|
for (String plugin: plugins.split("\\x00")) {
|
|
pluginsToCall.add(List.from(plugin.split("\\s+")));
|
|
}
|
|
JavacTask task = null;
|
|
Iterator<Plugin> iter = sl.iterator();
|
|
while (iter.hasNext()) {
|
|
Plugin plugin = iter.next();
|
|
for (List<String> p: pluginsToCall) {
|
|
if (plugin.getName().equals(p.head)) {
|
|
pluginsToCall.remove(p);
|
|
try {
|
|
if (task == null)
|
|
task = JavacTask.instance(pEnv);
|
|
plugin.init(task, p.tail.toArray(new String[p.tail.size()]));
|
|
} catch (Throwable ex) {
|
|
if (apiMode)
|
|
throw new RuntimeException(ex);
|
|
pluginMessage(ex);
|
|
return Result.SYSERR;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (List<String> p: pluginsToCall) {
|
|
log.printLines(PrefixKind.JAVAC, "msg.plugin.not.found", p.head);
|
|
}
|
|
}
|
|
|
|
comp = JavaCompiler.instance(context);
|
|
|
|
// FIXME: this code will not be invoked if using JavacTask.parse/analyze/generate
|
|
String xdoclint = options.get(XDOCLINT);
|
|
String xdoclintCustom = options.get(XDOCLINT_CUSTOM);
|
|
if (xdoclint != null || xdoclintCustom != null) {
|
|
Set<String> doclintOpts = new LinkedHashSet<String>();
|
|
if (xdoclint != null)
|
|
doclintOpts.add(DocLint.XMSGS_OPTION);
|
|
if (xdoclintCustom != null) {
|
|
for (String s: xdoclintCustom.split("\\s+")) {
|
|
if (s.isEmpty())
|
|
continue;
|
|
doclintOpts.add(s.replace(XDOCLINT_CUSTOM.text, DocLint.XMSGS_CUSTOM_PREFIX));
|
|
}
|
|
}
|
|
if (!(doclintOpts.size() == 1
|
|
&& doclintOpts.iterator().next().equals(DocLint.XMSGS_CUSTOM_PREFIX + "none"))) {
|
|
JavacTask t = BasicJavacTask.instance(context);
|
|
// standard doclet normally generates H1, H2
|
|
doclintOpts.add(DocLint.XIMPLICIT_HEADERS + "2");
|
|
new DocLint().init(t, doclintOpts.toArray(new String[doclintOpts.size()]));
|
|
comp.keepComments = true;
|
|
}
|
|
}
|
|
|
|
fileManager = context.get(JavaFileManager.class);
|
|
|
|
if (!files.isEmpty()) {
|
|
// add filenames to fileObjects
|
|
comp = JavaCompiler.instance(context);
|
|
List<JavaFileObject> otherFiles = List.nil();
|
|
JavacFileManager dfm = (JavacFileManager)fileManager;
|
|
for (JavaFileObject fo : dfm.getJavaFileObjectsFromFiles(files))
|
|
otherFiles = otherFiles.prepend(fo);
|
|
for (JavaFileObject fo : otherFiles)
|
|
fileObjects = fileObjects.prepend(fo);
|
|
}
|
|
comp.compile(fileObjects,
|
|
classnames.toList(),
|
|
processors);
|
|
|
|
if (log.expectDiagKeys != null) {
|
|
if (log.expectDiagKeys.isEmpty()) {
|
|
log.printRawLines("all expected diagnostics found");
|
|
return Result.OK;
|
|
} else {
|
|
log.printRawLines("expected diagnostic keys not found: " + log.expectDiagKeys);
|
|
return Result.ERROR;
|
|
}
|
|
}
|
|
|
|
if (comp.errorCount() != 0)
|
|
return Result.ERROR;
|
|
} catch (IOException ex) {
|
|
ioMessage(ex);
|
|
return Result.SYSERR;
|
|
} catch (OutOfMemoryError ex) {
|
|
resourceMessage(ex);
|
|
return Result.SYSERR;
|
|
} catch (StackOverflowError ex) {
|
|
resourceMessage(ex);
|
|
return Result.SYSERR;
|
|
} catch (FatalError ex) {
|
|
feMessage(ex);
|
|
return Result.SYSERR;
|
|
} catch (AnnotationProcessingError ex) {
|
|
if (apiMode)
|
|
throw new RuntimeException(ex.getCause());
|
|
apMessage(ex);
|
|
return Result.SYSERR;
|
|
} catch (ClientCodeException ex) {
|
|
// as specified by javax.tools.JavaCompiler#getTask
|
|
// and javax.tools.JavaCompiler.CompilationTask#call
|
|
throw new RuntimeException(ex.getCause());
|
|
} catch (PropagatedException ex) {
|
|
throw ex.getCause();
|
|
} catch (Throwable ex) {
|
|
// Nasty. If we've already reported an error, compensate
|
|
// for buggy compiler error recovery by swallowing thrown
|
|
// exceptions.
|
|
if (comp == null || comp.errorCount() == 0 ||
|
|
options == null || options.isSet("dev"))
|
|
bugMessage(ex);
|
|
return Result.ABNORMAL;
|
|
} finally {
|
|
if (comp != null) {
|
|
try {
|
|
comp.close();
|
|
} catch (ClientCodeException ex) {
|
|
throw new RuntimeException(ex.getCause());
|
|
}
|
|
}
|
|
filenames = null;
|
|
options = null;
|
|
}
|
|
return Result.OK;
|
|
}
|
|
|
|
/** Print a message reporting an internal error.
|
|
*/
|
|
void bugMessage(Throwable ex) {
|
|
log.printLines(PrefixKind.JAVAC, "msg.bug", JavaCompiler.version());
|
|
ex.printStackTrace(log.getWriter(WriterKind.NOTICE));
|
|
}
|
|
|
|
/** Print a message reporting a fatal error.
|
|
*/
|
|
void feMessage(Throwable ex) {
|
|
log.printRawLines(ex.getMessage());
|
|
if (ex.getCause() != null && options.isSet("dev")) {
|
|
ex.getCause().printStackTrace(log.getWriter(WriterKind.NOTICE));
|
|
}
|
|
}
|
|
|
|
/** Print a message reporting an input/output error.
|
|
*/
|
|
void ioMessage(Throwable ex) {
|
|
log.printLines(PrefixKind.JAVAC, "msg.io");
|
|
ex.printStackTrace(log.getWriter(WriterKind.NOTICE));
|
|
}
|
|
|
|
/** Print a message reporting an out-of-resources error.
|
|
*/
|
|
void resourceMessage(Throwable ex) {
|
|
log.printLines(PrefixKind.JAVAC, "msg.resource");
|
|
ex.printStackTrace(log.getWriter(WriterKind.NOTICE));
|
|
}
|
|
|
|
/** Print a message reporting an uncaught exception from an
|
|
* annotation processor.
|
|
*/
|
|
void apMessage(AnnotationProcessingError ex) {
|
|
log.printLines(PrefixKind.JAVAC, "msg.proc.annotation.uncaught.exception");
|
|
ex.getCause().printStackTrace(log.getWriter(WriterKind.NOTICE));
|
|
}
|
|
|
|
/** Print a message reporting an uncaught exception from an
|
|
* annotation processor.
|
|
*/
|
|
void pluginMessage(Throwable ex) {
|
|
log.printLines(PrefixKind.JAVAC, "msg.plugin.uncaught.exception");
|
|
ex.printStackTrace(log.getWriter(WriterKind.NOTICE));
|
|
}
|
|
|
|
/** Display the location and checksum of a class. */
|
|
void showClass(String className) {
|
|
PrintWriter pw = log.getWriter(WriterKind.NOTICE);
|
|
pw.println("javac: show class: " + className);
|
|
URL url = getClass().getResource('/' + className.replace('.', '/') + ".class");
|
|
if (url == null)
|
|
pw.println(" class not found");
|
|
else {
|
|
pw.println(" " + url);
|
|
try {
|
|
final String algorithm = "MD5";
|
|
byte[] digest;
|
|
MessageDigest md = MessageDigest.getInstance(algorithm);
|
|
DigestInputStream in = new DigestInputStream(url.openStream(), md);
|
|
try {
|
|
byte[] buf = new byte[8192];
|
|
int n;
|
|
do { n = in.read(buf); } while (n > 0);
|
|
digest = md.digest();
|
|
} finally {
|
|
in.close();
|
|
}
|
|
StringBuilder sb = new StringBuilder();
|
|
for (byte b: digest)
|
|
sb.append(String.format("%02x", b));
|
|
pw.println(" " + algorithm + " checksum: " + sb);
|
|
} catch (Exception e) {
|
|
pw.println(" cannot compute digest: " + e);
|
|
}
|
|
}
|
|
}
|
|
|
|
private JavaFileManager fileManager;
|
|
|
|
/* ************************************************************************
|
|
* Internationalization
|
|
*************************************************************************/
|
|
|
|
// /** Find a localized string in the resource bundle.
|
|
// * @param key The key for the localized string.
|
|
// */
|
|
// public static String getLocalizedString(String key, Object... args) { // FIXME sb private
|
|
// try {
|
|
// if (messages == null)
|
|
// messages = new JavacMessages(javacBundleName);
|
|
// return messages.getLocalizedString("javac." + key, args);
|
|
// }
|
|
// catch (MissingResourceException e) {
|
|
// throw new Error("Fatal Error: Resource for javac is missing", e);
|
|
// }
|
|
// }
|
|
//
|
|
// public static void useRawMessages(boolean enable) {
|
|
// if (enable) {
|
|
// messages = new JavacMessages(javacBundleName) {
|
|
// @Override
|
|
// public String getLocalizedString(String key, Object... args) {
|
|
// return key;
|
|
// }
|
|
// };
|
|
// } else {
|
|
// messages = new JavacMessages(javacBundleName);
|
|
// }
|
|
// }
|
|
|
|
public static final String javacBundleName =
|
|
"com.sun.tools.javac.resources.javac";
|
|
//
|
|
// private static JavacMessages messages;
|
|
}
|