/** Sets the Flags to defaults. */
public CompilerConfiguration() {
//
// Set in safe defaults
setWarningLevel(WarningMessage.LIKELY_ERRORS);
setOutput(null);
setTargetDirectory((File) null);
setClasspath("");
setVerbose(false);
setDebug(false);
setTolerance(10);
setScriptBaseClass(null);
setRecompileGroovySource(false);
setMinimumRecompilationInterval(100);
setTargetBytecode(getVMVersion());
setDefaultScriptExtension(".groovy");
//
// Source file encoding
String encoding = null;
try {
encoding = System.getProperty("file.encoding", "US-ASCII");
} catch (Exception e) {
// IGNORE
}
try {
encoding = System.getProperty("groovy.source.encoding", encoding);
} catch (Exception e) {
// IGNORE
}
setSourceEncoding(encoding);
try {
setOutput(new PrintWriter(System.err));
} catch (Exception e) {
// IGNORE
}
try {
String target = System.getProperty("groovy.target.directory");
if (target != null) {
setTargetDirectory(target);
}
} catch (Exception e) {
// IGNORE
}
}
/**
* Copy constructor. Use this if you have a mostly correct configuration for your compilation but
* you want to make a some changes programmatically. An important reason to prefer this approach
* is that your code will most likely be forward compatible with future changes to this
* configuration API.<br>
* An example of this copy constructor at work:<br>
*
* <pre>
* // In all likelihood there is already a configuration in your code's context
* // for you to copy, but for the sake of this example we'll use the global default.
* CompilerConfiguration myConfiguration = new CompilerConfiguration(CompilerConfiguration.DEFAULT);
* myConfiguration.setDebug(true);
* </pre>
*
* @param configuration The configuration to copy.
*/
public CompilerConfiguration(CompilerConfiguration configuration) {
setWarningLevel(configuration.getWarningLevel());
setOutput(configuration.getOutput());
setTargetDirectory(configuration.getTargetDirectory());
setClasspathList(new LinkedList(configuration.getClasspath()));
setVerbose(configuration.getVerbose());
setDebug(configuration.getDebug());
setTolerance(configuration.getTolerance());
setScriptBaseClass(configuration.getScriptBaseClass());
setRecompileGroovySource(configuration.getRecompileGroovySource());
setMinimumRecompilationInterval(configuration.getMinimumRecompilationInterval());
setTargetBytecode(configuration.getTargetBytecode());
setDefaultScriptExtension(configuration.getDefaultScriptExtension());
setSourceEncoding(configuration.getSourceEncoding());
setOutput(configuration.getOutput());
setTargetDirectory(configuration.getTargetDirectory());
Map jointCompilationOptions = configuration.getJointCompilationOptions();
if (jointCompilationOptions != null) {
jointCompilationOptions = new HashMap(jointCompilationOptions);
}
setJointCompilationOptions(jointCompilationOptions);
setPluginFactory(configuration.getPluginFactory());
}
/**
* Method to configure a this CompilerConfiguration by using Properties. For a list of available
* properties look at {link {@link #CompilerConfiguration(Properties)}.
*
* @param configuration The properties to get flag values from.
*/
public void configure(Properties configuration) throws ConfigurationException {
String text = null;
int numeric = 0;
//
// Warning level
numeric = getWarningLevel();
try {
text = configuration.getProperty("groovy.warnings", "likely errors");
numeric = Integer.parseInt(text);
} catch (NumberFormatException e) {
text = text.toLowerCase();
if (text.equals("none")) {
numeric = WarningMessage.NONE;
} else if (text.startsWith("likely")) {
numeric = WarningMessage.LIKELY_ERRORS;
} else if (text.startsWith("possible")) {
numeric = WarningMessage.POSSIBLE_ERRORS;
} else if (text.startsWith("paranoia")) {
numeric = WarningMessage.PARANOIA;
} else {
throw new ConfigurationException("unrecogized groovy.warnings: " + text);
}
}
setWarningLevel(numeric);
//
// Source file encoding
//
text = configuration.getProperty("groovy.source.encoding");
if (text != null) setSourceEncoding(text);
//
// Target directory for classes
//
text = configuration.getProperty("groovy.target.directory");
if (text != null) setTargetDirectory(text);
text = configuration.getProperty("groovy.target.bytecode");
if (text != null) setTargetBytecode(text);
//
// Classpath
//
text = configuration.getProperty("groovy.classpath");
if (text != null) setClasspath(text);
//
// Verbosity
//
text = configuration.getProperty("groovy.output.verbose");
if (text != null && text.equalsIgnoreCase("true")) setVerbose(true);
//
// Debugging
//
text = configuration.getProperty("groovy.output.debug");
if (text != null && text.equalsIgnoreCase("true")) setDebug(true);
//
// Tolerance
//
numeric = 10;
try {
text = configuration.getProperty("groovy.errors.tolerance", "10");
numeric = Integer.parseInt(text);
} catch (NumberFormatException e) {
throw new ConfigurationException(e);
}
setTolerance(numeric);
//
// Script Base Class
//
text = configuration.getProperty("groovy.script.base");
if (text != null) setScriptBaseClass(text);
//
// recompilation options
//
text = configuration.getProperty("groovy.recompile");
if (text != null) {
setRecompileGroovySource(text.equalsIgnoreCase("true"));
}
numeric = 100;
try {
text = configuration.getProperty("groovy.recompile.minimumIntervall");
if (text == null) text = configuration.getProperty("groovy.recompile.minimumInterval");
if (text != null) {
numeric = Integer.parseInt(text);
} else {
numeric = 100;
}
} catch (NumberFormatException e) {
throw new ConfigurationException(e);
}
setMinimumRecompilationInterval(numeric);
}
/**
* A convenience routine to create a standalone SourceUnit on a String with defaults for almost
* everything that is configurable.
*/
public static SourceUnit create(String name, String source, int tolerance) {
CompilerConfiguration configuration = new CompilerConfiguration();
configuration.setTolerance(tolerance);
return new SourceUnit(name, source, configuration, null, new ErrorCollector(configuration));
}