| Methods Summary |
|---|
| private void | addExistingToClasspath(java.lang.StringBuffer target, java.lang.String source)Takes a classpath-like string, and adds each element of this string to
a new classpath, if the components exist. Components that don't exist,
aren't added. We do this, because jikes issues warnings for
non-existant files/dirs in his classpath, and these warnings are pretty
annoying.
StringTokenizer tok = new StringTokenizer(source,
System.getProperty("path.separator"), false);
while (tok.hasMoreTokens()) {
File f = getProject().resolveFile(tok.nextToken());
if (f.exists()) {
target.append(File.pathSeparator);
target.append(f.getAbsolutePath());
} else {
log("Dropping from classpath: "
+ f.getAbsolutePath(), Project.MSG_VERBOSE);
}
}
|
| private void | copyFilesToDestination()Copy eligible files from the srcDir to destDir
if (filecopyList.size() > 0) {
log("Copying " + filecopyList.size() + " file"
+ (filecopyList.size() == 1 ? "" : "s")
+ " to " + destDir.getAbsolutePath());
Enumeration e = filecopyList.keys();
while (e.hasMoreElements()) {
String fromFile = (String) e.nextElement();
String toFile = (String) filecopyList.get(fromFile);
try {
FileUtils.getFileUtils().copyFile(fromFile, toFile);
} catch (IOException ioe) {
String msg = "Failed to copy " + fromFile + " to " + toFile
+ " due to " + ioe.getMessage();
throw new BuildException(msg, ioe);
}
}
}
|
| private void | doNetRexxCompile()Performs a compile using the NetRexx 1.1.x compiler
log("Using NetRexx compiler", Project.MSG_VERBOSE);
String classpath = getCompileClasspath();
StringBuffer compileOptions = new StringBuffer();
// create an array of strings for input to the compiler: one array
// comes from the compile options, the other from the compileList
String[] compileOptionsArray = getCompileOptionsAsArray();
String[] fileListArray = new String[compileList.size()];
Enumeration e = compileList.elements();
int j = 0;
while (e.hasMoreElements()) {
fileListArray[j] = (String) e.nextElement();
j++;
}
// create a single array of arguments for the compiler
String[] compileArgs = new String[compileOptionsArray.length + fileListArray.length];
for (int i = 0; i < compileOptionsArray.length; i++) {
compileArgs[i] = compileOptionsArray[i];
}
for (int i = 0; i < fileListArray.length; i++) {
compileArgs[i + compileOptionsArray.length] = fileListArray[i];
}
// print nice output about what we are doing for the log
compileOptions.append("Compilation args: ");
for (int i = 0; i < compileOptionsArray.length; i++) {
compileOptions.append(compileOptionsArray[i]);
compileOptions.append(" ");
}
log(compileOptions.toString(), Project.MSG_VERBOSE);
String eol = System.getProperty("line.separator");
StringBuffer niceSourceList = new StringBuffer("Files to be compiled:" + eol);
for (int i = 0; i < compileList.size(); i++) {
niceSourceList.append(" ");
niceSourceList.append(compileList.elementAt(i).toString());
niceSourceList.append(eol);
}
log(niceSourceList.toString(), Project.MSG_VERBOSE);
// need to set java.class.path property and restore it later
// since the NetRexx compiler has no option for the classpath
String currentClassPath = System.getProperty("java.class.path");
Properties currentProperties = System.getProperties();
currentProperties.put("java.class.path", classpath);
try {
StringWriter out = new StringWriter();
int rc =
COM.ibm.netrexx.process.NetRexxC.main(new Rexx(compileArgs), new PrintWriter(out));
String sdir = srcDir.getAbsolutePath();
String ddir = destDir.getAbsolutePath();
boolean doReplace = !(sdir.equals(ddir));
int dlen = ddir.length();
String l;
BufferedReader in = new BufferedReader(new StringReader(out.toString()));
log("replacing destdir '" + ddir + "' through sourcedir '"
+ sdir + "'", Project.MSG_VERBOSE);
while ((l = in.readLine()) != null) {
int idx;
while (doReplace && ((idx = l.indexOf(ddir)) != -1)) {
// path is mentioned in the message
l = (new StringBuffer(l)).replace(idx, idx + dlen, sdir).toString();
}
// verbose level logging for suppressed messages
if (suppressMethodArgumentNotUsed
&& l.indexOf(MSG_METHOD_ARGUMENT_NOT_USED) != -1) {
log(l, Project.MSG_VERBOSE);
} else if (suppressPrivatePropertyNotUsed
&& l.indexOf(MSG_PRIVATE_PROPERTY_NOT_USED) != -1) {
log(l, Project.MSG_VERBOSE);
} else if (suppressVariableNotUsed
&& l.indexOf(MSG_VARIABLE_NOT_USED) != -1) {
log(l, Project.MSG_VERBOSE);
} else if (suppressExceptionNotSignalled
&& l.indexOf(MSG_EXCEPTION_NOT_SIGNALLED) != -1) {
log(l, Project.MSG_VERBOSE);
} else if (suppressDeprecation
&& l.indexOf(MSG_DEPRECATION) != -1) {
log(l, Project.MSG_VERBOSE);
} else if (l.indexOf("Error:") != -1) {
// error level logging for compiler errors
log(l, Project.MSG_ERR);
} else if (l.indexOf("Warning:") != -1) {
// warning for all warning messages
log(l, Project.MSG_WARN);
} else {
log(l, Project.MSG_INFO); // info level for the rest.
}
}
if (rc > 1) {
throw new BuildException("Compile failed, messages should "
+ "have been provided.");
}
} catch (IOException ioe) {
throw new BuildException("Unexpected IOException while "
+ "playing with Strings", ioe);
} finally {
// need to reset java.class.path property
// since the NetRexx compiler has no option for the classpath
currentProperties = System.getProperties();
currentProperties.put("java.class.path", currentClassPath);
}
|
| public void | execute()Executes the task - performs the actual compiler call.
// first off, make sure that we've got a srcdir and destdir
if (srcDir == null || destDir == null) {
throw new BuildException("srcDir and destDir attributes must be set!");
}
// scan source and dest dirs to build up both copy lists and
// compile lists
// scanDir(srcDir, destDir);
DirectoryScanner ds = getDirectoryScanner(srcDir);
String[] files = ds.getIncludedFiles();
scanDir(srcDir, destDir, files);
// copy the source and support files
copyFilesToDestination();
// compile the source files
if (compileList.size() > 0) {
log("Compiling " + compileList.size() + " source file"
+ (compileList.size() == 1 ? "" : "s")
+ " to " + destDir);
doNetRexxCompile();
}
|
| private java.lang.String | getCompileClasspath()Builds the compilation classpath.
StringBuffer classpath = new StringBuffer();
// add dest dir to classpath so that previously compiled and
// untouched classes are on classpath
classpath.append(destDir.getAbsolutePath());
// add our classpath to the mix
if (this.classpath != null) {
addExistingToClasspath(classpath, this.classpath);
}
// add the system classpath
// addExistingToClasspath(classpath,System.getProperty("java.class.path"));
return classpath.toString();
|
| private java.lang.String[] | getCompileOptionsAsArray()This
Vector options = new Vector();
options.addElement(binary ? "-binary" : "-nobinary");
options.addElement(comments ? "-comments" : "-nocomments");
options.addElement(compile ? "-compile" : "-nocompile");
options.addElement(compact ? "-compact" : "-nocompact");
options.addElement(console ? "-console" : "-noconsole");
options.addElement(crossref ? "-crossref" : "-nocrossref");
options.addElement(decimal ? "-decimal" : "-nodecimal");
options.addElement(diag ? "-diag" : "-nodiag");
options.addElement(explicit ? "-explicit" : "-noexplicit");
options.addElement(format ? "-format" : "-noformat");
options.addElement(keep ? "-keep" : "-nokeep");
options.addElement(logo ? "-logo" : "-nologo");
options.addElement(replace ? "-replace" : "-noreplace");
options.addElement(savelog ? "-savelog" : "-nosavelog");
options.addElement(sourcedir ? "-sourcedir" : "-nosourcedir");
options.addElement(strictargs ? "-strictargs" : "-nostrictargs");
options.addElement(strictassign ? "-strictassign" : "-nostrictassign");
options.addElement(strictcase ? "-strictcase" : "-nostrictcase");
options.addElement(strictimport ? "-strictimport" : "-nostrictimport");
options.addElement(strictprops ? "-strictprops" : "-nostrictprops");
options.addElement(strictsignal ? "-strictsignal" : "-nostrictsignal");
options.addElement(symbols ? "-symbols" : "-nosymbols");
options.addElement(time ? "-time" : "-notime");
options.addElement("-" + trace);
options.addElement(utf8 ? "-utf8" : "-noutf8");
options.addElement("-" + verbose);
String[] results = new String[options.size()];
options.copyInto(results);
return results;
|
| public void | init()init-Method sets defaults from Properties. That way, when ant is called
with arguments like -Dant.netrexxc.verbose=verbose5 one can easily take
control of all netrexxc-tasks.
String p;
if ((p = getProject().getProperty("ant.netrexxc.binary")) != null) {
this.binary = Project.toBoolean(p);
}
// classpath makes no sense
if ((p = getProject().getProperty("ant.netrexxc.comments")) != null) {
this.comments = Project.toBoolean(p);
}
if ((p = getProject().getProperty("ant.netrexxc.compact")) != null) {
this.compact = Project.toBoolean(p);
}
if ((p = getProject().getProperty("ant.netrexxc.compile")) != null) {
this.compile = Project.toBoolean(p);
}
if ((p = getProject().getProperty("ant.netrexxc.console")) != null) {
this.console = Project.toBoolean(p);
}
if ((p = getProject().getProperty("ant.netrexxc.crossref")) != null) {
this.crossref = Project.toBoolean(p);
}
if ((p = getProject().getProperty("ant.netrexxc.decimal")) != null) {
this.decimal = Project.toBoolean(p);
// destDir
}
if ((p = getProject().getProperty("ant.netrexxc.diag")) != null) {
this.diag = Project.toBoolean(p);
}
if ((p = getProject().getProperty("ant.netrexxc.explicit")) != null) {
this.explicit = Project.toBoolean(p);
}
if ((p = getProject().getProperty("ant.netrexxc.format")) != null) {
this.format = Project.toBoolean(p);
}
if ((p = getProject().getProperty("ant.netrexxc.keep")) != null) {
this.keep = Project.toBoolean(p);
}
if ((p = getProject().getProperty("ant.netrexxc.logo")) != null) {
this.logo = Project.toBoolean(p);
}
if ((p = getProject().getProperty("ant.netrexxc.replace")) != null) {
this.replace = Project.toBoolean(p);
}
if ((p = getProject().getProperty("ant.netrexxc.savelog")) != null) {
this.savelog = Project.toBoolean(p);
// srcDir
}
if ((p = getProject().getProperty("ant.netrexxc.sourcedir")) != null) {
this.sourcedir = Project.toBoolean(p);
}
if ((p = getProject().getProperty("ant.netrexxc.strictargs")) != null) {
this.strictargs = Project.toBoolean(p);
}
if ((p = getProject().getProperty("ant.netrexxc.strictassign")) != null) {
this.strictassign = Project.toBoolean(p);
}
if ((p = getProject().getProperty("ant.netrexxc.strictcase")) != null) {
this.strictcase = Project.toBoolean(p);
}
if ((p = getProject().getProperty("ant.netrexxc.strictimport")) != null) {
this.strictimport = Project.toBoolean(p);
}
if ((p = getProject().getProperty("ant.netrexxc.strictprops")) != null) {
this.strictprops = Project.toBoolean(p);
}
if ((p = getProject().getProperty("ant.netrexxc.strictsignal")) != null) {
this.strictsignal = Project.toBoolean(p);
}
if ((p = getProject().getProperty("ant.netrexxc.symbols")) != null) {
this.symbols = Project.toBoolean(p);
}
if ((p = getProject().getProperty("ant.netrexxc.time")) != null) {
this.time = Project.toBoolean(p);
}
if ((p = getProject().getProperty("ant.netrexxc.trace")) != null) {
setTrace(p);
}
if ((p = getProject().getProperty("ant.netrexxc.utf8")) != null) {
this.utf8 = Project.toBoolean(p);
}
if ((p = getProject().getProperty("ant.netrexxc.verbose")) != null) {
setVerbose(p);
}
if ((p = getProject().getProperty("ant.netrexxc.suppressMethodArgumentNotUsed")) != null) {
this.suppressMethodArgumentNotUsed = Project.toBoolean(p);
}
if ((p = getProject().getProperty("ant.netrexxc.suppressPrivatePropertyNotUsed")) != null) {
this.suppressPrivatePropertyNotUsed = Project.toBoolean(p);
}
if ((p = getProject().getProperty("ant.netrexxc.suppressVariableNotUsed")) != null) {
this.suppressVariableNotUsed = Project.toBoolean(p);
}
if ((p = getProject().getProperty("ant.netrexxc.suppressExceptionNotSignalled")) != null) {
this.suppressExceptionNotSignalled = Project.toBoolean(p);
}
if ((p = getProject().getProperty("ant.netrexxc.suppressDeprecation")) != null) {
this.suppressDeprecation = Project.toBoolean(p);
}
|
| private void | scanDir(java.io.File srcDir, java.io.File destDir, java.lang.String[] files)Scans the directory looking for source files to be compiled and support
files to be copied.
for (int i = 0; i < files.length; i++) {
File srcFile = new File(srcDir, files[i]);
File destFile = new File(destDir, files[i]);
String filename = files[i];
// if it's a non source file, copy it if a later date than the
// dest
// if it's a source file, see if the destination class file
// needs to be recreated via compilation
if (filename.toLowerCase().endsWith(".nrx")) {
File classFile =
new File(destDir,
filename.substring(0, filename.lastIndexOf('.")) + ".class");
if (!compile || srcFile.lastModified() > classFile.lastModified()) {
filecopyList.put(srcFile.getAbsolutePath(), destFile.getAbsolutePath());
compileList.addElement(destFile.getAbsolutePath());
}
} else {
if (srcFile.lastModified() > destFile.lastModified()) {
filecopyList.put(srcFile.getAbsolutePath(), destFile.getAbsolutePath());
}
}
}
|
| public void | setBinary(boolean binary)Set whether literals are treated as binary, rather than NetRexx types.
this.binary = binary;
|
| public void | setClasspath(java.lang.String classpath)Set the classpath used for NetRexx compilation.
this.classpath = classpath;
|
| public void | setComments(boolean comments)Set whether comments are passed through to the generated java source.
Valid true values are "on" or "true". Anything else sets the flag to
false. The default value is false
this.comments = comments;
|
| public void | setCompact(boolean compact)Set whether error messages come out in compact or verbose format. Valid
true values are "on" or "true". Anything else sets the flag to false.
The default value is false
this.compact = compact;
|
| public void | setCompile(boolean compile)Set whether the NetRexx compiler should compile the generated java code
Valid true values are "on" or "true". Anything else sets the flag to
false. The default value is true. Setting this flag to false, will
automatically set the keep flag to true.
this.compile = compile;
if (!this.compile && !this.keep) {
this.keep = true;
}
|
| public void | setConsole(boolean console)Set whether or not messages should be displayed on the 'console' Valid
true values are "on" or "true". Anything else sets the flag to false.
The default value is true.
this.console = console;
|
| public void | setCrossref(boolean crossref)Whether variable cross references are generated.
this.crossref = crossref;
|
| public void | setDecimal(boolean decimal)Set whether decimal arithmetic should be used for the netrexx code.
Binary arithmetic is used when this flag is turned off. Valid true
values are "on" or "true". Anything else sets the flag to false. The
default value is true.
this.decimal = decimal;
|
| public void | setDestDir(java.io.File destDirName)Set the destination directory into which the NetRexx source files
should be copied and then compiled.
destDir = destDirName;
|
| public void | setDiag(boolean diag)Whether diagnostic information about the compile is generated
this.diag = diag;
|
| public void | setExplicit(boolean explicit)Sets whether variables must be declared explicitly before use. Valid
true values are "on" or "true". Anything else sets the flag to false.
The default value is false.
this.explicit = explicit;
|
| public void | setFormat(boolean format)Whether the generated java code is formatted nicely or left to match
NetRexx line numbers for call stack debugging.
this.format = format;
|
| public void | setJava(boolean java)Whether the generated java code is produced Valid true values are "on"
or "true". Anything else sets the flag to false. The default value is
false.
log("The attribute java is currently unused.", Project.MSG_WARN);
|
| public void | setKeep(boolean keep)Sets whether the generated java source file should be kept after
compilation. The generated files will have an extension of .java.keep,
not .java Valid true values are "on" or "true". Anything else
sets the flag to false. The default value is false.
this.keep = keep;
|
| public void | setLogo(boolean logo)Whether the compiler text logo is displayed when compiling.
this.logo = logo;
|
| public void | setReplace(boolean replace)Whether the generated .java file should be replaced when compiling
Valid true values are "on" or "true". Anything else sets the flag to
false. The default value is false.
this.replace = replace;
|
| public void | setSavelog(boolean savelog)Sets whether the compiler messages will be written to NetRexxC.log as
well as to the console Valid true values are "on" or "true". Anything
else sets the flag to false. The default value is false.
this.savelog = savelog;
|
| public void | setSourcedir(boolean sourcedir)Tells the NetRexx compiler to store the class files in the same
directory as the source files. The alternative is the working directory
Valid true values are "on" or "true". Anything else sets the flag to
false. The default value is true.
this.sourcedir = sourcedir;
|
| public void | setSrcDir(java.io.File srcDirName)Set the source dir to find the source Java files.
srcDir = srcDirName;
|
| public void | setStrictargs(boolean strictargs)Tells the NetRexx compiler that method calls always need parentheses,
even if no arguments are needed, e.g. aStringVar.getBytes
vs. aStringVar.getBytes() Valid true values are "on" or
"true". Anything else sets the flag to false. The default value is
false.
this.strictargs = strictargs;
|
| public void | setStrictassign(boolean strictassign)Tells the NetRexx compile that assignments must match exactly on type.
this.strictassign = strictassign;
|
| public void | setStrictcase(boolean strictcase)Specifies whether the NetRexx compiler should be case sensitive or not.
this.strictcase = strictcase;
|
| public void | setStrictimport(boolean strictimport)Sets whether classes need to be imported explicitly using an import
statement. By default the NetRexx compiler will import certain packages
automatically Valid true values are "on" or "true". Anything else sets
the flag to false. The default value is false.
this.strictimport = strictimport;
|
| public void | setStrictprops(boolean strictprops)Sets whether local properties need to be qualified explicitly using
this Valid true values are "on" or "true". Anything else
sets the flag to false. The default value is false.
this.strictprops = strictprops;
|
| public void | setStrictsignal(boolean strictsignal)Whether the compiler should force catching of exceptions by explicitly
named types.
this.strictsignal = strictsignal;
|
| public void | setSuppressDeprecation(boolean suppressDeprecation)Tells whether we should filter out any deprecation-messages
of the compiler out.
this.suppressDeprecation = suppressDeprecation;
|
| public void | setSuppressExceptionNotSignalled(boolean suppressExceptionNotSignalled)Whether the task should suppress the "FooException is in SIGNALS list
but is not signalled within the method", which is sometimes rather
useless. The warning is logged as verbose message, though.
this.suppressExceptionNotSignalled = suppressExceptionNotSignalled;
|
| public void | setSuppressMethodArgumentNotUsed(boolean suppressMethodArgumentNotUsed)Whether the task should suppress the "Method argument is not used" in
strictargs-Mode, which can not be suppressed by the compiler itself.
The warning is logged as verbose message, though.
this.suppressMethodArgumentNotUsed = suppressMethodArgumentNotUsed;
|
| public void | setSuppressPrivatePropertyNotUsed(boolean suppressPrivatePropertyNotUsed)Whether the task should suppress the "Private property is defined but
not used" in strictargs-Mode, which can be quite annoying while
developing. The warning is logged as verbose message, though.
this.suppressPrivatePropertyNotUsed = suppressPrivatePropertyNotUsed;
|
| public void | setSuppressVariableNotUsed(boolean suppressVariableNotUsed)Whether the task should suppress the "Variable is set but not used" in
strictargs-Mode. Be careful with this one! The warning is logged as
verbose message, though.
this.suppressVariableNotUsed = suppressVariableNotUsed;
|
| public void | setSymbols(boolean symbols)Sets whether debug symbols should be generated into the class file
Valid true values are "on" or "true". Anything else sets the flag to
false. The default value is false.
this.symbols = symbols;
|
| public void | setTime(boolean time)Asks the NetRexx compiler to print compilation times to the console
Valid true values are "on" or "true". Anything else sets the flag to
false. The default value is false.
this.time = time;
|
| public void | setTrace(org.apache.tools.ant.taskdefs.optional.NetRexxC$TraceAttr trace)Turns on or off tracing and directs the resultant trace output Valid
values are: "trace", "trace1", "trace2" and "notrace". "trace" and
"trace2".
this.trace = trace.getValue();
|
| public void | setTrace(java.lang.String trace)Turns on or off tracing and directs the resultant trace output Valid
values are: "trace", "trace1", "trace2" and "notrace". "trace" and
"trace2".
TraceAttr t = new TraceAttr();
t.setValue(trace);
setTrace(t);
|
| public void | setUtf8(boolean utf8)Tells the NetRexx compiler that the source is in UTF8 Valid true values
are "on" or "true". Anything else sets the flag to false. The default
value is false.
this.utf8 = utf8;
|
| public void | setVerbose(org.apache.tools.ant.taskdefs.optional.NetRexxC$VerboseAttr verbose)Whether lots of warnings and error messages should be generated
this.verbose = verbose.getValue();
|
| public void | setVerbose(java.lang.String verbose)Whether lots of warnings and error messages should be generated
VerboseAttr v = new VerboseAttr();
v.setValue(verbose);
setVerbose(v);
|
