Ant User Manual

by

• Jacques Bergeron (jacques.bergeron@dogico.com)
• Stefan Bodewig (stefan.bodewig@megabit.net)
• Patrick Chanezon (chanezon@netscape.com)
• James Duncan Davison (duncan@x180.com)
• Tom Dimock (tad1@cornell.edu)
• Bill Kelly (bill.kelly@softwired-inc.com)
• Arnout J. Kuiper (ajkuiper@wxs.nl)
• Conor MacNeill (conor@cortexebusiness.com.au)
• Stefano Mazzocchi (stefano@apache.org)
• Sam Ruby (rubys@us.ibm.com)

Version 1.1 - 2000/07/18

Table of Contents

• Introduction
• Getting Ant
• System Requirements
• Building Ant
• Installing Ant
• Running Ant
• Writing a simple buildfile
• Directory based tasks
• Built in Tasks
• Optional Tasks
• Build Events
• Writing your own task
• FAQ, DTD, external resources
• License
• Feedback

Introduction

Ant is a Java based build tool. In theory it is kind of like make without make's wrinkles.

Why?

Why another build tool when there is already make, gnumake, nmake, jam, and others? Because all of those tools have limitations that its original author couldn't live with when developing software across multiple platforms. Make like tools are inherently shell based. They evaluate a set of dependencies and then execute commands not unlike what you would issue on a shell. This means that you can easily extend these tools by using or writing any program for the OS that you are working on. However, this also means that you limit yourself to the OS, or at least the OS type such as Unix, that you are working on.

Makefiles are inherently evil as well. Anybody who has worked on them for any time has run into the dreaded tab problem. "Is my command not executing because I have a space in front of my tab!!!" said the original author of Ant way too many times. Tools like Jam took care of this to a great degree, but still use yet another format to use and remember.

Ant is different. Instead a model where it is extended with shell based commands, it is extended using Java classes. Instead of writing shell commands, the configuration files are XML based calling out a target tree where various tasks get executed. Each task is run by an object which implements a particular Task interface.

Granted, this removes some of the expressive power that is inherent by being able to construct a shell command such as `find . -name foo -exec rm {}` but it gives you the ability to be cross platform. To work anywhere and everywhere. And hey, if you really need to execute a shell command, Ant has an exec rule that allows different commands to be executed based on the OS that it is executing on.

Getting Ant

Binary edition

The latest stable version of Ant can be downloaded from http://jakarta.apache.org/builds/tomcat/release/v3.0/ant.zip. If you like living on the edge, you can download the latest version from http://jakarta.apache.org/builds/tomcat/nightly/ant.zip.

Source edition

If you prefer the source edition, you can download Ant from http://jakarta.apache.org/builds/tomcat/release/v3.0/src/jakarta-tools.src.zip (latest stable) or from http://jakarta.apache.org/from-cvs/jakarta-ant/ (current). See the section Building Ant on how to build Ant from the source code.

System Requirements

To build and use ant you must have a JAXP compilant XML parser installed and available on your classpath.

If you do not have a JAXP compliant XML parse installed, you may use the reference implementation available from Sun. It is available from http://java.sun.com/xml. Once installed make sure the "jaxp.jar" and "parser.jar" files are in your classpath.

You will also need the JDK installed on your system, version 1.1 or later.

Building Ant

Go to the directory jakarta-ant.

Make sure the JDK is in you path.

Run bootstrap.bat (Windows) or bootstrap.sh (UNIX) to build a bootstrap version of Ant.

When finished, use

build.bat -Dant.dist.dir=<directory to install Ant> dist

for Windows, and

build.sh -Dant.dist.dir=<directory to install Ant> dist

for UNIX, to create a binary distribution of Ant. This distribution can be found in the directory you specified.

Installing Ant

The binary distribution of Ant consists of three directories: bin, docs and lib. Only the bin and lib directory are crucial for running Ant. To run Ant, the following must be done:

• Add the bin directory to your path.
• Set the ANT_HOME environment variable. This should be set to the directory which contains the bin and lib directory.
• Set the JAVA_HOME environment variable. This should be set to the directory where the JDK is installed.

Windows

Assume Ant is installed in c:\ant\. The following sets up the environment:

set ANT_HOME=c:\ant
set JAVA_HOME=c:\jdk1.2.2
set PATH=%PATH%;%ANT_HOME%\bin

Unix (bash)

Assume Ant is installed in /usr/local/ant. The following sets up the environment:

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

Advanced

There are lots of variants that can be used to run Ant. What you need is at least the following:

The classpath for Ant must contain ant.jar and any jars/classes needed for your chosen JAXP compliant XML parser.

When you need JDK functionality (like a javac task, or a rmic task), then for JDK 1.1, the classes.zip file of the JDK must be added to the classpath; for JDK 1.2, tools.jar must be added. The scripts supplied with ant, in the bin directory, will add tools.jar automatically if the JAVA_HOME environment variable is set.

When you are executing platform specific applications (like the exec task, or the cvs task), the property ant.home must be set to the directory containing a bin directory, which contains the antRun shell script necessary to run execs on Unix.

Running Ant

Running Ant is simple, when you installed it as described in the previous section. Just type ant.

When nothing is specified, Ant looks for a build.xml file in the current directory. When found, it uses that file as a buildfile. To make Ant use another buildfile, use the commandline option -buildfile <file>, where <file> is the buildfile you want to use.

You can also set properties which override properties specified in the buildfile (see the property task). This can be done with the -D<property>=<value> option, where <property> is the name of the property and <value> the value.

To more options are -quiet which instructs Ant to print less information on the console when running. The option -verbose on the other hand makes Ant print more information on the console.

It is also possible to specify the target that should be executed. Default the target that is mentioned in the default attribute of the project is used. This can be overridden by adding the target name to the end of the commandline.

Commandline option summary:

ant [options] [target]
Options:
-help                  print this message
-version               print the version information and exit
-quiet                 be extra quiet
-verbose               be extra verbose
-logfile <file>        use given file for log
-listener <classname>  add an instance of class as a project listener
-buildfile <file>      use given buildfile
-D<property>=<value>   use value for given property

Examples

ant

runs Ant using the build.xml file in the current directory, on the default target.

ant -buildfile test.xml

