aboutsummaryrefslogtreecommitdiffstats
path: root/framework/src/ant/apache-ant-1.9.6/src/main/org/apache/tools/ant/taskdefs/compilers/Jikes.java
diff options
context:
space:
mode:
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.java221
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");
+ }
+ }
+
+}