"groovy.warnings"
<tr>
<tr>
<tr>
<tr>
<tr>
<tr>
<tr>
<tr>
<tr>
<tr>
<tr>
<tr>
Groovy example source code file (CompilerConfiguration.java)
The Groovy CompilerConfiguration.java source code/*
* Copyright 2003-2009 the original author or authors.
*
* 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.
*/
package org.codehaus.groovy.control;
import org.codehaus.groovy.control.customizers.CompilationCustomizer;
import org.codehaus.groovy.control.io.NullWriter;
import org.codehaus.groovy.control.messages.WarningMessage;
import java.io.File;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.StringTokenizer;
/**
* Compilation control flags and coordination stuff.
*
* @author <a href="mailto:cpoirier@dreaming.org">Chris Poirier
* @author <a href="mailto:blackdrag@gmx.org">Jochen Theodorou
* @author <a href="mailto:jim@pagesmiths.com">Jim White
* @version $Id: CompilerConfiguration.java 21737 2011-03-07 16:05:50Z glaforge $
*/
public class CompilerConfiguration {
private static final String JDK5_CLASSNAME_CHECK = "java.lang.annotation.Annotation";
/** This (<code>"1.5") is the value for targetBytecode to compile for a JDK 1.5 or later JVM. **/
public static final String POST_JDK5 = "1.5";
/** This (<code>"1.4" | Get/Set Property Name | {@link #getWarningLevel} | |
|---|---|---|---|
"groovy.source.encoding" | {@link #getSourceEncoding} | ||
"groovy.target.directory" | {@link #getTargetDirectory} | ||
"groovy.target.bytecode" | {@link #getTargetBytecode} | ||
"groovy.classpath" | {@link #getClasspath} | ||
"groovy.output.verbose" | {@link #getVerbose} | ||
"groovy.output.debug" | {@link #getDebug} | ||
"groovy.errors.tolerance" | {@link #getTolerance} | ||
"groovy.script.extension" | {@link #getDefaultScriptExtension} | ||
"groovy.script.base" | {@link #getScriptBaseClass} | ||
"groovy.recompile" | {@link #getRecompileGroovySource} | ||
"groovy.recompile.minimumInterval" | {@link #getMinimumRecompilationInterval} | ||
</tr>
</table>
<br/>
* @param configuration The properties to get flag values from.
*/
public CompilerConfiguration(Properties configuration) throws ConfigurationException {
this();
configure(configuration);
}
/**
* 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);
}
/**
* Gets the currently configured warning level. See WarningMessage
* for level details.
*/
public int getWarningLevel() {
return this.warningLevel;
}
/**
* Sets the warning level. See WarningMessage for level details.
*/
public void setWarningLevel(int level) {
if (level < WarningMessage.NONE || level > WarningMessage.PARANOIA) {
this.warningLevel = WarningMessage.LIKELY_ERRORS;
}
else {
this.warningLevel = level;
}
}
/**
* Gets the currently configured source file encoding.
*/
public String getSourceEncoding() {
return this.sourceEncoding;
}
/**
* Sets the encoding to be used when reading source files.
*/
public void setSourceEncoding(String encoding) {
if (encoding == null) encoding = "US-ASCII";
this.sourceEncoding = encoding;
}
/**
* Gets the currently configured output writer.
*/
public PrintWriter getOutput() {
return this.output;
}
/**
* Sets the output writer.
*/
public void setOutput(PrintWriter output) {
if (output == null) {
this.output = new PrintWriter(NullWriter.DEFAULT);
}
else {
this.output = output;
}
}
/**
* Gets the target directory for writing classes.
*/
public File getTargetDirectory() {
return this.targetDirectory;
}
/**
* Sets the target directory.
*/
public void setTargetDirectory(String directory) {
if (directory != null && directory.length() > 0) {
this.targetDirectory = new File(directory);
} else {
this.targetDirectory = null;
}
}
/**
* Sets the target directory.
*/
public void setTargetDirectory(File directory) {
this.targetDirectory = directory;
}
/**
* @return the classpath
*/
public List<String> getClasspath() {
return this.classpath;
}
/**
* Sets the classpath.
*/
public void setClasspath(String classpath) {
this.classpath = new LinkedList<String>();
StringTokenizer tokenizer = new StringTokenizer(classpath, File.pathSeparator);
while (tokenizer.hasMoreTokens()) {
this.classpath.add(tokenizer.nextToken());
}
}
/**
* sets the classpath using a list of Strings
* @param l list of strings containg the classpathparts
*/
public void setClasspathList(List<String> l) {
this.classpath = new LinkedList<String>(l);
}
/**
* Returns true if verbose operation has been requested.
*/
public boolean getVerbose() {
return this.verbose;
}
/**
* Turns verbose operation on or off.
*/
public void setVerbose(boolean verbose) {
this.verbose = verbose;
}
/**
* Returns true if debugging operation has been requested.
*/
public boolean getDebug() {
return this.debug;
}
/**
* Turns debugging operation on or off.
*/
public void setDebug(boolean debug) {
this.debug = debug;
}
/**
* Returns the requested error tolerance.
*/
public int getTolerance() {
return this.tolerance;
}
/**
* Sets the error tolerance, which is the number of
* non-fatal errors (per unit) that should be tolerated before
* compilation is aborted.
*/
public void setTolerance(int tolerance) {
this.tolerance = tolerance;
}
/**
* Gets the name of the base class for scripts. It must be a subclass
* of Script.
*/
public String getScriptBaseClass() {
return this.scriptBaseClass;
}
/**
* Sets the name of the base class for scripts. It must be a subclass
* of Script.
*/
public void setScriptBaseClass(String scriptBaseClass) {
this.scriptBaseClass = scriptBaseClass;
}
public ParserPluginFactory getPluginFactory() {
if (pluginFactory == null) {
pluginFactory = ParserPluginFactory.newInstance(true);
}
return pluginFactory;
}
public void setPluginFactory(ParserPluginFactory pluginFactory) {
this.pluginFactory = pluginFactory;
}
public void setScriptExtensions(Set<String> scriptExtensions) {
if(scriptExtensions == null) scriptExtensions = new LinkedHashSet<String>();
this.scriptExtensions = scriptExtensions;
}
public Set<String> getScriptExtensions() {
if(scriptExtensions == null || scriptExtensions.isEmpty()) {
/*
* this happens
* * when groovyc calls FileSystemCompiler in forked mode, or
* * when FileSystemCompiler is run from the command line directly, or
* * when groovy was not started using groovyc or FileSystemCompiler either
*/
scriptExtensions = SourceExtensionHandler.getRegisteredExtensions(
this.getClass().getClassLoader());
}
return scriptExtensions;
}
public String getDefaultScriptExtension() {
return defaultScriptExtension;
}
public void setDefaultScriptExtension(String defaultScriptExtension) {
this.defaultScriptExtension = defaultScriptExtension;
}
public void setRecompileGroovySource(boolean recompile) {
recompileGroovySource = recompile;
}
public boolean getRecompileGroovySource(){
return recompileGroovySource;
}
public void setMinimumRecompilationInterval(int time) {
minimumRecompilationInterval = Math.max(0,time);
}
public int getMinimumRecompilationInterval() {
return minimumRecompilationInterval;
}
/**
* Allow setting the bytecode compatibility. The parameter can take
* one of the values <tt>1.5 or 1.4. If wrong parameter
* then the value will default to VM determined version.
*
* @param version the bytecode compatibility mode
*/
public void setTargetBytecode(String version) {
if(PRE_JDK5.equals(version) || POST_JDK5.equals(version)) {
this.targetBytecode = version;
}
}
/**
* Retrieves the compiler bytecode compatibility mode.
*
* @return bytecode compatibility mode. Can be either <tt>1.5 or 1.4.
*/
public String getTargetBytecode() {
return this.targetBytecode;
}
private static String getVMVersion() {
try {
Class.forName(JDK5_CLASSNAME_CHECK);
return POST_JDK5;
} catch(Exception ex) {
// IGNORE
}
return PRE_JDK5;
}
/**
* Gets the joint compilation options for this configuration.
* @return the options
*/
public Map<String, Object> getJointCompilationOptions() {
return jointCompilationOptions;
}
/**
* Sets the joint compilation options for this configuration.
* Using null will disable joint compilation.
* @param options the options
*/
public void setJointCompilationOptions(Map<String, Object> options) {
jointCompilationOptions = options;
}
/**
* Gets the optimization options for this configuration.
* @return the options (always not null)
*/
public Map<String, Boolean> getOptimizationOptions() {
return optimizationOptions;
}
/**
* Sets the optimization options for this configuration.
* No entry or a true for that entry means to enable that optimization,
* a false means the optimization is disabled.
* Valid keys are "all" and "int".
* @param options the options.
* @throws IllegalArgumentException if the options are null
*/
public void setOptimizationOptions(Map<String, Boolean> options) {
if (options==null) throw new IllegalArgumentException("provided option map must not be null");
optimizationOptions = options;
}
/**
* Adds compilation customizers to the compilation process. A compilation customizer is a class node
* operation which performs various operations going from adding imports to access control.
* @param customizers the list of customizers to be added
* @return this configuration instance
*/
public CompilerConfiguration addCompilationCustomizers(CompilationCustomizer... customizers) {
if (customizers==null) throw new IllegalArgumentException("provided customizers list must not be null");
compilationCustomizers.addAll(Arrays.asList(customizers));
return this;
}
/**
* Returns the list of compilation customizers.
* @return the customizers (always not null)
*/
public List<CompilationCustomizer> getCompilationCustomizers() {
return compilationCustomizers;
}
}
Other Groovy examples (source code examples)Here is a short list of links related to this Groovy CompilerConfiguration.java source code file: |
The search page
Other Groovy source code examples at this package level
Click here to learn more about this project