runs Ant using the test.xml file in the current directory, on the default target.

ant -buildfile test.xml dist

runs Ant using the test.xml file in the current directory, on a target called dist.

ant -buildfile test.xml -Dbuild=build/classes dist

runs Ant using the test.xml file in the current directory, on a target called dist. It also sets the build property to the value build/classes.

Running Ant by hand

When you have installed Ant in the do-it-yourself way, Ant can be started with:

java -Dant.home=c:\ant org.apache.tools.ant.Main [options] [target]

These instructions actually do exactly the same as the ant command. The options and target are the same as when running Ant with the ant command. This example assumes you have set up your classpath to include

• ant.jar
• jars/classes for your XML parser
• the JDK's tools.jar

Writing a simple buildfile

The buildfile is written in XML. Each buildfile contains one project.

Projects

A project has three attributes:

Each project defines one or more targets. A target is a set of tasks you want to be executed. When starting Ant, you can select which target you want to have executed. When no target is given, the project's default is used.

Targets

A target can depend on other targets. You might have a target for compiling, for instance, and a target for creating a distributable. You can only build a distributable when you have compiled first, so the distribute target depends on the compile target. Ant resolves all these dependencies.

Ant tries to execute the targets in the depends attribute in the order they appear (from left to right). Keep in mind that it is possible that a target can get executed earlier when an earlier target depends on it:

<target name="A"/>
<target name="B" depends="A"/>
<target name="C" depends="B"/>
<target name="D" depends="C,B,A"/>

Suppose we want to execute target D. From its depends attribute, you might think that first target C, then B and then A is executed. Wrong! C depends on B, and B depends on A, so first A is executed, then B, then C, and finally D.

A target gets executed only once. Even when more targets depend on it (see the previous example).

A target has also the ability to perform its execution if (or unless) a property has been set. This allows, for example, better control on the building process depending on the state of the system (java version, OS, command line properties, etc...). To make target sense this property you should add the if (or unless) attribute with the name of the property that the target should react to, for example

<target name="build-module-A" if="module-A-present"/>

<target name="build-own-fake-module-A" unless="module-A-present"/>

If no if and no unless attribute is present, the target will always be executed.

It is a good practice to place your tstamp tasks in a so called initialization target, on which all other targets depend. Make sure that that target is always the first one in the depends list of the other targets. In this manual, most initialization targets have the name "init".

A target has the following attributes:

Tasks

A task is a piece of code that can be executed.

A task can have multiple attributes (or arguments if you prefer). The value of an attribute might contain references to a property. These references will be resolved before the task is executed.

Tasks have a common structure:

<name attribute1="value1" attribute2="value2" ... />

where name is the name of the task, attribute-x the attribute name, and value-x the value of this attribute.

There is a set of built in tasks, but it is also very easy to write your own.

All tasks share a taskname attribute. The value of this attribute will be used in the logging messages generated by Ant.

Properties

A project can have a set of properties. These might be set in the buildfile by the property task, or might be set outside Ant. A property has a name and a value. Properties might be used in in the value of task attributes. This is done by placing the property name between "${" and "}" in the attribute value.

If there is a property called "builddir" with the value "build", then this could be used in an attribute like this: "${builddir}/classes". This is resolved as "build/classes".

Token Filters

A project can have a set of tokens that might be automatically expanded if found when a file is copied, when the filtering-copy behavior is selected in the tasks that support this. These might be set in the buildfile by the filter task. 

Since this can be a very harmful behavior, the tokens in the files must be of the form @token@ where token is the token name that is set in the filter task. This token syntax matches the syntax of other build systems that perform such filtering and remains sufficiently orthogonal to most programming and scripting languages, as well with documentation systems.

Note: in case a token with the format @token@ if found in a file but no filter is associated with that token, no changes take place. So, no escaping method is present, but as long as you choose appropriate names for your tokens, this should not cause problems.

Examples

<project name="foo" default="dist" basedir=".">
  <target name="init">
    <tstamp/>
    <property name="build" value="build" />
    <property name="dist"  value="dist" />
    <filter token="version" value="1.0.3" />
    <filter token="year" value="2000" />
  </target>

  <target name="prepare" depends="init">
    <mkdir dir="${build}" />
  </target>

  <target name="compile" depends="prepare">
    <javac srcdir="${src}" destdir="${build}" filtering="on"/>
  </target>

  <target name="dist" depends="compile">
    <mkdir dir="${dist}/lib" />
    <jar jarfile="${dist}/lib/foo${DSTAMP}.jar"
     basedir="${build}" items="com"/>
  </target>

  <target name="clean" depends="init">
    <deltree dir="${build}" />
    <deltree dir="${dist}" />
  </target>
</project>

PATH like structures

You can specify PATH and CLASSPATH variables using both ":" and ";" as separator characters, Ant will convert it to the correct character of the current operating system.

Wherever PATH like values need to be specified a nested element can be used. This takes the general form of

    <classpath>
      <pathelement path="${classpath}" />
      <pathelement location="lib/helper.jar" />
    </classpath>

The location attribute specifies a single file or directory relative to the project's base directory (or an absolute filename), while the path attribute accepts ":" or ";" separated lists of locations. The path attribute is intended to be used with predefined paths - in any other case multiple elements with location attributes should be preferred.

As a shortcut the surrounding PATH element supports path and location attributes of its own, so

    <classpath>
      <pathelement path="${classpath}" />
    </classpath>

can be abreviated to

    <classpath path="${classpath}" />

Directory based tasks

Some tasks use directory trees for the task they perform. For instance, the Javac task which works upon a directory tree with .java files. Sometimes it can be very useful to work on a subset of that directory tree. This section describes how you can select a subset of such a directory tree.

Ant gives you two ways to create a subset, both of which can be used at the same time:

• Only include files/directories that match at least one pattern of a set of patterns
• Exclude files/directories that match at least one pattern a set of patterns

When both inclusion and exclusion are used, only files/directories that match the include patterns, and don't match the exclude patterns are used.

Patterns can be specified inside the buildfile via task attributes or nested elements and via external files. Each line of the external file is taken as pattern that is added to the list of include or exclude patterns.

Patterns

As described earlier, patterns are used for the inclusion and exclusion. These patterns look very much like the patterns used in DOS and UNIX:

