| Methods Summary |
|---|
| protected void | addCurrentCompilerArgs(org.apache.tools.ant.types.Commandline cmd)Adds the command line arguments specific to the current implementation.
cmd.addArguments(getJavac().getCurrentCompilerArgs());
|
| protected void | addExtdirsToClasspath(org.apache.tools.ant.types.Path classpath)Add extdirs to classpath
classpath.addExtdirs(extdirs);
|
| protected boolean | assumeJava11()Shall we assume JDK 1.1 command line switches?
return "javac1.1".equals(attributes.getCompilerVersion());
|
| protected boolean | assumeJava12()Shall we assume JDK 1.2 command line switches?
return "javac1.2".equals(attributes.getCompilerVersion())
|| ("classic".equals(attributes.getCompilerVersion())
&& JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_2))
|| ("extJavac".equals(attributes.getCompilerVersion())
&& JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_2));
|
| protected boolean | assumeJava13()Shall we assume JDK 1.3 command line switches?
return "javac1.3".equals(attributes.getCompilerVersion())
|| ("classic".equals(attributes.getCompilerVersion())
&& JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_3))
|| ("modern".equals(attributes.getCompilerVersion())
&& JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_3))
|| ("extJavac".equals(attributes.getCompilerVersion())
&& JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_3));
|
| protected boolean | assumeJava14()Shall we assume JDK 1.4 command line switches?
return "javac1.4".equals(attributes.getCompilerVersion())
|| ("classic".equals(attributes.getCompilerVersion())
&& JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_4))
|| ("modern".equals(attributes.getCompilerVersion())
&& JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_4))
|| ("extJavac".equals(attributes.getCompilerVersion())
&& JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_4));
|
| protected boolean | assumeJava15()Shall we assume JDK 1.5 command line switches?
return "javac1.5".equals(attributes.getCompilerVersion())
|| ("classic".equals(attributes.getCompilerVersion())
&& JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_5))
|| ("modern".equals(attributes.getCompilerVersion())
&& JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_5))
|| ("extJavac".equals(attributes.getCompilerVersion())
&& JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_5));
|
| protected boolean | assumeJava16()Shall we assume JDK 1.6 command line switches?
return "javac1.6".equals(attributes.getCompilerVersion())
|| ("classic".equals(attributes.getCompilerVersion())
&& JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_6))
|| ("modern".equals(attributes.getCompilerVersion())
&& JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_6))
|| ("extJavac".equals(attributes.getCompilerVersion())
&& JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_6));
|
| protected int | executeExternalCompile(java.lang.String[] args, int firstFileName)Do the compile with the specified arguments.
return executeExternalCompile(args, firstFileName, true);
|
| protected int | executeExternalCompile(java.lang.String[] args, int firstFileName, boolean quoteFiles)Do the compile with the specified arguments.
String[] commandArray = null;
File tmpFile = null;
try {
/*
* Many system have been reported to get into trouble with
* long command lines - no, not only Windows ;-).
*
* POSIX seems to define a lower limit of 4k, so use a temporary
* file if the total length of the command line exceeds this limit.
*/
if (Commandline.toString(args).length() > 4096
&& firstFileName >= 0) {
PrintWriter out = null;
try {
tmpFile = FILE_UTILS.createTempFile(
"files", "", getJavac().getTempdir());
tmpFile.deleteOnExit();
out = new PrintWriter(new FileWriter(tmpFile));
for (int i = firstFileName; i < args.length; i++) {
if (quoteFiles && args[i].indexOf(" ") > -1) {
args[i] = args[i].replace(File.separatorChar, '/");
out.println("\"" + args[i] + "\"");
} else {
out.println(args[i]);
}
}
out.flush();
commandArray = new String[firstFileName + 1];
System.arraycopy(args, 0, commandArray, 0, firstFileName);
commandArray[firstFileName] = "@" + tmpFile;
} catch (IOException e) {
throw new BuildException("Error creating temporary file",
e, location);
} finally {
FileUtils.close(out);
}
} else {
commandArray = args;
}
try {
Execute exe = new Execute(
new LogStreamHandler(attributes,
Project.MSG_INFO,
Project.MSG_WARN));
if (Os.isFamily("openvms")) {
//Use the VM launcher instead of shell launcher on VMS
//for java
exe.setVMLauncher(true);
}
exe.setAntRun(project);
exe.setWorkingDirectory(project.getBaseDir());
exe.setCommandline(commandArray);
exe.execute();
return exe.getExitValue();
} catch (IOException e) {
throw new BuildException("Error running " + args[0]
+ " compiler", e, location);
}
} finally {
if (tmpFile != null) {
tmpFile.delete();
}
}
|
| protected org.apache.tools.ant.types.Path | getBootClassPath()Combines a user specified bootclasspath with the system
bootclasspath taking build.sysclasspath into account.
Path bp = new Path(project);
if (bootclasspath != null) {
bp.append(bootclasspath);
}
return bp.concatSystemBootClasspath("ignore");
|
| protected org.apache.tools.ant.types.Path | getCompileClasspath()Builds the compilation classpath.
Path classpath = new Path(project);
// add dest dir to classpath so that previously compiled and
// untouched classes are on classpath
if (destDir != null) {
classpath.setLocation(destDir);
}
// Combine the build classpath with the system classpath, in an
// order determined by the value of build.sysclasspath
Path cp = compileClasspath;
if (cp == null) {
cp = new Path(project);
}
if (includeAntRuntime) {
classpath.addExisting(cp.concatSystemClasspath("last"));
} else {
classpath.addExisting(cp.concatSystemClasspath("ignore"));
}
if (includeJavaRuntime) {
classpath.addJavaRuntime();
}
return classpath;
|
| public org.apache.tools.ant.taskdefs.Javac | getJavac()Get the Javac task instance associated with this compiler adapter
return attributes;
|
| protected java.lang.String | getNoDebugArgument()The argument the compiler wants to see if the debug attribute
has been set to false.
A return value of null means no argument at all.
return assumeJava11() ? null : "-g:none";
|
| protected org.apache.tools.ant.Project | getProject()Get the project this compiler adapter was created in.
return project;
|
| protected void | logAndAddFilesToCompile(org.apache.tools.ant.types.Commandline cmd)Logs the compilation parameters, adds the files to compile and logs the
"niceSourceList"
attributes.log("Compilation " + cmd.describeArguments(),
Project.MSG_VERBOSE);
StringBuffer niceSourceList = new StringBuffer("File");
if (compileList.length != 1) {
niceSourceList.append("s");
}
niceSourceList.append(" to be compiled:");
niceSourceList.append(StringUtils.LINE_SEP);
for (int i = 0; i < compileList.length; i++) {
String arg = compileList[i].getAbsolutePath();
cmd.createArgument().setValue(arg);
niceSourceList.append(" ");
niceSourceList.append(arg);
niceSourceList.append(StringUtils.LINE_SEP);
}
attributes.log(niceSourceList.toString(), Project.MSG_VERBOSE);
|
| public void | setJavac(org.apache.tools.ant.taskdefs.Javac attributes)Set the Javac instance which contains the configured compilation
attributes.
// CheckStyle:ConstantNameCheck ON
// CheckStyle:VisibilityModifier ON
this.attributes = attributes;
src = attributes.getSrcdir();
destDir = attributes.getDestdir();
encoding = attributes.getEncoding();
debug = attributes.getDebug();
optimize = attributes.getOptimize();
deprecation = attributes.getDeprecation();
depend = attributes.getDepend();
verbose = attributes.getVerbose();
target = attributes.getTarget();
bootclasspath = attributes.getBootclasspath();
extdirs = attributes.getExtdirs();
compileList = attributes.getFileList();
compileClasspath = attributes.getClasspath();
compileSourcepath = attributes.getSourcepath();
project = attributes.getProject();
location = attributes.getLocation();
includeAntRuntime = attributes.getIncludeantruntime();
includeJavaRuntime = attributes.getIncludejavaruntime();
memoryInitialSize = attributes.getMemoryInitialSize();
memoryMaximumSize = attributes.getMemoryMaximumSize();
|
| protected org.apache.tools.ant.types.Commandline | setupJavacCommand(boolean debugLevelCheck)Does the command line argument processing for classic and adds
the files to compile as well.
Commandline cmd = new Commandline();
setupJavacCommandlineSwitches(cmd, debugLevelCheck);
logAndAddFilesToCompile(cmd);
return cmd;
|
| protected org.apache.tools.ant.types.Commandline | setupJavacCommand()Set up the command line.
return setupJavacCommand(false);
|
| protected org.apache.tools.ant.types.Commandline | setupJavacCommandlineSwitches(org.apache.tools.ant.types.Commandline cmd)Get the command line arguments for the switches.
return setupJavacCommandlineSwitches(cmd, false);
|
| protected org.apache.tools.ant.types.Commandline | setupJavacCommandlineSwitches(org.apache.tools.ant.types.Commandline cmd, boolean useDebugLevel)Does the command line argument processing common to classic and
modern. Doesn't add the files to compile.
Path classpath = getCompileClasspath();
// 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;
}
String memoryParameterPrefix = assumeJava11() ? "-J-" : "-J-X";
if (memoryInitialSize != null) {
if (!attributes.isForkedJavac()) {
attributes.log("Since fork is false, ignoring "
+ "memoryInitialSize setting.",
Project.MSG_WARN);
} else {
cmd.createArgument().setValue(memoryParameterPrefix
+ "ms" + memoryInitialSize);
}
}
if (memoryMaximumSize != null) {
if (!attributes.isForkedJavac()) {
attributes.log("Since fork is false, ignoring "
+ "memoryMaximumSize setting.",
Project.MSG_WARN);
} else {
cmd.createArgument().setValue(memoryParameterPrefix
+ "mx" + memoryMaximumSize);
}
}
if (attributes.getNowarn()) {
cmd.createArgument().setValue("-nowarn");
}
if (deprecation) {
cmd.createArgument().setValue("-deprecation");
}
if (destDir != null) {
cmd.createArgument().setValue("-d");
cmd.createArgument().setFile(destDir);
}
cmd.createArgument().setValue("-classpath");
// Just add "sourcepath" to classpath ( for JDK1.1 )
// as well as "bootclasspath" and "extdirs"
if (assumeJava11()) {
Path cp = new Path(project);
Path bp = getBootClassPath();
if (bp.size() > 0) {
cp.append(bp);
}
if (extdirs != null) {
cp.addExtdirs(extdirs);
}
cp.append(classpath);
cp.append(sourcepath);
cmd.createArgument().setPath(cp);
} else {
cmd.createArgument().setPath(classpath);
// If the buildfile specifies sourcepath="", then don't
// output any sourcepath.
if (sourcepath.size() > 0) {
cmd.createArgument().setValue("-sourcepath");
cmd.createArgument().setPath(sourcepath);
}
if (target != null) {
cmd.createArgument().setValue("-target");
cmd.createArgument().setValue(target);
}
Path bp = getBootClassPath();
if (bp.size() > 0) {
cmd.createArgument().setValue("-bootclasspath");
cmd.createArgument().setPath(bp);
}
if (extdirs != null && extdirs.size() > 0) {
cmd.createArgument().setValue("-extdirs");
cmd.createArgument().setPath(extdirs);
}
}
if (encoding != null) {
cmd.createArgument().setValue("-encoding");
cmd.createArgument().setValue(encoding);
}
if (debug) {
if (useDebugLevel && !assumeJava11()) {
String debugLevel = attributes.getDebugLevel();
if (debugLevel != null) {
cmd.createArgument().setValue("-g:" + debugLevel);
} else {
cmd.createArgument().setValue("-g");
}
} else {
cmd.createArgument().setValue("-g");
}
} else if (getNoDebugArgument() != null) {
cmd.createArgument().setValue(getNoDebugArgument());
}
if (optimize) {
cmd.createArgument().setValue("-O");
}
if (depend) {
if (assumeJava11()) {
cmd.createArgument().setValue("-depend");
} else if (assumeJava12()) {
cmd.createArgument().setValue("-Xdepend");
} else {
attributes.log("depend attribute is not supported by the "
+ "modern compiler", Project.MSG_WARN);
}
}
if (verbose) {
cmd.createArgument().setValue("-verbose");
}
addCurrentCompilerArgs(cmd);
return cmd;
|
| protected org.apache.tools.ant.types.Commandline | setupModernJavacCommand()Does the command line argument processing for modern and adds
the files to compile as well.
Commandline cmd = new Commandline();
setupModernJavacCommandlineSwitches(cmd);
logAndAddFilesToCompile(cmd);
return cmd;
|
| protected org.apache.tools.ant.types.Commandline | setupModernJavacCommandlineSwitches(org.apache.tools.ant.types.Commandline cmd)Does the command line argument processing for modern. Doesn't
add the files to compile.
setupJavacCommandlineSwitches(cmd, true);
if (attributes.getSource() != null && !assumeJava13()) {
cmd.createArgument().setValue("-source");
String source = attributes.getSource();
if ((assumeJava14() || assumeJava15())
&& (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 - and isn't present in 1.5.0 either
cmd.createArgument().setValue("1.3");
} else {
cmd.createArgument().setValue(source);
}
} else if ((assumeJava15() || assumeJava16())
&& attributes.getTarget() != null) {
String t = attributes.getTarget();
if (t.equals("1.1") || t.equals("1.2") || t.equals("1.3")
|| t.equals("1.4")) {
String s = t;
if (t.equals("1.1")) {
// 1.5.0 doesn't support -source 1.1
s = "1.2";
}
attributes.log("", Project.MSG_WARN);
attributes.log(" WARNING", Project.MSG_WARN);
attributes.log("", Project.MSG_WARN);
attributes.log("The -source switch defaults to 1.5 in JDK 1.5 and 1.6.",
Project.MSG_WARN);
attributes.log("If you specify -target " + t
+ " you now must also specify -source " + s
+ ".", Project.MSG_WARN);
attributes.log("Ant will implicitly add -source " + s
+ " for you. Please change your build file.",
Project.MSG_WARN);
cmd.createArgument().setValue("-source");
cmd.createArgument().setValue(s);
}
}
return cmd;
|
