| /* |
| * 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 |
| * |
| * https://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"); |
| } |
| } |
| |
| } |