FileDocCategorySizeDatePackage
ANTLR.javaAPI DocApache Ant 1.7014693Wed Dec 13 06:16:18 GMT 2006org.apache.tools.ant.taskdefs.optional

ANTLR

public class ANTLR extends org.apache.tools.ant.Task
Invokes the ANTLR Translator generator on a grammar file.

Fields Summary
private org.apache.tools.ant.types.CommandlineJava
commandline
private File
targetFile
the file to process
private File
outputDirectory
where to output the result
private File
superGrammar
an optional super grammar file
private boolean
html
optional flag to enable html output
private boolean
diagnostic
optional flag to print out a diagnostic file
private boolean
trace
optional flag to add trace methods
private boolean
traceParser
optional flag to add trace methods to the parser only
private boolean
traceLexer
optional flag to add trace methods to the lexer only
private boolean
traceTreeWalker
optional flag to add trace methods to the tree walker only
private File
workingdir
working directory
private ByteArrayOutputStream
bos
captures ANTLR's output
private boolean
debug
The debug attribute
private static final org.apache.tools.ant.util.FileUtils
FILE_UTILS
Instance of a utility class to use for file operations.
Constructors Summary
public ANTLR()
Constructor for ANTLR task.


         
      
        commandline.setVm(JavaEnvUtils.getJreExecutable("java"));
        commandline.setClassname("antlr.Tool");
Methods Summary
protected voidaddClasspathEntry(java.lang.String resource)
Search for the given resource and add the directory or archive that contains it to the classpath.

Doesn't work for archives in JDK 1.1 as the URL returned by getResource doesn't contain the name of the archive.