'*' matches zero or more characters, '?' matches one character.

Examples:

'*.java' matches '.java', 'x.java' and 'FooBar.java', but not 'FooBar.xml' (does not end with '.java').

'?.java' matches 'x.java', 'A.java', but not '.java' or 'xyz.java' (both don't have one character before '.java').

Combinations of '*'s and '?'s are allowed.

Matching is done per-directory. This means that first the first directory in the pattern is matched against the first directory in the path to match. Then the second directories are matched, and so on. E.g. when we have the pattern '/?abc/*/*.java' and the path '/xabc/foobar/test.java', then first '?abc' is matched with 'xabc', then '*' is matched with 'foobar' and finally '*.java' is matched with 'test.java'. They all match so the path matches the pattern.

Too make things a bit more flexible, we add one extra feature, which makes it possible to match multiple directory levels. This can be used to match a complete directory tree, or a file anywhere in the directory tree. To do this, '**' must be used as the name of a directory. When '**' is used as the name of a directory in the pattern, it matches zero or more directories. For instance: '/test/**' matches all files/directories under '/test/', such as '/test/x.java', or '/test/foo/bar/xyz.html', but not '/xyz.xml'.

There is one "shorthand", if a pattern ends with '/' or '\', then '**' is appended. E.g. "mypackage/test/" is interpreted as were it "mypackage/test/**".

Examples:

When these patterns are used in inclusion and exclusion, you have a powerful way to select just the files you want.

Examples

  <copydir src="${src}"
           dest="${dist}"
           includes="**/images/*"
           excludes="**/*.gif" />

This copies all files in directories called "images", that are located in the directory tree "${src}" to the destination "${dist}", but excludes all "*.gif" files from the copy.

This example can also be expressed using nested elements as

  <copydir src="${src}"
           dest="${dist}">
    <include name="**/images/*"/>
    <exclude name="**/*.gif" />
  </copydir>

Default Excludes

There are a set of definitions which are excluded by default from all directory based tasks. They are:

        "**/*~",
        "**/#*#",
        "**/%*%",
        "**/CVS",
        "**/CVS/*",
        "**/.cvsignore"

Built in tasks

• Ant
• Available
• Chmod
• Copydir
• Copyfile
• Cvs
• Delete
• Deltree
• Echo
• Exec
• Expand
• Filter
• FixCRLF
• Get
• GUnzip
• GZip
• Jar
• Java
• Javac
• Javadoc/Javadoc2
• KeySubst
• Mkdir
• Patch
• Property
• Rename
• Replace
• Rmic
• SignJar
• Tar
• Taskdef
• Touch
• Tstamp
• Style
• Unjar
• Untar
• Unzip
• Zip

Ant

Description:

Runs Ant on a supplied buildfile. This can be used to build subprojects.

When the antfile attribute is omitted, the file "build.xml" in the supplied directory (dir attribute) is used.

If no target attribute is supplied, the default target of the new project is used.

The properties of the current project will be available in the new project. These properties will override the properties that are set in the new project. (See also the properties task).

Parameters:

Examples

<ant antfile="subproject/subbuild.xml" dir="subproject" target="compile" />

<ant dir="subproject" />

Available

Description

Sets a property if a resource is available at runtime. This resource can be a file resource, a class in classpath or a JVM system resource.

The value part of the properties being set is true if the resource is present, otherwise, the property is not set.

Normally, this task is used to set properties that are useful to avoid target execution depending on system parameters.

Parameters

Examples

  <available classname="org.whatever.Myclass" property="Myclass.present" />

sets the property Myclass.present to the value "true" if the org.whatever.Myclass is found in Ant's classpath.

Chmod

Description

Changes the permissions of a file or all files inside a specified directory. Right now it has efect only under Unix. The permissions are also UNIX style, like the argument for the chmod command.

It is possible to refine the set of files whose permissions are changed. This can be done with the includes, includesfile, excludes, excludesfile and defaultexcludes attributes. With the includes or includesfile attribute you specify the files you want to have included by using patterns. The exclude or excludesfile attribute is used to specify the files you want to have excluded. This is also done with patterns. And finally with the defaultexcludes attribute, you can specify whether you want to use default exclusions or not. See the section on directory based tasks, on how the inclusion/exclusion of files works, and how to write patterns. The patterns are relative to the dir directory.

Parameters

Examples

<chmod file="${dist}/start.sh" perm="ugo+rx" />

makes the "start.sh" file readable and executable for anyone on a UNIX system.

    <chmod dir="${dist}/bin" perm="ugo+rx" includes="**/*.sh" />

makes all ".sh" files below ${dist}/bin readable and executable for anyone on a UNIX system.

Copydir

Description

Copies a directory tree from the source to the destination.

It is possible to refine the set of files that are being copied. This can be done with the includes, includesfile, excludes, excludesfile and defaultexcludes attributes. With the includes or includesfile attribute you specify the files you want to have included by using patterns. The exclude or excludesfile attribute is used to specify the files you want to have excluded. This is also done with patterns. And finally with the defaultexcludes attribute, you can specify whether you want to use default exclusions or not. See the section on directory based tasks, on how the inclusion/exclusion of files works, and how to write patterns. The patterns are relative to the src directory.

The ignore attribute contains the names of the files/directories that must be excluded from the copy. The names specified in the ignore attribute are just names, they do not contain any path information! Note that this attribute has been replaced by the excludes attribute.

Parameters

Examples

  <copydir src="${src}/resources"
           dest="${dist}"
  />

copies the directory ${src}/resources to ${dist}.

  <copydir src="${src}/resources"
           dest="${dist}"
           includes="**/*.java"
           excludes="**/Test.java"
  />

copies the directory ${src}/resources to ${dist} recursively. All java files are copied, except for files with the name Test.java.

  <copydir src="${src}/resources"
           dest="${dist}"
           includes="**/*.java"
           excludes="mypackage/test/**" />

copies the directory ${src}/resources to ${dist} recursively. All java files are copied, except for the files under the mypackage/test directory.

Copyfile

Description

Copies a file from the source to the destination. The file is only copied if the source file is newer than the destination file, or when the destination file does not exist.

Parameters

Examples

<copyfile src="test.java" dest="subdir/test.java" />

<copyfile src="${src}/index.html" dest="${dist}/help/index.html" />

Cvs

Description

Handles packages/modules retrieved from a CVS repository.

When doing automated builds, the get task should be preferred over the checkout command, because of speed.

Parameters

Examples

  <cvs cvsRoot=":pserver:anoncvs@jakarta.apache.org:/home/cvspublic"
       package="jakarta-tools"
       dest="${ws.dir}"
  />

checks out the package/module "jakarta-tools" from the CVS repository pointed to by the cvsRoot attribute, and stores the files in "${ws.dir}".

  <cvs dest="${ws.dir}" command="update" />

updates the package/module that has previously been checked out into "${ws.dir}".

Delete

Description

Deletes either a single file or all files in a specified directory and its sub-directories.

It is possible to refine the set of files that are being deleted. This can be done with the includes, includesfile, excludes, excludesfile and defaultexcludes attributes. With the includes or includesfile attribute you specify the files you want to have included in the deletion process by using patterns. The exclude or excludesfile attribute is used to specify the files you want to have excluded from the deletion process. This is also done with patterns. And finally with the defaultexcludes attribute, you can specify whether you want to use default exclusions or not. See the section on directory based tasks, on how the inclusion/exclusion of files works, and how to write patterns. The patterns are relative to the dir directory.

Parameters

Examples

  <delete file="/lib/ant.jar" />

deletes the file /lib/ant.jar.

  <delete dir="lib" />

deletes all files in the /lib directory.

  <delete dir="."
          include="**/*.bak"
  />

deletes all files with the extension ".bak" from the current directory and any sub-directories.

Deltree

Description

Deletes a directory with all its files and subdirectories.

Parameters

Examples

  <deltree dir="dist" />

deletes the directory dist, including its files and subdirectories.

  <deltree dir="${dist}" />

deletes the directory ${dist}, including its files and subdirectories.

Echo

Description

Echoes a message to System.out.

Parameters

Examples

  <echo message="Hello world" />

Exec

Description

Executes a system command. When the os attribute is specified, then the command is only executed when Ant is run on one of the specified operating systems.

Parameters

Examples

<exec dir="${src}" command="dir" os="windows" output="dir.txt" />

Expand/Unzip/Unjar

Description

Unzips a zip- or jarfile.

For JDK 1.1 "last modified time" field is set to current time instead of being carried from zipfile.

DEPRECATION: the expand task simply points to the unzip task and it's there for back compatibility reasons.

Parameters

Examples

<unzip src="${tomcat_src}/tools-src.zip" dest="${tools.home}" />

Filter

Description

Sets a token filter for this project. Token filters are used by all tasks that perform file copying operations through the Project commodity methods.

Note: the token string must not contain the separators chars (@).

Parameters

Examples

  <filter token="year" value="2000" />
  <copydir src="${src.dir}" dest="${dest.dir}"/>

will copy recursively all the files from the src.dir directory into the dest.dir directory replacing all the occurencies of the string @year@ with 2000.

FixCRLF

Description

Adjusts a text file to local.

It is possible to refine the set of files that are being adjusted. This can be done with the includes, includesfile, excludes, excludesfile and defaultexcludes attributes. With the includes or includesfile attribute you specify the files you want to have included by using patterns. The exclude or excludesfile attribute is used to specify the files you want to have excluded. This is also done with patterns. And finally with the defaultexcludes attribute, you can specify whether you want to use default exclusions or not. See the section on directory based tasks, on how the inclusion/exclusion of files works, and how to write patterns. The patterns are relative to the src directory.

Parameters

Examples

  <fixcrlf srcdir="${src}"
       cr="remove" eof="remove"
       includes="**/*.sh"
  />

Removes carriage return and eof characters from the shell scripts. Tabs and spaces are left as is.

  <fixcrlf srcdir="${src}"
       cr="add"
       includes="**/*.bat"
  />

Ensures that there are carriage return characters prior to evey line feed. Tabs and spaces are left as is. EOF characters are left alone if run on DOS systems, and are removed if run on Unix systems.

  <fixcrlf srcdir="${src}"
       tabs="add"
       includes="**/Makefile"
  />

Adds or removes CR characters to match local OS conventions, and converts spaces to tabs when appropriate. EOF characters are left alone if run on DOS systems, and are removed if run on Unix systems. Many versions of make require tabs prior to commands.

  <fixcrlf srcdir="${src}"
       tabs="remove"
       includes="**/README*"
  />

Adds or removes CR characters to match local OS conventions, and converts all tabs to spaces. EOF characters are left alone if run on DOS systems, and are removed if run on Unix systems. You never know what editor a user will use to browse README's.

Get

Description

Gets a file from an URL. When the verbose option is "on", this task displays a '.' for every 100 Kb retrieved.

This task should be preferred above the CVS task when doing automated builds. CVS is significant slower than loading a compressed archive with http/ftp.

Parameters

Examples

  <get src="http://jakarta.apache.org/" dest="help/index.html" />

gets the index page of http://jakarta.apache.org/, and stores it in the file help/index.html.

GUnzip

Description

Expands a GZip file.

If dest is a directory the name of the destination file is the same as src (with the ".gz" extension removed if present). If dest is ommited, the parent dir of src is taken. The file is only expanded if the source file is newer than the destination file, or when the destination file does not exist.

Parameters

Examples

<gunzip src="test.tar.gz"/>

expands test.tar.gz to test.tar

<gunzip src="test.tar.gz" dest="test2.tar"/>

expands test.tar.gz to test2.tar

<gunzip src="test.tar.gz" dest="subdir"/>

expands test.tar.gz to subdir/test.tar (assuming subdir is a directory).

GZip

Description

GZips a file.

Parameters

Examples

<gzip src="test.tar" zipfile="test.tar.gz" />

Jar

Description

Jars a set of files.

The basedir attribute is the reference directory from where to jar.

It is possible to refine the set of files that are being jarred. This can be done with the includes, includesfile, excludes, excludesfile and defaultexcludes attributes. With the includes or includesfile attribute you specify the files you want to have included by using patterns. The exclude or excludesfile attribute is used to specify the files you want to have excluded. This is also done with patterns. And finally with the defaultexcludes attribute, you can specify whether you want to use default exclusions or not. See the section on directory based tasks, on how the inclusion/exclusion of files works, and how to write patterns. The patterns are relative to the basedir directory.

The includes, excludes and defaultexcludes attributes replace the items and ignore attributes. The following explains how the deprecated items and ignore attribute behave.

When "*" is used for items, all files in the basedir, and its subdirectories, will be jarred. Otherwise all the files and directories mentioned in the items list will jarred. When a directory is specified, then all files within it are also jarred.

With the ignore attribute, you can specify files or directories to ignore. These files will not be jarred. The items in the ignore attribute override the items in the items attribute. The names specified in the ignore attribute are just names, they do not contain any path information!

Parameters

Examples

  <jar jarfile="${dist}/lib/app.jar" basedir="${build}/classes" />

jars all files in the ${build}/classes directory in a file called app.jar in the ${dist}/lib directory.

  <jar jarfile="${dist}/lib/app.jar"
       basedir="${build}/classes"
       excludes="**/Test.class"
  />

jars all files in the ${build}/classes directory in a file called app.jar in the ${dist}/lib directory. Files with the name Test.class are excluded.

  <jar jarfile="${dist}/lib/app.jar"
       basedir="${build}/classes"
       includes="mypackage/test/**"
       excludes="**/Test.class"
  />

jars all files in the ${build}/classes directory in a file called app.jar in the ${dist}/lib directory. Only files under the directory mypackage/test are used, and files with the name Test.class are excluded.

Deprecated examples

  <jar jarfile="${dist}/lib/app.jar" basedir="${build}/classes" items="*" />

jars all files in the ${build}/classes directory in a file called app.jar in the ${dist}/lib directory.

  <jar jarfile="${dist}/lib/app.jar" basedir="${build}/classes" items="*" ignore="Test.class" />

jars all files in the ${build}/classes directory in a file called app.jar in the ${dist}/lib directory. Files/directories with the name Test.class are excluded.

Java

Description

Executes a Java class within the running (Ant) VM or forks another VM if specified.

Be careful that the executed class doesn't call System.exit(), because it will terminate the VM and thus Ant. In case this happens, it's highly suggested that you set the fork attribute so that System.exit() stops the other VM and not the one that is currently running Ant.

Parameters

Parameters specified as nested elements

Java's classpath attribute is a PATH like structure and can also be set via a nested classpath element.

Example

  
       <java classname="test.Main" args="-h" >
         <classpath>
           <pathelement location="\test.jar" />
           <pathelement path="${java.class.path}" />
         </classpath>
       </java>

Examples

  <java classname="test.Main" />

  <java classname="test.Main" args="-h" />

  <java classname="test.Main"
        args="-h"
        fork="yes"
        jvmargs="-Xrunhprof:cpu=samples,file=log.txt,depth=3"
  />

Javac

Description

Compiles a source tree within the running (Ant) VM.

The source and destination directory will be recursively scanned for Java source files to compile. Only Java files that have no corresponding class file or where the class file is older than the java file will be compiled.

Files in the source tree, that are no java files, are copied to the destination directory, allowing support files to be located properly in the classpath.

The directory structure of the source tree should follow the package hierarchy.

It is possible to refine the set of files that are being compiled/copied. This can be done with the includes, includesfile, excludes, excludesfile and defaultexcludes attributes. With the includes or includesfile attribute you specify the files you want to have included by using patterns. The exclude or excludesfile attribute is used to specify the files you want to have excluded. This is also done with patterns. And finally with the defaultexcludes attribute, you can specify whether you want to use default exclusions or not. See the section on directory based tasks, on how the inclusion/exclusion of files works, and how to write patterns. The patterns are relative to the srcdir directory.

It is possible to use different compilers. This can be selected with the "build.compiler" property. There are three choices:

• classic (the standard compiler of JDK 1.1/1.2)
• modern (the new compiler of JDK 1.3)
• jikes (the Jikes compiler)

For JDK 1.1/1.2 is classic the default. For JDK 1.3 is modern the default.

Parameters

Parameters specified as nested elements

src, classpath, bootclasspath and extdirs

Javac's srcdir, classpath, bootclasspath and extdirs attributes are PATH like structure and can also be set via nested src, classpath, bootclasspath and extdirs elements respectively.

Examples

  <javac srcdir="${src}"
         destdir="${build}"
         classpath="xyz.jar"
         debug="on"
  />

compiles all .java files under the directory ${src}, and stores the .class files in the directory ${build}. It also copies the non-java files from the tree under ${src} to the tree under ${build}. The classpath used contains xyz.jar, and debug information is on.

  <javac srcdir="${src}"
         destdir="${build}"
         includes="mypackage/p1/**,mypackage/p2/**"
         excludes="mypackage/p1/testpackage/**"
         classpath="xyz.jar"
         debug="on"
  />

compiles .java files under the directory ${src}, and stores the .class files in the directory ${build}. It also copies the non-java files from the tree under ${src} to the tree under ${build}. The classpath used contains xyz.jar, and debug information is on. Only files under mypackage/p1 and mypackage/p2 are used. Files in the mypackage/p1/testpackage directory are excluded form compilation and copy.

  <javac srcdir="${src}:${src2}"
         destdir="${build}"
         includes="mypackage/p1/**,mypackage/p2/**"
         excludes="mypackage/p1/testpackage/**"
         classpath="xyz.jar"
         debug="on"
  />

is the same as the previous example with the addition of a second source path, defined by the propery src2. This can also be represented using nested elements as follows

  <javac destdir="${build}"
         classpath="xyz.jar"
         debug="on">
    <src path="${src}" />
    <src path="${src2}" />
    <include name="mypackage/p1/**,mypackage/p2/**" />
    <exclude name="mypackage/p1/testpackage/**" />
  </javac>

Javadoc/Javadoc2

Description

Generates code documentation using the javadoc tool.

The source directory will be recursively scanned for Java source files to process but only those matching the inclusion rules will be passed to the javadoc tool. This allows wildcards to be used to choose between package names, reducing verbosity and management costs over time. This task, however, has no notion of "changed" files, unlike the javac task. This means all packages will be processed each time this task is run. In general, however, this task is used much less frequently.

This task works seamlessly between different javadoc versions (1.1 and 1.2), with the obvious restriction that the 1.2 attributes will be ignored if run in a 1.1 VM.

NOTE: since javadoc calls System.exit(), javadoc cannot be run inside the same VM as ant without breaking functionality. For this reason, this task always forks the VM. This overhead is not significant since javadoc is normally a heavy application and will be called infrequently.

NOTE: the packagelist attribute allows you to specify the list of packages to document outside of the Ant file. It's a much better practice to include everything inside the build.xml file. This option was added in order to make it easier to migrate from regular makefiles, where you would use this option of javadoc. The packages listed in packagelist are not checked, so the task performs even if some packages are missing or broken. Use this option if you wish to convert from an existing makefile. Once things are running you should then switch to the regular notation.

DEPRECATION: the javadoc2 task simply points to the javadoc task and it's there for back compatibility reasons. Since this task will be removed in future versions, you are strongly encouraged to use javadoc instead.

Parameters

Parameters specified as nested elements

link

Parameters

groups

sourcepath, classpath and bootclasspath

Javadoc's sourcepath, classpath and bootclasspath attributes are PATH like structure and can also be set via nested sourcepath, classpath and bootclasspath elements respectively.

Example

  <javadoc packagenames="com.dummy.test.*"
           sourcepath="src"
           destdir="docs/api"
           author="true"
           version="true"
           use="true"
           windowtitle="Test API"
           doctitle="<h1>Test</h1>"
           bottom="<i>Copyright &#169; 2000 Dummy Corp. All Rights Reserved.</i>">
    <group title="Group 1 Packages" packages="com.dummy.test.a*"/>
    <group title="Group 2 Packages" packages="com.dummy.test.b*"/>
    <link offline="true" href="http://java.sun.com/products/jdk/1.2/docs/api/" packagelistLoc="C:\tmp"/>
    <link href="http://developer.java.sun.com/developer/products/xml/docs/api/"/>
  </javadoc>

KeySubst

Description

Performs keyword substitution in the source file, and writes the result to the destination file.

Keys in the source file are of the form ${keyname}. The keys attribute contains key/value pairs. When a key is found in the keys attribute, then "${keyname}" is replaced by the corresponding value.

The keys attribute is of the form "name1=value1*name2=value2*name3=value3". The '*' is called the separator, which might we changed with the sep attribute.

Note: the source file and destination file may not be the same.

Parameters

Examples

  <keysubst src="abc.txt" dest="def.txt" keys="VERSION=1.0.3*DATE=2000-01-10" />

Mkdir

Description

Creates a directory. Also non-existent parent directories are created, when necessary.

Parameters

Examples

<mkdir dir="${dist}" />

creates a directory ${dist}.

<mkdir dir="${dist}/lib" />

creates a directory ${dist}/lib.

Patch

Description

Applies a diff file to originals.

Parameters

Examples

  <patch patchfile="module.1.0-1.1.patch" />

applies the diff included in module.1.0-1.1.patch to the files in base directory guessing the filename(s) from the diff output.

  <patch patchfile="module.1.0-1.1.patch" strip="1" />

like above but one leading directory part will be removed. i.e. if the diff output looked like

--- a/mod1.0/A	Mon Jun  5 17:28:41 2000
+++ a/mod1.1/A	Mon Jun  5 17:28:49 2000

Property

Description

Sets a property (by name and value), or set of properties (from file or resource) in the project.

When a property was set by the user, or was a property in a parent project (that started this project with the ant task), then this property cannot be set, and will be ignored. This means that properties set outside the current project always override the properties of the current project.

There are three ways to set properties:

• By supplying both the name and value attribute.
• By setting the file attribute with the filename of the property file to load. This property file has the format as defined by the file used in the class java.util.Properties.
• By setting the resource attribute with the resource name of the property file to load. This property file has the format as defined by the file used in the class java.util.Properties.

Although combinations of the three ways are possible, only one should be used at a time. Problems might occur with the order in which properties are set, for instance.

The value part of the properties being set, might contain references to other properties. These references are resolved at the time these properties are set. This also holds for properties loaded from a property file.

Parameters

Examples

  <property name="foo.dist" value="dist" />

sets the property foo.dist to the value "dist".

  <property file="foo.properties" />

reads a set of properties from a file called "foo.properties".

  <property resource="foo.properties" />

reads a set of properties from a resource called "foo.properties".

Note that you can reference a global properties file for all of your Ant builds using the following:

  <property file="${user.home}/.ant-global.properties" />

since the "user.home" property is defined by the Java virtual machine to be your home directory. This technique is more appropriate for Unix than Windows since the notion of a home directory doesn't exist on Windows. On the JVM that I tested, the home directory on Windows is "C:\". Different JVM implementations may use other values for the home directory on Windows.

Rename

Description

Renames a given file.

Parameters

Examples

  <rename src="foo.jar" dest="${name}-${version}.jar" />

Renames the file foo.jar to ${name}-${version}.jar (assuming name and version being predefined properties). If a file named ${name}-${version}.jar already exists, it will be removed prior to renameing foo.jar.

Replace

Description

Replace is a directory based task for replacing the occurrence of a given string with another string in selected file.

Parameters

Examples

  <replace file="${src}/index.html" token="@@@" value="wombat" />

replaces occurrences of the string "@@@" with the string "wombat", in the file ${src}/index.html.

Rmic

Description

Runs the rmic compiler for a certain class.

Rmic can be run on a single class (as specified with the classname attribute) or a number of classes at once (all classes below base that are neither _Stub nor _Skel classes).

It is possible to refine the set of files that are being rmiced. This can be done with the includes, includesfile, excludes, excludesfile and defaultexcludes attributes. With the includes or includesfile attribute you specify the files you want to have included by using patterns. The exclude or excludesfile attribute is used to specify the files you want to have excluded. This is also done with patterns. And finally with the defaultexcludes attribute, you can specify whether you want to use default exclusions or not. See the section on directory based tasks, on how the inclusion/exclusion of files works, and how to write patterns. The patterns are relative to the base directory.

Parameters

Parameters specified as nested elements

classpath

Rmic's classpath attribute is a PATH like structure and can also be set via a nested classpath elements.

Examples

  <rmic classname="com.xyz.FooBar" base="${build}/classes" />

runs the rmic compiler for the class com.xyz.FooBar. The compiled files will be stored in the directory ${build}/classes.

  <rmic base="${build}/classes" includes="**/Remote*.class" />

runs the rmic compiler for all classes with .class files below ${build}/classes whose classname starts with Remote. The compiled files will be stored in the directory ${build}/classes.

SignJar

Description

Signs a jar or zip file with the javasign command line tool.

Parameters

Examples

<signjar jar="${dist}/lib/ant.jar" alias="apache-group" storepass="secret" />

signs the ant.jar with alias "apache-group" accessing the keystore and private key via "secret" password.

Tar

Description

Creates a tar archive.

The basedir attribute is the reference directory from where to tar.

It is possible to refine the set of files that are being tarred. This can be done with the includes, includesfile, excludes, excludesfile and defaultexcludes attributes. With the includes or includesfile attribute you specify the files you want to have included by using patterns. The exclude or excludesfile attribute is used to specify the files you want to have excluded. This is also done with patterns. And finally with the defaultexcludes attribute, you can specify whether you want to use default exclusions or not. See the section on directory based tasks, on how the inclusion/exclusion of files works, and how to write patterns. The patterns are relative to the basedir directory.

The includes, excludes and defaultexcludes attributes replace the items and ignore attributes. The following explains how the deprecated items and ignore attribute behave.

When "*" is used for items, all files in the basedir, and its subdirectories, will be tarred. Otherwise all the files and directories mentioned in the items list will tarred. When a directory is specified, then all files within it are also tarred.

With the ignore attribute, you can specify files or directories to ignore. These files will not be tarred. The items in the ignore attribute override the items in the items attribute. The names specified in the ignore attribute are just names, they do not contain any path information!

Note that this task does not perform compression. You might want to use the GZip task to come up with a .tar.gz package.

Parameters

Examples

  <tar tarfile="${dist}/manual.tar" basedir="htdocs/manual" />
  <gzip zipfile="${dist}/manual.tar.gz" src="${dist}/manual.tar" />

tars all files in the htdocs/manual directory in a file called manual.tar in the ${dist} directory, then applies the gzip task to compress it.

  <tar tarfile="${dist}/manual.tar"
       basedir="htdocs/manual"
       excludes="mydocs/**, **/todo.html"
  />

tars all files in the htdocs/manual directory in a file called manual.tar in the ${dist} directory. Files in the directory mydocs, or files with the name todo.html are excluded.

Taskdef

Description

Adds a task definition to the current project, such that this new task can be used in the current project. Two attributes are needed, the name that identifies this task uniquely, and the full name of the class (including the packages) that implements this task.

Taskdef should be used to add your own tasks to the system. See also "Writing your own task".

Parameters

Examples

  <taskdef name="myjavadoc" classname="com.mydomain.JavadocTask" />

makes a task called myjavadoc available to Ant. The class com.mydomain.JavadocTask implements the task.

Touch

Description

Changes the modification time of a file and possibly creates it at the same time.

For JDK 1.1 only the creation of new files with a modification time of now works, all other cases will emit a warning.

Parameters

If both millis and datetime are ommited the current time is assumed.

Examples

  <touch file="myfile" />

creates myfile if it doesn't exist and changes the modification time to the current time.

  <touch file="myfile" datetime="06/28/2000 2:02 pm" />

creates myfile if it doesn't exist and changes the modification time to Jun, 28 2000 2:02 pm (14:02 for those used to 24 hour times).

Tstamp

Description

Sets the DSTAMP, TSTAMP and TODAY properties in the current project. The DSTAMP is in the "yyyymmdd" format, the TSTAMP is in the "hhmm" format and TODAY is "month day year".

These properties can be used in the buildfile, for instance, to create timestamped filenames or used to replace placeholder tags inside documents to indicate, for example, the release date. The best place for this task is in your initialization target.

Parameters

Examples

  <tstamp/>

Style

Description

Process a set of documents via XSLT.

This is useful for building views of XML based documentation, or in generating code.

It is possible to refine the set of files that are being copied. This can be done with the includes, includesfile, excludes, excludesfile and defaultexcludes attributes. With the includes or includesfile attribute you specify the files you want to have included by using patterns. The exclude or excludesfile attribute is used to specify the files you want to have excluded. This is also done with patterns. And finally with the defaultexcludes attribute, you can specify whether you want to use default exclusions or not. See the section on directory based tasks, on how the inclusion/exclusion of files works, and how to write patterns. The patterns are relative to the basedir directory.

Parameters

Examples

<style basedir="doc" destdir="build/doc"
       extension="html" style="style/apache.xml"/>

Untar

Description

Untars a tarfile.

For JDK 1.1 "last modified time" field is set to current time instead of being carried from tarfile.

Parameters

Examples

<gunzip src="tools.tar.gz"/>
<untar src="tools.tar" dest="${tools.home}"/>

Zip

Description

Creates a zipfile.

The basedir attribute is the reference directory from where to zip.

It is possible to refine the set of files that are being zipped. This can be done with the includes, includesfile, excludes, excludesfile and defaultexcludes attributes. With the includes or includesfile attribute you specify the files you want to have included by using patterns. The exclude or excludesfile attribute is used to specify the files you want to have excluded. This is also done with patterns. And finally with the defaultexcludes attribute, you can specify whether you want to use default exclusions or not. See the section on directory based tasks, on how the inclusion/exclusion of files works, and how to write patterns. The patterns are relative to the basedir directory.

The includes, excludes and defaultexcludes attributes replace the items and ignore attributes. The following explains how the deprecated items and ignore attribute behave.

When "*" is used for items, all files in the basedir, and its subdirectories, will be zipped. Otherwise all the files and directories mentioned in the items list will zipped. When a directory is specified, then all files within it are also zipped.

With the ignore attribute, you can specify files or directories to ignore. These files will not be zipped. The items in the ignore attribute override the items in the items attribute. The names specified in the ignore attribute are just names, they do not contain any path information!

Parameters

Examples

  <zip zipfile="${dist}/manual.zip"
       basedir="htdocs/manual"
  />

zips all files in the htdocs/manual directory in a file called manual.zip in the ${dist} directory.

  <zip zipfile="${dist}/manual.zip"
       basedir="htdocs/manual"
       excludes="mydocs/**, **/todo.html"
  />

zips all files in the htdocs/manual directory in a file called manual.zip in the ${dist} directory. Files in the directory mydocs, or files with the name todo.html are excluded.

  <zip zipfile="${dist}/manual.zip"
       basedir="htdocs/manual"
       includes="api/**/*.html"
       excludes="**/todo.html"
  />

zips all files in the htdocs/manual directory in a file called manual.zip in the ${dist} directory. Only html files under the directory api are zipped, and files with the name todo.html are excluded.

Deprecated examples

  <zip zipfile="${dist}/manual.zip"
       basedir="htdocs/manual"
       items="*"
  />

zips all files in the htdocs/manual directory in a file called manual.zip in the ${dist} directory.

  <zip zipfile="${dist}/manual.zip"
       basedir="htdocs/manual"
       items="*"
       ignore="mydocs, todo.html"
  />

zips all files in the htdocs/manual directory in a file called manual.zip in the ${dist} directory. Files/directories with the names mydocs and todo.html are excluded.

Build Events

To use build events you need to create an ant Project object. You can then call the addBuildListener method to add your listener to the project. Your listener must implement the org.apache.tools.antBuildListener interface. The listener will receive BuildEvents for the following events

• Build started
• Build finished
• Target started
• Target finished
• Task started
• Task finished
• Message logged

ant -listener org.apache.tools.ant.XmlLogger

Writing your own task

It is very easy to write your own task:

1. Create a Java class that extends org.apache.tools.ant.Task.
2. For each attribute, write a setter method. The setter method must be a public void method that takes a single argument. The name of the method must begin with "set", followed by the attribute name, with the first character in uppercase, and the rest in lowercase. The type of the attribute can be String, any primitive type, Class, File (in which case the value of the attribute is interpreted relative to the project's basedir) or any other type that has a constructor with a single String argument
3. If your task has enumerated attributes, you should consider using a subclass of org.apache.tools.ant.EnumeratedAttribute as argument to your setter method. See org.apache.tools.ant.taskdefs.FixCRLF for an example.
4. If the task should support character data, write a public void addText(String) method.
5. For each nested element, write a create or add method. A create method must be a public method that takes no arguments and returns an Object type. The name of the create method must begin with "create", followed by the element name. An add method must be a public void method that takes a single argument of an Object type with a no argument constructor. The name of the add method must begin with "add", followed by the element name.
6. Write a public void execute method, with no arguments, that throws a BuildException. This method implements the task itself.

It is important to know that Ant first calls the setters for the attributes it encounters for a specific task in the buildfile, before it executes is.

Let's write our own task, that prints a message on the System.out stream. The task has one attribute called "message".

package com.mydomain;

import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Task;

public class MyVeryOwnTask extends Task {
  private String msg;

  // The method executing the task
  public void execute() throws BuildException {
    System.out.println(msg);
  }

  // The setter for the "message" attribute
  public void setMessage(String msg) {
    this.msg = msg;
  }
}

It's really this simple;-)

Adding your task to the system is rather simple too:

1. Make sure the class that implements your task is in the classpath when starting Ant.
2. In your initialization target, add a taskdef task. This actually adds your task to the system.
3. Use your task in the rest of the buildfile.

Example

<?xml version="1.0"?>

<project name="OwnTaskExample" default="main" basedir=".">
  <target name="init">
    <taskdef name="mytask" classname="com.mydomain.MyVeryOwnTask"/>
  </target>

  <target name="main" depends="init">
    <mytask message="Hello World! MyVeryOwnTask works!" />
  </target>
</project>

Another way to add a task (more permanently), is to add the task name and implementing class name to the default.properties file in the org.apache.tools.ant.taskdefs package. Then you can use it as if it were a built in task.

FAQ, DTD, external resources

There is an online FAQ for Ant at jakarta.apache.org. This FAQ is interactive, which means you can ask and answer questions online.

One of the questions poping up quite often is "Is there a DTD for buildfiles?". Please refer to the FAQ for an answer.

The FAQ contains lists of known custom tasks that don't ship with Ant and projects that use Ant. Feel free to add your own task or project there.

Feedback

To provide feedback on this software, please subscribe to the Ant Development Mail List (ant-dev-subscribe@jakarta.apache.org)

Copyright © 2000 Apache Software Foundation. All rights Reserved.

Optional tasks

• NetRexxC
• RenameExtensions
• Script
• VssGet

NetRexxC

Description:

Compiles a NetRexx source tree within the running (Ant) VM.

The source and destination directory will be recursively scanned for NetRexx source files to compile. Only NetRexx files that have no corresponding class file or where the class file is older than the java file will be compiled.

Files in the source tree are copied to the destination directory, allowing support files to be located properly in the classpath. The source files are copied because the NetRexx compiler cannot produce class files in a specific directory via parameters

The directory structure of the source tree should follow the package hierarchy.

It is possible to refine the set of files that are being compiled/copied. This can be done with the includes, includesfile, excludes, excludesfile and defaultexcludes attributes. With the includes or includesfile attribute you specify the files you want to have included by using patterns. The exclude or excludesfile attribute is used to specify the files you want to have excluded. This is also done with patterns. And finally with the defaultexcludes attribute, you can specify whether you want to use default exclusions or not. See the section on directory based tasks, on how the inclusion/exclusion of files works, and how to write patterns. The patterns are relative to the srcDir directory.

Parameters:

Examples

<netrexxc srcDir="/source/project" includes="vnr/util/*" destDir="/source/project/build" classpath="/source/project2/proj.jar" comments="true" crossref="false" replace="true" keep="true" />

RenameExtensions

Description:

Renames files in the srcDir directory ending with the fromExtension string so that they end with the toExtension string. Files are only replaced if replace is true

See the section on directory based tasks, on how the inclusion/exclusion of files works, and how to write patterns. The patterns are relative to the srcDir directory.

Parameters:

Examples

<renameext srcDir="/source/project1" includes="**" excludes="**/samples/*" fromExtension=".java.keep" toExtension=".java" replace="true" />

Script

Description:

Execute a script in a BSF supported language.

All items (tasks, targets, etc) of the running project are accessible from the script.

Parameters:

Examples

None yet available

VssGet

Description:

The following attributes are interpretted:

Parameters:

Note that only one of version, date or label should be specified

Examples

None yet available