/*
* The Apache Software License, Version 1.1
*
* Copyright (c) 2000-2002 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution, if
* any, must include the following acknowlegement:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowlegement may appear in the software itself,
* if and wherever such third-party acknowlegements normally appear.
*
* 4. The names "The Jakarta Project", "Ant", and "Apache Software
* Foundation" must not be used to endorse or promote products derived
* from this software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache"
* nor may "Apache" appear in their names without prior written
* permission of the Apache Group.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*/
package org.apache.tools.ant.taskdefs;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.DirectoryScanner;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.types.Path;
import org.apache.tools.ant.types.Reference;
import org.apache.tools.ant.util.GlobPatternMapper;
import org.apache.tools.ant.util.JavaEnvUtils;
import org.apache.tools.ant.util.SourceFileScanner;
import org.apache.tools.ant.util.facade.FacadeTaskHelper;
import org.apache.tools.ant.taskdefs.compilers.CompilerAdapter;
import org.apache.tools.ant.taskdefs.compilers.CompilerAdapterFactory;
import java.io.File;
/**
* Compiles Java source files. This task can take the following
* arguments:
* <ul>
* <li>sourcedir
* <li>destdir
* <li>deprecation
* <li>classpath
* <li>bootclasspath
* <li>extdirs
* <li>optimize
* <li>debug
* <li>encoding
* <li>target
* <li>depend
* <li>vebose
* <li>failonerror
* <li>includeantruntime
* <li>includejavaruntime
* <li>source
* <li>compiler
* </ul>
* Of these arguments, the <b>sourcedir</b> and <b>destdir</b> are required.
* <p>
* When this task executes, it will recursively scan the sourcedir and
* destdir looking for Java source files to compile. This task makes its
* compile decision based on timestamp.
*
* @author James Davidson <a href="mailto:duncan@x180.com">duncan@x180.com</a>
* @author Robin Green
* <a href="mailto:greenrd@hotmail.com">greenrd@hotmail.com</a>
* @author <a href="mailto:stefan.bodewig@epost.de">Stefan Bodewig</a>
* @author <a href="mailto:jayglanville@home.com">J D Glanville</a>
*
* @version $Revision: 1.102.2.2 $
*
* @since Ant 1.1
*
* @ant.task category="java"
*/
public class Javac extends MatchingTask {
private static final String FAIL_MSG
= "Compile failed; see the compiler error output for details.";
private Path src;
private File destDir;
private Path compileClasspath;
private Path compileSourcepath;
private String encoding;
private boolean debug = false;
private boolean optimize = false;
private boolean deprecation = false;
private boolean depend = false;
private boolean verbose = false;
private String target;
private Path bootclasspath;
private Path extdirs;
private boolean includeAntRuntime = true;
private boolean includeJavaRuntime = false;
private boolean fork = false;
private String forkedExecutable = null;
private boolean nowarn = false;
private String memoryInitialSize;
private String memoryMaximumSize;
private FacadeTaskHelper facade = null;
protected boolean failOnError = true;
protected boolean listFiles = false;
protected File[] compileList = new File[0];
private String source;
private String debugLevel;
/**
* Javac task for compilation of Java files.
*/
public Javac() {
if (JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_1)) {
facade = new FacadeTaskHelper("javac1.1");
} else if (JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_2)) {
facade = new FacadeTaskHelper("javac1.2");
} else if (JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_3)) {
facade = new FacadeTaskHelper("javac1.3");
} else if (JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_4)) {
facade = new FacadeTaskHelper("javac1.4");
} else {
facade = new FacadeTaskHelper("classic");
}
}
/**
* Get the value of debugLevel.
* @return value of debugLevel.
*/
public String getDebugLevel() {
return debugLevel;
}
/**
* Keyword list to be appended to the -g command-line switch.
*
* This will be ignored by all implementations except modern
* and classic(ver >= 1.2). Legal values are none or a
* comma-separated list of the following keywords: lines, vars,
* and source. If debuglevel is not specified, by default, :none
* will be appended to -g. If debug is not turned on, this attribute
* will be ignored.
*
* @param v Value to assign to debugLevel.
*/
public void setDebugLevel(String v) {
this.debugLevel = v;
}
/**
* Get the value of source.
* @return value of source.
*/
public String getSource() {
return source;
}
/**
* Value of the -source command-line switch; will be ignored
* by all implementations except modern and jikes.
*
* If you use this attribute together with jikes, you must
* make sure that your version of jikes supports the -source switch.
* Legal values are 1.3 and 1.4 - by default, no -source argument
* will be used at all.
*
* @param v Value to assign to source.
*/
public void setSource(String v) {
this.source = v;
}
/**
* Adds a path for source compilation.
*
* @return a nested src element.
*/
public Path createSrc() {
if (src == null) {
src = new Path(project);
}
return src.createPath();
}
/**
* Recreate src.
*
* @return a nested src element.
*/
protected Path recreateSrc() {
src = null;
return createSrc();
}
/**
* Set the source directories to find the source Java files.
*/
public void setSrcdir(Path srcDir) {
if (src == null) {
src = srcDir;
} else {
src.append(srcDir);
}
}
/** Gets the source dirs to find the source java files. */
public Path getSrcdir() {
return src;
}
/**
* Set the destination directory into which the Java source
* files should be compiled.
*/
public void setDestdir(File destDir) {
this.destDir = destDir;
}
/**
* Gets the destination directory into which the java source files
* should be compiled.
*/
public File getDestdir() {
return destDir;
}
/**
* Set the sourcepath to be used for this compilation.
*/
public void setSourcepath(Path sourcepath) {
if (compileSourcepath == null) {
compileSourcepath = sourcepath;
} else {
compileSourcepath.append(sourcepath);
}
}
/** Gets the sourcepath to be used for this compilation. */
public Path getSourcepath() {
return compileSourcepath;
}
/**
* Adds a path to sourcepath.
*/
public Path createSourcepath() {
if (compileSourcepath == null) {
compileSourcepath = new Path(project);
}
return compileSourcepath.createPath();
}
/**
* Adds a reference to a source path defined elsewhere.
*/
public void setSourcepathRef(Reference r) {
createSourcepath().setRefid(r);
}
/**
* Set the classpath to be used for this compilation.
*
* @param classpath an Ant Path object containing the compilation classpath.
*/
public void setClasspath(Path classpath) {
if (compileClasspath == null) {
compileClasspath = classpath;
} else {
compileClasspath.append(classpath);
}
}
/** Gets the classpath to be used for this compilation. */
public Path getClasspath() {
return compileClasspath;
}
/**
* Adds a path to the classpath.
*/
public Path createClasspath() {
if (compileClasspath == null) {
compileClasspath = new Path(project);
}
return compileClasspath.createPath();
}
/**
* Adds a reference to a classpath defined elsewhere.
*/
public void setClasspathRef(Reference r) {
createClasspath().setRefid(r);
}
/**
* Sets the bootclasspath that will be used to compile the classes
* against.
*/
public void setBootclasspath(Path bootclasspath) {
if (this.bootclasspath == null) {
this.bootclasspath = bootclasspath;
} else {
this.bootclasspath.append(bootclasspath);
}
}
/**
* Gets the bootclasspath that will be used to compile the classes
* against.
*/
public Path getBootclasspath() {
return bootclasspath;
}
/**
* Adds a path to the bootclasspath.
*/
public Path createBootclasspath() {
if (bootclasspath == null) {
bootclasspath = new Path(project);
}
return bootclasspath.createPath();
}
/**
* Adds a reference to a classpath defined elsewhere.
*/
public void setBootClasspathRef(Reference r) {
createBootclasspath().setRefid(r);
}
/**
* Sets the extension directories that will be used during the
* compilation.
*/
public void setExtdirs(Path extdirs) {
if (this.extdirs == null) {
this.extdirs = extdirs;
} else {
this.extdirs.append(extdirs);
}
}
/**
* Gets the extension directories that will be used during the
* compilation.
*/
public Path getExtdirs() {
return extdirs;
}
/**
* Adds a path to extdirs.
*/
public Path createExtdirs() {
if (extdirs == null) {
extdirs = new Path(project);
}
return extdirs.createPath();
}
/**
* If true, list the source files being handed off to the compiler.
*/
public void setListfiles(boolean list) {
listFiles = list;
}
/** Get the listfiles flag. */
public boolean getListfiles() {
return listFiles;
}
/**
* Indicates whether the build will continue
* even if there are compilation errors; defaults to true.
*/
public void setFailonerror(boolean fail) {
failOnError = fail;
}
/**
* @ant.attribute ignore="true"
*/
public void setProceed(boolean proceed) {
failOnError = !proceed;
}
/**
* Gets the failonerror flag.
*/
public boolean getFailonerror() {
return failOnError;
}
/**
* Indicates whether source should be
* compiled with deprecation information; defaults to off.
*/
public void setDeprecation(boolean deprecation) {
this.deprecation = deprecation;
}
/** Gets the deprecation flag. */
public boolean getDeprecation() {
return deprecation;
}
/**
* The initial size of the memory for the underlying VM
* if javac is run externally; ignored otherwise.
* Defaults to the standard VM memory setting.
* (Examples: 83886080, 81920k, or 80m)
*/
public void setMemoryInitialSize(String memoryInitialSize) {
this.memoryInitialSize = memoryInitialSize;
}
/** Gets the memoryInitialSize flag. */
public String getMemoryInitialSize() {
return memoryInitialSize;
}
/**
* The maximum size of the memory for the underlying VM
* if javac is run externally; ignored otherwise.
* Defaults to the standard VM memory setting.
* (Examples: 83886080, 81920k, or 80m)
*/
public void setMemoryMaximumSize(String memoryMaximumSize) {
this.memoryMaximumSize = memoryMaximumSize;
}
/** Gets the memoryMaximumSize flag. */
public String getMemoryMaximumSize() {
return memoryMaximumSize;
}
/**
* Set the Java source file encoding name.
*/
public void setEncoding(String encoding) {
this.encoding = encoding;
}
/** Gets the java source file encoding name. */
public String getEncoding() {
return encoding;
}
/**
* Indicates whether source should be compiled
* with debug information; defaults to off.
*/
public void setDebug(boolean debug) {
this.debug = debug;
}
/** Gets the debug flag. */
public boolean getDebug() {
return debug;
}
/**
* If true, compiles with optimization enabled.
*/
public void setOptimize(boolean optimize) {
this.optimize = optimize;
}
/** Gets the optimize flag. */
public boolean getOptimize() {
return optimize;
}
/**
* Enables dependency-tracking for compilers
* that support this (jikes and classic).
*/
public void setDepend(boolean depend) {
this.depend = depend;
}
/** Gets the depend flag. */
public boolean getDepend() {
return depend;
}
/**
* If true, asks the compiler for verbose output.
*/
public void setVerbose(boolean verbose) {
this.verbose = verbose;
}
/** Gets the verbose flag. */
public boolean getVerbose() {
return verbose;
}
/**
* Sets the target VM that the classes will be compiled for. Valid
* strings are "1.1", "1.2", and "1.3".
*/
public void setTarget(String target) {
this.target = target;
}
/** Gets the target VM that the classes will be compiled for. */
public String getTarget() {
return target;
}
/**
* If true, includes Ant's own classpath in the classpath.
*/
public void setIncludeantruntime(boolean include) {
includeAntRuntime = include;
}
/**
* Gets whether or not the ant classpath is to be included in the classpath.
*/
public boolean getIncludeantruntime() {
return includeAntRuntime;
}
/**
* If true, includes the Java runtime libraries in the classpath.
*/
public void setIncludejavaruntime(boolean include) {
includeJavaRuntime = include;
}
/**
* Gets whether or not the java runtime should be included in this
* task's classpath.
*/
public boolean getIncludejavaruntime() {
return includeJavaRuntime;
}
/**
* If true, forks the javac compiler.
*
* @param f "true|false|on|off|yes|no"
*/
public void setFork(boolean f) {
fork = f;
}
/**
* Sets the the name of the javac executable.
*
* <p>Ignored unless fork is true or extJavac has been specified
* as the compiler.</p>
*/
public void setExecutable(String forkExec) {
forkedExecutable = forkExec;
}
/**
* Is this a forked invocation of JDK's javac?
*/
public boolean isForkedJavac() {
return fork || "extJavac".equals(getCompiler());
}
/**
* The name of the javac executable to use in fork-mode.
*/
public String getJavacExecutable() {
if (forkedExecutable == null && isForkedJavac()) {
forkedExecutable = getSystemJavac();
} else if (forkedExecutable != null && !isForkedJavac()) {
forkedExecutable = null;
}
return forkedExecutable;
}
/**
* If true, enables the -nowarn option.
*/
public void setNowarn(boolean flag) {
this.nowarn = flag;
}
/**
* Should the -nowarn option be used.
*/
public boolean getNowarn() {
return nowarn;
}
/**
* Adds an implementation specific command-line argument.
*/
public ImplementationSpecificArgument createCompilerArg() {
ImplementationSpecificArgument arg =
new ImplementationSpecificArgument();
facade.addImplementationArgument(arg);
return arg;
}
/**
* Get the additional implementation specific command line arguments.
* @return array of command line arguments, guaranteed to be non-null.
*/
public String[] getCurrentCompilerArgs() {
String chosen = facade.getExplicitChoice();
// make sure facade knows about magic properties and fork setting
facade.setImplementation(getCompiler());
try {
return facade.getArgs();
} finally {
facade.setImplementation(chosen);
}
}
/**
* Executes the task.
*/
public void execute() throws BuildException {
checkParameters();
resetFileLists();
// scan source directories and dest directory to build up
// compile lists
String[] list = src.list();
for (int i = 0; i < list.length; i++) {
File srcDir = project.resolveFile(list[i]);
if (!srcDir.exists()) {
throw new BuildException("srcdir \""
+ srcDir.getPath()
+ "\" does not exist!", location);
}
DirectoryScanner ds = this.getDirectoryScanner(srcDir);
String[] files = ds.getIncludedFiles();
scanDir(srcDir, destDir != null ? destDir : srcDir, files);
}
compile();
}
/**
* Clear the list of files to be compiled and copied..
*/
protected void resetFileLists() {
compileList = new File[0];
}
/**
* Scans the directory looking for source files to be compiled.
* The results are returned in the class variable compileList
*/
protected void scanDir(File srcDir, File destDir, String[] files) {
GlobPatternMapper m = new GlobPatternMapper();
m.setFrom("*.java");
m.setTo("*.class");
SourceFileScanner sfs = new SourceFileScanner(this);
File[] newFiles = sfs.restrictAsFiles(files, srcDir, destDir, m);
if (newFiles.length > 0) {
File[] newCompileList = new File[compileList.length +
newFiles.length];
System.arraycopy(compileList, 0, newCompileList, 0,
compileList.length);
System.arraycopy(newFiles, 0, newCompileList,
compileList.length, newFiles.length);
compileList = newCompileList;
}
}
/** Gets the list of files to be compiled. */
public File[] getFileList() {
return compileList;
}
protected boolean isJdkCompiler(String compilerImpl) {
return "modern".equals(compilerImpl) ||
"classic".equals(compilerImpl) ||
"javac1.1".equals(compilerImpl) ||
"javac1.2".equals(compilerImpl) ||
"javac1.3".equals(compilerImpl) ||
"javac1.4".equals(compilerImpl);
}
protected String getSystemJavac() {
return JavaEnvUtils.getJdkExecutable("javac");
}
/**
* Choose the implementation for this particular task.
*
* @since Ant 1.5
*/
public void setCompiler(String compiler) {
facade.setImplementation(compiler);
}
/**
* The implementation for this particular task.
*
* <p>Defaults to the build.compiler property but can be overriden
* via the compiler and fork attributes.</p>
*
* <p>If fork has been set to true, the result will be extJavac
* and not classic or java1.2 - no matter what the compiler
* attribute looks like.</p>
*
* @see #getCompilerVersion
*
* @since Ant 1.5
*/
public String getCompiler() {
String compilerImpl = getCompilerVersion();
if (fork) {
if (isJdkCompiler(compilerImpl)) {
log("Since fork is true, ignoring compiler setting.",
Project.MSG_WARN);
compilerImpl = "extJavac";
} else {
log("Since compiler setting isn't classic or modern,"
+ "ignoring fork setting.", Project.MSG_WARN);
}
}
return compilerImpl;
}
/**
* The implementation for this particular task.
*
* <p>Defaults to the build.compiler property but can be overriden
* via the compiler attribute.</p>
*
* <p>This method does not take the fork attribute into
* account.</p>
*
* @see #getCompiler
*
* @since Ant 1.5
*/
public String getCompilerVersion() {
facade.setMagicValue(getProject().getProperty("build.compiler"));
return facade.getImplementation();
}
/**
* Check that all required attributes have been set and nothing
* silly has been entered.
*
* @since Ant 1.5
*/
protected void checkParameters() throws BuildException {
if (src == null) {
throw new BuildException("srcdir attribute must be set!",
location);
}
if (src.size() == 0) {
throw new BuildException("srcdir attribute must be set!",
location);
}
if (destDir != null && !destDir.isDirectory()) {
throw new BuildException("destination directory \""
+ destDir
+ "\" does not exist "
+ "or is not a directory", location);
}
}
/**
* Perform the compilation.
*
* @since Ant 1.5
*/
protected void compile() {
String compilerImpl = getCompiler();
if (compileList.length > 0) {
log("Compiling " + compileList.length +
" source file"
+ (compileList.length == 1 ? "" : "s")
+ (destDir != null ? " to " + destDir : ""));
if (listFiles) {
for (int i = 0 ; i < compileList.length ; i++) {
String filename = compileList[i].getAbsolutePath();
log(filename) ;
}
}
CompilerAdapter adapter =
CompilerAdapterFactory.getCompiler(compilerImpl, this);
// now we need to populate the compiler adapter
adapter.setJavac(this);
// finally, lets execute the compiler!!
if (!adapter.execute()) {
if (failOnError) {
throw new BuildException(FAIL_MSG, location);
} else {
log(FAIL_MSG, Project.MSG_ERR);
}
}
}
}
/**
* Adds an "compiler" attribute to Commandline$Attribute used to
* filter command line attributes based on the current
* implementation.
*/
public class ImplementationSpecificArgument extends
org.apache.tools.ant.util.facade.ImplementationSpecificArgument {
public void setCompiler(String impl) {
super.setImplementation(impl);
}
}
}