| /* |
| * Copyright 2000-2004 The Apache Software Foundation |
| * |
| * Licensed 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. |
| * |
| * 2006-12-29: Modified to work for antlr3 by Jürgen Pfundt |
| * 2007-01-04: Some minor correction after checking code with findBugs tool |
| * 2007-02-10: Adapted the grammar type recognition to the changed naming |
| * conventions for Tree Parser |
| * 2007-10-17: Options "trace", "traceLexer", "traceParser" and "glib" emit |
| * warnings when being used. |
| * Added recognition of "parser grammar T". |
| * Added options "nocollapse", "noprune". |
| * ANTLR option "depend" is being used to resolve build dependencies. |
| * 2007-11-15: Embedded Classpath statement had not been observed |
| * with option depend="true" (Reported by Mats Behre) |
| * 2008-03-31: Support the option conversiontimeout. (Jim Idle) |
| * 2007-12-31: With option "depend=true" proceed even if first pass failed so |
| * that ANTLR can spit out its errors |
| * 2008-08-09: Inspecting environment variable ANTLR_HOME to detect and add |
| * antlr- and stringtemplate libraries to the classpath |
| * 2008-08-09: Removed routine checkGenerateFile. It got feeble with the |
| * introduction of composed grammars, e.g. "import T.g" and after |
| * a short struggle it started it's journey to /dev/null. |
| * From now one it is always antlr itself via the depend option |
| * which decides about dependecies |
| * 2008-08-19: Dependency check for composed grammars added. |
| * Might need some further improvements. |
| */ |
| package org.apache.tools.ant.antlr; |
| |
| import java.util.regex.*; |
| import java.io.*; |
| import java.util.Map; |
| import org.apache.tools.ant.BuildException; |
| import org.apache.tools.ant.DirectoryScanner; |
| import org.apache.tools.ant.Project; |
| import org.apache.tools.ant.Task; |
| import org.apache.tools.ant.taskdefs.Execute; |
| import org.apache.tools.ant.taskdefs.LogOutputStream; |
| import org.apache.tools.ant.taskdefs.PumpStreamHandler; |
| import org.apache.tools.ant.taskdefs.Redirector; |
| import org.apache.tools.ant.types.Commandline; |
| import org.apache.tools.ant.types.CommandlineJava; |
| import org.apache.tools.ant.types.Path; |
| import org.apache.tools.ant.util.JavaEnvUtils; |
| import org.apache.tools.ant.util.LoaderUtils; |
| import org.apache.tools.ant.util.TeeOutputStream; |
| import org.apache.tools.ant.util.FileUtils; |
| |
| /** |
| * Invokes the ANTLR3 Translator generator on a grammar file. |
| * |
| */ |
| public class ANTLR3 extends Task { |
| |
| private CommandlineJava commandline = new CommandlineJava(); |
| /** the file to process */ |
| private File target = null; |
| /** where to output the result */ |
| private File outputDirectory = null; |
| /** location of token files */ |
| private File libDirectory = null; |
| /** an optional super grammar file */ |
| private File superGrammar; |
| /** depend */ |
| private boolean depend = false; |
| /** fork */ |
| private boolean fork; |
| /** name of output style for messages */ |
| private String messageFormatName; |
| /** optional flag to print out a diagnostic file */ |
| private boolean diagnostic; |
| /** optional flag to add methods */ |
| private boolean trace; |
| /** optional flag to add trace methods to the parser only */ |
| private boolean traceParser; |
| /** optional flag to add trace methods to the lexer only */ |
| private boolean traceLexer; |
| /** working directory */ |
| private File workingdir = null; |
| /** captures ANTLR's output */ |
| private ByteArrayOutputStream bos = new ByteArrayOutputStream(); |
| /** The debug attribute */ |
| private boolean debug; |
| /** The report attribute */ |
| private boolean report; |
| /** The print attribute */ |
| private boolean print; |
| /** The profile attribute */ |
| private boolean profile; |
| /** The nfa attribute */ |
| private boolean nfa; |
| /** The dfa attribute */ |
| private boolean dfa; |
| /** multi threaded analysis */ |
| private boolean multiThreaded; |
| /** collapse incident edges into DFA states */ |
| private boolean nocollapse; |
| /** test lookahead against EBNF block exit branches */ |
| private boolean noprune; |
| /** put tags at start/stop of all templates in output */ |
| private boolean dbgST; |
| /** print AST */ |
| private boolean grammarTree; |
| /** Instance of a utility class to use for file operations. */ |
| private FileUtils fileUtils; |
| /** |
| * Whether to override the default conversion timeout with -Xconversiontimeout nnnn |
| */ |
| private String conversiontimeout; |
| |
| public ANTLR3() { |
| commandline.setVm(JavaEnvUtils.getJreExecutable("java")); |
| commandline.setClassname("org.antlr.Tool"); |
| fileUtils = FileUtils.getFileUtils(); |
| } |
| |
| /** |
| * The grammar file to process. |
| */ |
| public void setTarget(File targetFile) { |
| log("Setting target to: " + targetFile.toString(), Project.MSG_VERBOSE); |
| this.target = targetFile; |
| } |
| |
| /** |
| * The directory to write the generated files to. |
| */ |
| public void setOutputdirectory(File outputDirectoryFile) { |
| log("Setting output directory to: " + outputDirectoryFile.toString(), Project.MSG_VERBOSE); |
| this.outputDirectory = outputDirectoryFile; |
| } |
| |
| /** |
| * The directory to write the generated files to. |
| */ |
| public File getOutputdirectory() { |
| return outputDirectory; |
| } |
| |
| /** |
| * The token files output directory. |
| */ |
| public void setLibdirectory(File libDirectoryFile) { |
| log("Setting lib directory to: " + libDirectoryFile.toString(), Project.MSG_VERBOSE); |
| this.libDirectory = libDirectoryFile; |
| } |
| |
| /** |
| * The output style for messages. |
| */ |
| public void setMessageformat(String name) { |
| log("Setting message-format to: " + name, Project.MSG_VERBOSE); |
| this.messageFormatName = name; |
| } |
| |
| /** |
| * Sets an optional super grammar file |
| * @deprecated |
| */ |
| public void setGlib(File superGrammarFile) { |
| this.superGrammar = superGrammarFile; |
| } |
| |
| /** |
| * Sets a flag to enable ParseView debugging |
| */ |
| public void setDebug(boolean enable) { |
| this.debug = enable; |
| } |
| |
| /** |
| * Sets a flag to enable report statistics |
| */ |
| public void setReport(boolean enable) { |
| this.report = enable; |
| } |
| |
| /** |
| * Sets a flag to print out the grammar without actions |
| */ |
| public void setPrint(boolean enable) { |
| this.print = enable; |
| } |
| |
| /** |
| * Sets a flag to enable profiling |
| */ |
| public void setProfile(boolean enable) { |
| this.profile = enable; |
| } |
| |
| /** |
| * Sets a flag to enable nfa generation |
| */ |
| public void setNfa(boolean enable) { |
| this.nfa = enable; |
| } |
| |
| /** |
| * Sets a flag to enable nfa generation |
| */ |
| public void setDfa(boolean enable) { |
| this.dfa = enable; |
| } |
| |
| /** |
| * Run the analysis multithreaded |
| * @param enable |
| */ |
| public void setMultithreaded(boolean enable) { |
| multiThreaded = enable; |
| } |
| |
| /** |
| * collapse incident edges into DFA states |
| * @param enable |
| */ |
| public void setNocollapse(boolean enable) { |
| nocollapse = enable; |
| } |
| |
| /** |
| * test lookahead against EBNF block exit branches |
| * @param enable |
| */ |
| public void setNoprune(boolean enable) { |
| noprune = enable; |
| } |
| |
| /** |
| * test lookahead against EBNF block exit branches |
| * @param enable |
| */ |
| public void setDbgST(boolean enable) { |
| dbgST = enable; |
| } |
| |
| /** |
| * override the default conversion timeout with -Xconversiontimeout nnnn |
| * @param conversiontimeoutString |
| */ |
| public void setConversiontimeout(String conversiontimeoutString) { |
| log("Setting conversiontimeout to: " + conversiontimeoutString, Project.MSG_VERBOSE); |
| try { |
| int timeout = Integer.valueOf(conversiontimeoutString); |
| this.conversiontimeout = conversiontimeoutString; |
| } catch (NumberFormatException e) { |
| log("Option ConversionTimeOut ignored due to illegal value: '" + conversiontimeoutString + "'", Project.MSG_ERR); |
| } |
| } |
| |
| /** |
| * Set a flag to enable printing of the grammar tree |
| */ |
| public void setGrammartree(boolean enable) { |
| grammarTree = enable; |
| } |
| |
| /** |
| * Set a flag to enable dependency checking by ANTLR itself |
| * The depend option is always used implicitely inside the antlr3 task |
| * @deprecated |
| */ |
| public void setDepend(boolean s) { |
| this.depend = s; |
| } |
| |
| /** |
| * Sets a flag to emit diagnostic text |
| */ |
| public void setDiagnostic(boolean enable) { |
| diagnostic = enable; |
| } |
| |
| /** |
| * If true, enables all tracing. |
| * @deprecated |
| */ |
| public void setTrace(boolean enable) { |
| trace = enable; |
| } |
| |
| /** |
| * If true, enables parser tracing. |
| * @deprecated |
| */ |
| public void setTraceParser(boolean enable) { |
| traceParser = enable; |
| } |
| |
| /** |
| * If true, enables lexer tracing. |
| * @deprecated |
| */ |
| public void setTraceLexer(boolean enable) { |
| traceLexer = enable; |
| } |
| |
| // we are forced to fork ANTLR since there is a call |
| // to System.exit() and there is nothing we can do |
| // right now to avoid this. :-( (SBa) |
| // I'm not removing this method to keep backward compatibility |
| /** |
| * @ant.attribute ignore="true" |
| */ |
| public void setFork(boolean s) { |
| this.fork = s; |
| } |
| |
| /** |
| * The working directory of the process |
| */ |
| public void setDir(File d) { |
| this.workingdir = d; |
| } |
| |
| /** |
| * Adds a classpath to be set |
| * because a directory might be given for Antlr debug. |
| */ |
| public Path createClasspath() { |
| return commandline.createClasspath(getProject()).createPath(); |
| } |
| |
| /** |
| * Adds a new JVM argument. |
| * @return create a new JVM argument so that any argument can be passed to the JVM. |
| * @see #setFork(boolean) |
| */ |
| public Commandline.Argument createJvmarg() { |
| return commandline.createVmArgument(); |
| } |
| |
| /** |
| * Adds the jars or directories containing Antlr and associates. |
| * This should make the forked JVM work without having to |
| * specify it directly. |
| */ |
| @Override |
| public void init() throws BuildException { |
| /* Inquire environment variables */ |
| Map<String, String> variables = System.getenv(); |
| /* Get value for key "ANTLR_HOME" which should hopefully point to |
| * the directory where the current version of antlr3 is installed */ |
| String antlrHome = variables.get("ANTLR_HOME"); |
| if (antlrHome != null) { |
| /* Environment variable ANTLR_HOME has been defined. |
| * Now add all antlr and stringtemplate libraries to the |
| * classpath */ |
| addAntlrJarsToClasspath(antlrHome + "/lib"); |
| } |
| addClasspathEntry("/antlr/ANTLRGrammarParseBehavior.class", "AntLR2"); |
| addClasspathEntry("/org/antlr/tool/ANTLRParser.class", "AntLR3"); |
| addClasspathEntry("/org/antlr/stringtemplate/StringTemplate.class", "Stringtemplate"); |
| |
| |
| } |
| |
| /** |
| * Search for the given resource and add the directory or archive |
| * that contains it to the classpath. |
| * |
| * <p>Doesn't work for archives in JDK 1.1 as the URL returned by |
| * getResource doesn't contain the name of the archive.</p> |
| */ |
| protected void addClasspathEntry(String resource, String msg) { |
| /* |
| * pre Ant 1.6 this method used to call getClass().getResource |
| * while Ant 1.6 will call ClassLoader.getResource(). |
| * |
| * The difference is that Class.getResource expects a leading |
| * slash for "absolute" resources and will strip it before |
| * delegating to ClassLoader.getResource - so we now have to |
| * emulate Class's behavior. |
| */ |
| if (resource.startsWith("/")) { |
| resource = resource.substring(1); |
| } else { |
| resource = "org/apache/tools/ant/taskdefs/optional/" + resource; |
| } |
| |
| File f = LoaderUtils.getResourceSource(getClass().getClassLoader(), resource); |
| if (f != null) { |
| log("Found via classpath: " + f.getAbsolutePath(), Project.MSG_VERBOSE); |
| createClasspath().setLocation(f); |
| } else { |
| log("Couldn\'t find resource " + resource + " for library " + msg + " in external classpath", Project.MSG_VERBOSE); |
| } |
| } |
| |
| /** |
| * If the environment variable ANTLR_HOME is defined and points |
| * to the installation directory of antlr3 then look for all antlr-*.jar and |
| * stringtemplate-*.jar files in the lib directory and add them |
| * to the classpath. |
| * This feature should make working with eclipse or netbeans projects a |
| * little bit easier. As wildcards are being used for the version part |
| * of the jar-archives it makes the task independent of |
| * new releases. Just let ANTLR_HOME point to the new installation |
| * directory. |
| */ |
| private void addAntlrJarsToClasspath(String antlrLibDir) { |
| String[] includes = {"antlr-*.jar", "stringtemplate-*.jar"}; |
| |
| DirectoryScanner ds = new DirectoryScanner(); |
| ds.setIncludes(includes); |
| ds.setBasedir(new File(antlrLibDir)); |
| ds.setCaseSensitive(true); |
| ds.scan(); |
| |
| String separator = System.getProperty("file.separator"); |
| String[] files = ds.getIncludedFiles(); |
| for (String file : files) { |
| File f = new File(antlrLibDir + separator + file); |
| log("Found via ANTLR_HOME: " + f.getAbsolutePath(), Project.MSG_VERBOSE); |
| createClasspath().setLocation(f); |
| } |
| } |
| |
| @Override |
| public void execute() throws BuildException { |
| |
| validateAttributes(); |
| |
| // Use ANTLR itself to resolve dependencies and decide whether |
| // to invoke ANTLR for compilation |
| if (dependencyCheck()) { |
| populateAttributes(); |
| commandline.createArgument().setValue(target.toString()); |
| |
| log(commandline.describeCommand(), Project.MSG_VERBOSE); |
| int err = 0; |
| try { |
| err = run(commandline.getCommandline(), new LogOutputStream(this, Project.MSG_INFO), new LogOutputStream(this, Project.MSG_WARN)); |
| } catch (IOException e) { |
| throw new BuildException(e, getLocation()); |
| } finally { |
| try { |
| bos.close(); |
| } catch (IOException e) { |
| // ignore |
| } |
| } |
| |
| if (err != 0) { |
| throw new BuildException("ANTLR returned: " + err, getLocation()); |
| } else { |
| Pattern p = Pattern.compile("error\\([0-9]+\\):"); |
| Matcher m = p.matcher(bos.toString()); |
| if (m.find()) { |
| throw new BuildException("ANTLR signaled an error.", getLocation()); |
| } |
| } |
| } else { |
| try { |
| log("All dependencies of grammar file \'" + target.getCanonicalPath() + "\' are up to date.", Project.MSG_VERBOSE); |
| } catch (IOException ex) { |
| log("All dependencies of grammar file \'" + target.toString() + "\' are up to date.", Project.MSG_VERBOSE); |
| } |
| } |
| } |
| |
| /** |
| * A refactored method for populating all the command line arguments based |
| * on the user-specified attributes. |
| */ |
| private void populateAttributes() { |
| |
| commandline.createArgument().setValue("-o"); |
| commandline.createArgument().setValue(outputDirectory.toString()); |
| |
| commandline.createArgument().setValue("-lib"); |
| commandline.createArgument().setValue(libDirectory.toString()); |
| |
| if (superGrammar != null) { |
| log("Option 'glib' is not supported by ANTLR v3. Option ignored!", Project.MSG_WARN); |
| } |
| |
| if (diagnostic) { |
| commandline.createArgument().setValue("-diagnostic"); |
| } |
| if (depend) { |
| log("Option 'depend' is implicitely always used by ANTLR v3. Option can safely be omitted!", Project.MSG_WARN); |
| } |
| if (trace) { |
| log("Option 'trace' is not supported by ANTLR v3. Option ignored!", Project.MSG_WARN); |
| } |
| if (traceParser) { |
| log("Option 'traceParser' is not supported by ANTLR v3. Option ignored!", Project.MSG_WARN); |
| } |
| if (traceLexer) { |
| log("Option 'traceLexer' is not supported by ANTLR v3. Option ignored!", Project.MSG_WARN); |
| } |
| if (debug) { |
| commandline.createArgument().setValue("-debug"); |
| } |
| if (report) { |
| commandline.createArgument().setValue("-report"); |
| } |
| if (print) { |
| commandline.createArgument().setValue("-print"); |
| } |
| if (profile) { |
| commandline.createArgument().setValue("-profile"); |
| } |
| if (messageFormatName != null) { |
| commandline.createArgument().setValue("-message-format"); |
| commandline.createArgument().setValue(messageFormatName); |
| } |
| if (nfa) { |
| commandline.createArgument().setValue("-nfa"); |
| } |
| if (dfa) { |
| commandline.createArgument().setValue("-dfa"); |
| } |
| if (multiThreaded) { |
| commandline.createArgument().setValue("-Xmultithreaded"); |
| } |
| if (nocollapse) { |
| commandline.createArgument().setValue("-Xnocollapse"); |
| } |
| if (noprune) { |
| commandline.createArgument().setValue("-Xnoprune"); |
| } |
| if (dbgST) { |
| commandline.createArgument().setValue("-XdbgST"); |
| } |
| if (conversiontimeout != null) { |
| commandline.createArgument().setValue("-Xconversiontimeout"); |
| commandline.createArgument().setValue(conversiontimeout); |
| } |
| if (grammarTree) { |
| commandline.createArgument().setValue("-Xgrtree"); |
| } |
| } |
| |
| private void validateAttributes() throws BuildException { |
| |
| if (target == null) { |
| throw new BuildException("No target grammar, lexer grammar or tree parser specified!"); |
| } else if (!target.isFile()) { |
| throw new BuildException("Target: " + target + " is not a file!"); |
| } |
| |
| // if no output directory is specified, use the target's directory |
| if (outputDirectory == null) { |
| setOutputdirectory(new File(target.getParent())); |
| } |
| |
| if (!outputDirectory.isDirectory()) { |
| throw new BuildException("Invalid output directory: " + outputDirectory); |
| } |
| |
| if (workingdir != null && !workingdir.isDirectory()) { |
| throw new BuildException("Invalid working directory: " + workingdir); |
| } |
| |
| // if no libDirectory is specified, use the target's directory |
| if (libDirectory == null) { |
| setLibdirectory(new File(target.getParent())); |
| } |
| |
| if (!libDirectory.isDirectory()) { |
| throw new BuildException("Invalid lib directory: " + libDirectory); |
| } |
| } |
| |
| private boolean dependencyCheck() throws BuildException { |
| // using "antlr -o <OutputDirectory> -lib <LibDirectory> -depend <T>" |
| // to get the list of dependencies |
| CommandlineJava cmdline; |
| try { |
| cmdline = (CommandlineJava) commandline.clone(); |
| } catch (java.lang.CloneNotSupportedException e) { |
| throw new BuildException("Clone of commandline failed: " + e); |
| } |
| |
| cmdline.createArgument().setValue("-depend"); |
| cmdline.createArgument().setValue("-o"); |
| cmdline.createArgument().setValue(outputDirectory.toString()); |
| cmdline.createArgument().setValue("-lib"); |
| cmdline.createArgument().setValue(libDirectory.toString()); |
| cmdline.createArgument().setValue(target.toString()); |
| |
| log(cmdline.describeCommand(), Project.MSG_VERBOSE); |
| |
| // redirect output generated by ANTLR to temporary file |
| Redirector r = new Redirector(this); |
| File f; |
| try { |
| f = File.createTempFile("depend", null, getOutputdirectory()); |
| f.deleteOnExit(); |
| log("Write dependencies for '" + target.toString() + "' to file '" + f.getCanonicalPath() + "'", Project.MSG_VERBOSE); |
| r.setOutput(f); |
| r.setAlwaysLog(false); |
| r.createStreams(); |
| } catch (IOException e) { |
| throw new BuildException("Redirection of output failed: " + e); |
| } |
| |
| // execute antlr -depend ... |
| int err = 0; |
| try { |
| err = run(cmdline.getCommandline(), r.getOutputStream(), null); |
| } catch (IOException e) { |
| try { |
| r.complete(); |
| log("Redirection of output terminated.", Project.MSG_VERBOSE); |
| } catch (IOException ex) { |
| log("Termination of output redirection failed: " + ex, Project.MSG_ERR); |
| } |
| throw new BuildException(e, getLocation()); |
| } finally { |
| try { |
| bos.close(); |
| } catch (IOException e) { |
| // ignore |
| } |
| } |
| |
| try { |
| r.complete(); |
| log("Redirection of output terminated.", Project.MSG_VERBOSE); |
| } catch (IOException e) { |
| log("Termination of output redirection failed: " + e, Project.MSG_ERR); |
| } |
| |
| if (err != 0) { |
| if (f.exists()) { |
| f.delete(); |
| } |
| if (cmdline.getClasspath() == null) { |
| log("Antlr libraries not found in external classpath or embedded classpath statement ", Project.MSG_ERR); |
| } |
| log("Dependency check failed. ANTLR returned: " + err, Project.MSG_ERR); |
| return true; |
| } else { |
| Pattern p = Pattern.compile("error\\([0-9]+\\):"); |
| Matcher m = p.matcher(bos.toString()); |
| if (m.find()) { |
| if (f.exists()) { |
| f.delete(); |
| } |
| // On error always recompile |
| return true; |
| } |
| } |
| |
| boolean compile = false; |
| |
| // open temporary file |
| BufferedReader in = null; |
| try { |
| in = new BufferedReader(new FileReader(f)); |
| } catch (IOException e) { |
| try { |
| if (in != null) { |
| in.close(); |
| } |
| } catch (IOException ex) { |
| throw new BuildException("Could not close file\'" + f.toString() + "\'."); |
| } |
| if (f.exists()) { |
| f.delete(); |
| } |
| try { |
| throw new BuildException("Could not open \'" + f.getCanonicalPath() + "\' for reading."); |
| } catch (IOException ex) { |
| throw new BuildException("Could not open \'" + f.toString() + "\' for reading."); |
| } |
| } |
| |
| // evaluate dependencies in temporary file |
| String s; |
| |
| try { |
| while ((s = in.readLine()) != null) { |
| String a; |
| String b; |
| // As the separator string in lines emitted by the depend option |
| // is either " : " or ": " trim is invoked for the first file name of a line |
| int to = s.indexOf(": "); |
| if (to >= 0) { |
| a = s.substring(0, to).trim(); |
| File lhs = new File(a); |
| if (!lhs.isFile()) { |
| log("File '" + a + "' is not a regular file", Project.MSG_VERBOSE); |
| String name = lhs.getName(); |
| String[] parts = splitRightHandSide(name, "\\u002E"); |
| if (parts.length <= 1) { |
| a += ".java"; |
| lhs = new File(a); |
| if (lhs.isFile()) { |
| log("File '" + a + "' is a regular file last modified at " + lhs.lastModified(), Project.MSG_VERBOSE); |
| } |
| } |
| } |
| |
| b = s.substring(to + ": ".length()); |
| String[] names = splitRightHandSide(b, ", ?"); |
| File aFile = new File(a); |
| for (String name : names) { |
| File bFile = new File(name); |
| log("File '" + a + "' depends on file '" + name + "'", Project.MSG_VERBOSE); |
| log("File '" + a + "' modified at " + aFile.lastModified(), Project.MSG_VERBOSE); |
| log("File '" + name + "' modified at " + bFile.lastModified(), Project.MSG_VERBOSE); |
| if (fileUtils.isUpToDate(aFile, bFile)) { |
| log("Compiling " + target + " as '" + name + "' is newer than '" + a + "'", Project.MSG_VERBOSE); |
| // Feeling not quite comfortable with touching the file |
| fileUtils.setFileLastModified(aFile, -1); |
| log("Touching file '" + a + "'", Project.MSG_VERBOSE); |
| compile = true; |
| break; |
| } |
| } |
| if (compile) { |
| break; |
| } |
| } |
| } |
| in.close(); |
| } catch (IOException e) { |
| if (f.exists()) { |
| f.delete(); |
| } |
| throw new BuildException("Error reading file '" + f.toString() + "'"); |
| } |
| |
| if (f.exists()) { |
| f.delete(); |
| } |
| |
| return compile; |
| } |
| |
| private String[] splitRightHandSide(String fileNames, String pattern) { |
| String[] names = fileNames.split(pattern); |
| for (String name : names) { |
| log("Split right hand side '" + name + "'", Project.MSG_VERBOSE); |
| } |
| return names; |
| } |
| |
| /** execute in a forked VM */ |
| private int run(String[] command, OutputStream out, OutputStream err) throws IOException { |
| PumpStreamHandler psh; |
| if (err == null) { |
| psh = new PumpStreamHandler(out, bos); |
| } else { |
| psh = new PumpStreamHandler(out, new TeeOutputStream(err, bos)); |
| } |
| |
| Execute exe = new Execute(psh, null); |
| |
| exe.setAntRun(getProject()); |
| if (workingdir != null) { |
| exe.setWorkingDirectory(workingdir); |
| } |
| |
| exe.setCommandline(command); |
| |
| return exe.execute(); |
| } |
| } |
