diff options
Diffstat (limited to 'framework/src/ant/apache-ant-1.9.6/src/main/org/apache/tools/ant/taskdefs/compilers/Jikes.java')
-rw-r--r-- | framework/src/ant/apache-ant-1.9.6/src/main/org/apache/tools/ant/taskdefs/compilers/Jikes.java | 221 |
1 files changed, 221 insertions, 0 deletions
diff --git a/framework/src/ant/apache-ant-1.9.6/src/main/org/apache/tools/ant/taskdefs/compilers/Jikes.java b/framework/src/ant/apache-ant-1.9.6/src/main/org/apache/tools/ant/taskdefs/compilers/Jikes.java new file mode 100644 index 00000000..eac1bcfc --- /dev/null +++ b/framework/src/ant/apache-ant-1.9.6/src/main/org/apache/tools/ant/taskdefs/compilers/Jikes.java @@ -0,0 +1,221 @@ +/* + * 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 + */ + 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 = null; + if (compileSourcepath != null) { + sourcepath = compileSourcepath; + } else { + sourcepath = src; + } + // If the buildfile specifies sourcepath="", then don't + // output any sourcepath. + if (sourcepath.size() > 0) { + cmd.createArgument().setValue("-sourcepath"); + cmd.createArgument().setPath(sourcepath); + } + + Path classpath = new Path(project); + + if (bootclasspath == null || bootclasspath.size() == 0) { + // 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.size() > 0) { + 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 (source.equals("1.1") || source.equals("1.2")) { + // 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.size() > 0) { + 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"); + } + } + +} |