param
resource the resource name to search for

        /*
         * 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 " + f.getAbsolutePath(), Project.MSG_DEBUG);
            createClasspath().setLocation(f);
        } else {
            log("Couldn\'t find " + resource, Project.MSG_VERBOSE);
        }
public org.apache.tools.ant.types.PathcreateClasspath()
Adds a classpath to be set because a directory might be given for Antlr debug.

return
a path to be configured

        return commandline.createClasspath(getProject()).createPath();
public Commandline.ArgumentcreateJvmarg()
Adds a new JVM argument.

return
create a new JVM argument so that any argument can be passed to the JVM.
see
#setFork(boolean)

        return commandline.createVmArgument();
public voidexecute()
Execute the task.

throws
BuildException on error

        validateAttributes();

        //TODO: use ANTLR to parse the grammar file to do this.
        File generatedFile = getGeneratedFile();
        boolean targetIsOutOfDate =
            targetFile.lastModified() > generatedFile.lastModified();
        boolean superGrammarIsOutOfDate  = superGrammar != null
                && (superGrammar.lastModified() > generatedFile.lastModified());
        if (targetIsOutOfDate || superGrammarIsOutOfDate) {
            if (targetIsOutOfDate) {
                log("Compiling " + targetFile + " as it is newer than "
                    + generatedFile, Project.MSG_VERBOSE);
            } else if (superGrammarIsOutOfDate) {
                log("Compiling " + targetFile + " as " + superGrammar
                    + " is newer than " + generatedFile, Project.MSG_VERBOSE);
            }
            populateAttributes();
            commandline.createArgument().setValue(targetFile.toString());

            log(commandline.describeCommand(), Project.MSG_VERBOSE);
            int err = run(commandline.getCommandline());
            if (err != 0) {
                throw new BuildException("ANTLR returned: " + err, getLocation());
            } else {
                String output = bos.toString();
                if (output.indexOf("error:") > -1) {
                    throw new BuildException("ANTLR signaled an error: "
                                             + output, getLocation());
                }
            }
        } else {
            log("Skipped grammar file. Generated file " + generatedFile
                + " is newer.", Project.MSG_VERBOSE);
        }
private java.io.FilegetGeneratedFile()

        String generatedFileName = null;
        try {
            BufferedReader in = new BufferedReader(new FileReader(targetFile));
            String line;
            while ((line = in.readLine()) != null) {
                int extendsIndex = line.indexOf(" extends ");
                if (line.startsWith("class ") && extendsIndex > -1) {
                    generatedFileName = line.substring(6, extendsIndex).trim();
                    break;
                }
            }
            in.close();
        } catch (Exception e) {
            throw new BuildException("Unable to determine generated class", e);
        }
        if (generatedFileName == null) {
            throw new BuildException("Unable to determine generated class");
        }
        return new File(outputDirectory, generatedFileName
                        + (html ? ".html" : ".java"));
public voidinit()
Adds the jars or directories containing Antlr this should make the forked JVM work without having to specify it directly.

throws
BuildException on error

        addClasspathEntry("/antlr/ANTLRGrammarParseBehavior.class");
protected booleanis272()
Whether the antlr version is 2.7.2 (or higher).

return
true if the version of Antlr present is 2.7.2 or later.
since
Ant 1.6

        AntClassLoader l = null;
        try {
            l = getProject().createClassLoader(commandline.getClasspath());
            l.loadClass("antlr.Version");
            return true;
        } catch (ClassNotFoundException e) {
            return false;
        } finally {
            if (l != null) {
                l.cleanup();
            }
        }
private voidpopulateAttributes()
A refactored method for populating all the command line arguments based on the user-specified attributes.

        commandline.createArgument().setValue("-o");
        commandline.createArgument().setValue(outputDirectory.toString());
        if (superGrammar != null) {
            commandline.createArgument().setValue("-glib");
            commandline.createArgument().setValue(superGrammar.toString());
        }
        if (html) {
            commandline.createArgument().setValue("-html");
        }
        if (diagnostic) {
            commandline.createArgument().setValue("-diagnostic");
        }
        if (trace) {
            commandline.createArgument().setValue("-trace");
        }
        if (traceParser) {
            commandline.createArgument().setValue("-traceParser");
        }
        if (traceLexer) {
            commandline.createArgument().setValue("-traceLexer");
        }
        if (traceTreeWalker) {
            if (is272()) {
                commandline.createArgument().setValue("-traceTreeParser");
            } else {
                commandline.createArgument().setValue("-traceTreeWalker");
            }
        }
        if (debug) {
            commandline.createArgument().setValue("-debug");
        }
private intrun(java.lang.String[] command)
execute in a forked VM

        PumpStreamHandler psh =
            new PumpStreamHandler(new LogOutputStream(this, Project.MSG_INFO),
                                  new TeeOutputStream(
                                                      new LogOutputStream(this,
                                                                          Project.MSG_WARN),
                                                      bos)
                                  );
        Execute exe = new Execute(psh, null);
        exe.setAntRun(getProject());
        if (workingdir != null) {
            exe.setWorkingDirectory(workingdir);
        }
        exe.setCommandline(command);
        try {
            return exe.execute();
        } catch (IOException e) {
            throw new BuildException(e, getLocation());
        } finally {
            FileUtils.close(bos);
        }
public voidsetDebug(boolean enable)
Sets a flag to enable ParseView debugging

param
enable a boolean value

        this.debug = enable;
public voidsetDiagnostic(boolean enable)
Sets a flag to emit diagnostic text

param
enable a boolean value

        diagnostic = enable;
public voidsetDir(java.io.File d)
The working directory of the process

param
d the working directory

        this.workingdir = d;
public voidsetFork(boolean s)

ant.attribute
ignore="true"
param
s a boolean value

        //this.fork = s;
public voidsetGlib(java.lang.String superGrammar)
Sets an optional super grammar file. Use setGlib(File superGrammar) instead.

param
superGrammar the super grammar filename
deprecated
since ant 1.6

        String sg = null;
        if (Os.isFamily("dos")) {
            sg = superGrammar.replace('\\", '/");
        } else {
            sg = superGrammar;
        }
        setGlib(FILE_UTILS.resolveFile(getProject().getBaseDir(), sg));
public voidsetGlib(java.io.File superGrammar)
Sets an optional super grammar file

param
superGrammar the super grammar file
since
ant 1.6

        this.superGrammar = superGrammar;
public voidsetHtml(boolean enable)
If true, emit html

param
enable a boolean value

        html = enable;
public voidsetOutputdirectory(java.io.File outputDirectory)
The directory to write the generated files to.

param
outputDirectory the output directory

        log("Setting output directory to: " + outputDirectory.toString(), Project.MSG_VERBOSE);
        this.outputDirectory = outputDirectory;
public voidsetTarget(java.io.File target)
The grammar file to process.

param
target the gramer file

        log("Setting target to: " + target.toString(), Project.MSG_VERBOSE);
        this.targetFile = target;
public voidsetTrace(boolean enable)
If true, enables all tracing.

param
enable a boolean value

        trace = enable;
public voidsetTraceLexer(boolean enable)
If true, enables lexer tracing.

param
enable a boolean value

        traceLexer = enable;
public voidsetTraceParser(boolean enable)
If true, enables parser tracing.

param
enable a boolean value

        traceParser = enable;
public voidsetTraceTreeWalker(boolean enable)
Sets a flag to allow the user to enable tree walker tracing

param
enable a boolean value

        traceTreeWalker = enable;
private voidvalidateAttributes()

        if (targetFile == null || !targetFile.isFile()) {
            throw new BuildException("Invalid target: " + targetFile);
        }

        // if no output directory is specified, used the target's directory
        if (outputDirectory == null) {
            setOutputdirectory(new File(targetFile.getParent()));
        }
        if (!outputDirectory.isDirectory()) {
            throw new BuildException("Invalid output directory: " + outputDirectory);
        }