/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.apache.tools.ant.taskdefs.compilers;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.types.Commandline;
import org.apache.tools.ant.types.Path;
/**
* The implementation of the jikes compiler.
* This is primarily a cut-and-paste from the original javac task before it
* was refactored.
*
* @since Ant 1.3
*/
public class Jikes extends DefaultCompilerAdapter {
/**
* Performs a compile using the Jikes compiler from IBM.
* Mostly of this code is identical to doClassicCompile()
* However, it does not support all options like
* extdirs, deprecation and so on, because
* there is no option in jikes and I don't understand
* what they should do.
*
* It has been successfully tested with jikes >1.10.
* @return true if the compilation succeeded
* @throws BuildException on error
*/
@Override
public boolean execute() throws BuildException {
attributes.log("Using jikes compiler", Project.MSG_VERBOSE);
Commandline cmd = new Commandline();
// For -sourcepath, use the "sourcepath" value if present.
// Otherwise default to the "srcdir" value.
Path sourcepath;
if (compileSourcepath != null) {
sourcepath = compileSourcepath;
} else {
sourcepath = src;
}
// If the buildfile specifies sourcepath="", then don't
// output any sourcepath.
if (!sourcepath.isEmpty()) {
cmd.createArgument().setValue("-sourcepath");
cmd.createArgument().setPath(sourcepath);
}
Path classpath = new Path(project);
if (bootclasspath == null || bootclasspath.isEmpty()) {
// no bootclasspath, therefore, get one from the java runtime
includeJavaRuntime = true;
} else {
// there is a bootclasspath stated. By default, the
// includeJavaRuntime is false. If the user has stated a
// bootclasspath and said to include the java runtime, it's on
// their head!
}
classpath.append(getCompileClasspath());
// if the user has set JIKESPATH we should add the contents as well
String jikesPath = System.getProperty("jikes.class.path");
if (jikesPath != null) {
classpath.append(new Path(project, jikesPath));
}
if (!(extdirs == null || extdirs.isEmpty())) {
cmd.createArgument().setValue("-extdirs");
cmd.createArgument().setPath(extdirs);
}
String exec = getJavac().getExecutable();
cmd.setExecutable(exec == null ? "jikes" : exec);
if (deprecation) {
cmd.createArgument().setValue("-deprecation");
}
if (destDir != null) {
cmd.createArgument().setValue("-d");
cmd.createArgument().setFile(destDir);
}
cmd.createArgument().setValue("-classpath");
cmd.createArgument().setPath(classpath);
if (encoding != null) {
cmd.createArgument().setValue("-encoding");
cmd.createArgument().setValue(encoding);
}
if (debug) {
String debugLevel = attributes.getDebugLevel();
if (debugLevel != null) {
cmd.createArgument().setValue("-g:" + debugLevel);
} else {
cmd.createArgument().setValue("-g");
}
} else {
cmd.createArgument().setValue("-g:none");
}
if (optimize) {
cmd.createArgument().setValue("-O");
}
if (verbose) {
cmd.createArgument().setValue("-verbose");
}
if (depend) {
cmd.createArgument().setValue("-depend");
}
if (target != null) {
cmd.createArgument().setValue("-target");
cmd.createArgument().setValue(target);
}
addPropertyParams(cmd);
if (attributes.getSource() != null) {
cmd.createArgument().setValue("-source");
String source = attributes.getSource();
if ("1.1".equals(source) || "1.2".equals(source)) {
// support for -source 1.1 and -source 1.2 has been
// added with JDK 1.4.2, Jikes doesn't like it
attributes.log("Jikes doesn't support '-source " + source
+ "', will use '-source 1.3' instead");
cmd.createArgument().setValue("1.3");
} else {
cmd.createArgument().setValue(source);
}
}
addCurrentCompilerArgs(cmd);
int firstFileName = cmd.size();
Path boot = getBootClassPath();
if (!boot.isEmpty()) {
cmd.createArgument().setValue("-bootclasspath");
cmd.createArgument().setPath(boot);
}
logAndAddFilesToCompile(cmd);
return executeExternalCompile(cmd.getCommandline(), firstFileName) == 0;
}
private void addPropertyParams(Commandline cmd) {
/*
* TODO
* Perhaps we shouldn't use properties for these
* three options (emacs mode, warnings and pedantic),
* but include it in the javac directive?
*/
/**
* Jikes has the nice feature to print error
* messages in a form readable by emacs, so
* that emacs can directly set the cursor
* to the place, where the error occurred.
*/
String emacsProperty = project.getProperty("build.compiler.emacs");
if (emacsProperty != null && Project.toBoolean(emacsProperty)) {
cmd.createArgument().setValue("+E");
}
/**
* Jikes issues more warnings that javac, for
* example, when you have files in your classpath
* that don't exist. As this is often the case, these
* warning can be pretty annoying.
*/
String warningsProperty = project.getProperty("build.compiler.warnings");
if (warningsProperty != null) {
attributes.log("!! the build.compiler.warnings property is " + "deprecated. !!",
Project.MSG_WARN);
attributes.log("!! Use the nowarn attribute instead. !!", Project.MSG_WARN);
if (!Project.toBoolean(warningsProperty)) {
cmd.createArgument().setValue("-nowarn");
}
}
if (attributes.getNowarn()) {
cmd.createArgument().setValue("-nowarn");
}
/**
* Jikes can issue pedantic warnings.
*/
String pedanticProperty = project.getProperty("build.compiler.pedantic");
if (pedanticProperty != null && Project.toBoolean(pedanticProperty)) {
cmd.createArgument().setValue("+P");
}
/**
* Jikes supports something it calls "full dependency
* checking", see the jikes documentation for differences
* between -depend and +F.
*/
String fullDependProperty = project.getProperty("build.compiler.fulldepend");
if (fullDependProperty != null
&& Project.toBoolean(fullDependProperty)) {
cmd.createArgument().setValue("+F");
}
}
}