<project name="subant" default="subant1">
            <property name="build.dir" value="subant.build"/>
            <target name="subant1">
                <subant target="">
                    <property name="build.dir" value="subant1.build"/>
                    <property name="not.overloaded" value="not.overloaded"/>
                    <fileset dir="." includes="*/build.xml"/>
                </subant>
            </target>
        </project>
        
            this snippet build file will run ant in each subdirectory of the project directory,
            where a file called build.xml can be found.
            The property build.dir will have the value subant1.build in the ant projects called by subant.
        
          <subant target="">
              <propertyset>
                  <propertyref prefix="toplevel"/>
                  <mapper type="glob" from="foo*" to="bar*"/>
              </propertyset>
              <fileset dir="." includes="*/build.xml"/>
          </subant>
        
            this snippet build file will run ant in each subdirectory of the project directory,
            where a file called build.xml can be found.
            All properties whose name starts with "foo" are passed, their names are changed to start with "bar" instead
        
          <subant target="compile" genericantfile="/opt/project/build1.xml">
              <dirset dir="." includes="projects*"/>
          </subant>
        
            assuming the subdirs of the project dir are called projects1, projects2, projects3
            this snippet will execute the compile target of /opt/project/build1.xml,
            setting the basedir to projects1, projects2, projects3
        
        
        Now a little more complex - but useful - scenario. Assume that we have
        a directory structure like this:
        
        root
          |  common.xml
          |  build.xml
          |
          +-- modules
                +-- modA
                |     +-- src
                +-- modB
                      +-- src
        common.xml:
        <project>
            <property name="src.dir"      value="src"/>
            <property name="build.dir"    value="build"/>
            <property name="classes.dir"  value="${build.dir}/classes"/>
            <target name="compile">
                <mkdir dir="${classes.dir}"/>
                <javac srcdir="${src.dir}" destdir="${classes.dir}"/>
            </target>
            <!-- more targets -->
        </project>
        build.xml:
        <project>
            <macrodef name="iterate">
                <attribute name="target"/>
                <sequential>
                    <subant target="@{target}">
                        <fileset dir="modules" includes="*/build.xml"/>
                    </subant>
                </sequential>
            </macrodef>
            <target name="compile">
                <iterate target="compile"/>
            </target>
            <!-- more targets -->
        </project>
        modules/modA/build.xml:
        <project name="modA">
            <import file="../../common.xml"/>
        </project>
        
        This results in very small buildfiles in the modules, maintainable
        buildfile (common.xml) and a clear project structure. Additionally
        the root buildfile is capable to run the whole build over all
        modules.
        
        
        <subant failonerror="false">
            <fileset dir="." includes="**/build.xml" excludes="build.xml"/>
            <target name="clean"/>
            <target name="build"/>
        </subant>
        
        Does a "clean build" for each subproject.
        Hint: because buildfiles are plain xml, you could generate the
        masterbuildfile from the common buildfile by using a XSLT transformation:
        
        
        <xslt in="common.xml"
              out="master.xml"
              style="${ant.home}/etc/common2master.xsl"
        />