root/trunk/ProjectFortress/build.xml

<?xml version="1.0" ?>

<!--
    Copyright 2008 Sun Microsystems, Inc.,
    4150 Network Circle, Santa Clara, California 95054, U.S.A.
    All rights reserved.

    U.S. Government Rights - Commercial software.
    Government users are subject to the Sun Microsystems, Inc. standard
    license agreement and applicable provisions of the FAR and its supplements.

    Use is subject to license terms.

    This distribution may include materials developed by third parties.

    Sun, Sun Microsystems, the Sun logo and Java are trademarks or registered
    trademarks of Sun Microsystems, Inc. in the U.S. and other countries. -->


<project name="Fortress" default="help">
    <description>
        The Fortress interpreter, implemented in Java.
    </description>

    <!-- test -->

<!-- Set global properties for this build. -->
 <property name="packagePrefix" value="com/sun/fortress"/>
 <property name="package.prefix" value="com.sun.fortress"/>
 <property name="interpreterPrefix" value="com/sun/fortress/interpreter"/>
 <property name="interpreter.prefix" value="com.sun.fortress.interpreter"/>
 <!-- Directories in the ${basedir} directory -->
 <property name="cache0" location="${basedir}/../default_repository/caches"/>
 <property name="cache1" location="${basedir}/../.fortress_cache"/>
 <property name="cache2" location="${basedir}/../.interpreter_cache"/>
 <property name="cache3" location="${basedir}/.interpreter_cache"/>
 <property name="cache4" location="${basedir}/../.syntax_cache"/>
 <property name="cache5" location="${basedir}/.syntax_cache"/>
 <property name="cache6" location="${basedir}/../.analyzed_cache"/>
 <property name="cache7" location="${basedir}/.analyzed_cache"/>
 <property name="cache8" location="${basedir}/../.presyntax_cache"/>
 <property name="cache9" location="${basedir}/.presyntax_cache"/>
 <property name="cache10" location="${basedir}/../.bytecode_cache"/>
 <property name="cache11" location="${basedir}/.bytecode_cache"/>
 <property name="cache12" location="${basedir}/../local_repository/caches"/>
 <property name="astgen.src" location="${basedir}/astgen"/>
 <property name="build" location="${basedir}/build"/>
 <property name="docs" location="${basedir}/docs"/>
 <property name="src" location="${basedir}/src"/>
 <property name="library" location="${basedir}/../Library"/>
 <property name="astgen.generators.src" location="${src}/${packagePrefix}/astgen"/>
 <!-- Third party jar files -->
 <property name="asm" location="${basedir}/third_party/asm"/>
 <!-- property name="astgen.third" location="${basedir}/../../astgen/jar"/ -->
 <property name="astgen.third" location="${basedir}/third_party/astgen"/>
 <property name="jsr166y" location="${basedir}/third_party/jsr166y"/>
 <property name="junit" location="${basedir}/third_party/junit"/>
 <property name="plt" location="${basedir}/third_party/plt"/>
 <property name="unicode.third" location="${basedir}/third_party/unicode"/>
 <property name="xtc" location="${basedir}/third_party/xtc"/>
 <property name="unsigned" location="${basedir}/third_party/unsigned"/>
 <!-- astgen -->
 <property name="generate-sourcefile" value="${astgen.src}/Fortress.ast" />
 <!-- nodes -->
 <property name="nodesPackage" value="${packagePrefix}/nodes"/>
 <property name="nodes"  location="${src}/${nodesPackage}"/>
 <property name="nodesBuild" location="${build}/${nodesPackage}"/>
 <!-- nodes_util -->
 <property name="nodesUtil"  location="${src}/${packagePrefix}/nodes_util"/>
 <!-- parser -->
 <property name="parser"  location="${src}/${packagePrefix}/parser"/>
 <property name="preparser" location="${src}/${packagePrefix}/parser/preparser"/>
 <property name="templateparser"  location="${src}/${packagePrefix}/parser/templateparser"/>
 <property name="parserUtil"  location="${src}/${packagePrefix}/parser_util"/>
 <property name="precedence" location="${parserUtil}/precedence"/>
 <property name="precedenceResolver" location="${parserUtil}/precedence_resolver"/>
 <!-- unicode -->
 <property name="unicodePackage" value="${packagePrefix}/unicode"/>
 <property name="unicode" location="${src}/${packagePrefix}/unicode"/>
 <property name="unicodeBuild" location="${build}/${unicodePackage}"/>
 <!-- useful -->
 <property name="usefulPackage" value="${packagePrefix}/useful"/>
 <!-- for fortress installation -->
 <property name="testFortress" location=".TEST_FORTRESS"/>
 <property name="installerDir" location=".installer"/>
 <property name="protofortress" location="${basedir}/fortress/FORTRESS"/>
 <property name="protofortress.lib" location="${protofortress}/lib"/>
<!-- for tests -->
 <property name="test.results" location="${basedir}/TEST-RESULTS"/>
<!-- other setting -->
 <property name="junitMem" value="768m"/>
 <property name="junit.dir" value="junit-results"/>
 <property environment="env"/>

 <path id="astgen.path">
     <pathelement location="${astgen.third}/astgen.jar" />
     <pathelement location="${build}" />
 </path>

 <path id="compile.classpath">
    <pathelement location="${java.home}/../lib/tools.jar"/>
    <pathelement location="${build}"/>
    <pathelement location="${asm}/asm-3.1.jar"/>
    <pathelement location="${xtc}/xtc.jar"/>
    <pathelement location ="${unsigned}/unsigned.jar"/>
    <pathelement location="${jsr166y}/jsr166y.jar"/>
    <pathelement location="${plt}/plt.jar"/>
    <pathelement location="${astgen.third}/astgen.jar" />
    <pathelement location="${junit}/junit.jar"/>
    <pathelement location="${ant.home}/lib/ant.jar"/>
</path>

 <path id="astgen.classpath">
    <pathelement location="${build}"/>
    <pathelement location="${astgen.third}/astgen.jar"/>
</path>

 <property name="instrumentation.package"
           value="${package.prefix}.parser_util.instrumentation"/>
 <property name="instrumentationPackage"
           value="${packagePrefix}/parser_util/instrumentation"/>
 <property name="instrumentation.outfile"
           location="${parserUtil}/instrumentation/coverage-report.txt"/>
 <property name="instrumentation.transient"
           location="${parserUtil}/instrumentation/transient.txt"/>

 <path id="instrumentedparser.classpath">
    <pathelement location="${build}"/>
    <pathelement location="${xtc}/xtc.jar"/>
    <pathelement location="${plt}/plt.jar"/>
 </path>

 <property name="blahblahblah" value="com/sun/fortress"/>

    <target name="help">
        <echo message="ant checkEnv, checkNodesUptodate, checkOperatorsUptodate,
checkParserUptodate, clean, cleanCache, compile, compileCommon, compileCommonLint,
compileLint, doc, grammarCoverage, help, init, interpreter-jar, makeAST, operatorsGen,
fortressparser, preparser, parser, reportNotPassing, systemProperties,
test, testAll, testDemos, testSystem,
testOnly -DtestPattern='some pattern', testCruiseControl"/>
        <echo message="If you are building Fortress, you want ant compile or ant test."/>
    </target>

    <condition property="correct.environment">
        <and>
            <equals arg1="${ant.java.version}" arg2="1.5"/>
            <equals arg1="${env.ANT_CALLED_FROM_SCRIPT}" arg2='yes'/>
        </and>
    </condition>

    <target name="systemProperties">
        <echo message="Environment variables set correctly? ${correct.environment}"/>
        <echo message="Ant Java version: ${ant.java.version}"/>
        <echo message="Ant called from script? ${env.ANT_CALLED_FROM_SCRIPT}"/>
        <echo message="ANT_ARGS: ${env.ANT_ARGS}"/>
        <echo message="ANT_OPTS: ${env.ANT_OPTS}"/>
        <echo message="Java Runtime Environment
        version: ${java.version}"/>
        <echo message="Java Runtime Environment
        vendor: ${java.vendor}"/>
        <echo message="Java Runtime Environment
        vendor URL: ${java.vendor.url}"/>
        <echo message="Java installation
        directory: ${java.home}"/>
        <echo message="Java Virtual Machine
              specification version:
        ${java.vm.specification.version}"/>
        <echo message="Java Virtual Machine
              specification vendor:
        ${java.vm.specification.vendor}"/>
        <echo message="Java Virtual Machine
              specification name:
        ${java.vm.specification.name}"/>
        <echo message="Java Virtual Machine
              implementation version:
        ${java.vm.version}"/>
        <echo message="Java Virtual Machine
              implementation vendor:
        ${java.vm.vendor}"/>
        <echo message="Java Virtual Machine
        implementation name: ${java.vm.name}"/>
        <echo message="Java Runtime Environment
              specification version:
        ${java.specification.version}"/>
        <echo message="Java Runtime Environment
              specification vendor:
        ${java.specification.vendor}"/>
        <echo message="Java Runtime Environment
              specification name:
        ${java.specification.name}"/>
        <echo message="Java class format version
        number: ${java.class.version}"/>
        <echo message="Java class path:
        ${java.class.path}"/>
        <echo message="List of paths to search when
        loading libraries: ${java.library.path}"/>
        <echo message="Path of extension directory
        or directories: ${java.ext.dirs}"/>
        <echo message="Default temp file path:
        ${java.io.tmpdir}"/>
        <echo message="Operating system name:
        ${os.name}"/>
        <echo message="Operating system
        architecture: ${os.arch}"/>
        <echo message="Operating system version:
        ${os.version}"/>
    </target>

    <target name="checkEnv">
        <echo message="Environment variables set correctly? ${correct.environment}"/>
        <fail unless="correct.environment"
              message='ERROR: This build script requires specific command-line arguments to Ant. Please call it using the script provided at ${basedir}/ant.'/>
    </target>

    <target name="init">
        <echo message="basedir: ${basedir}"/>
        <!-- Create the time stamp. -->
        <tstamp/>
        <!-- Create the build directory structure used by compile. -->
        <mkdir dir="${build}"/>
        <mkdir dir="${junit.dir}"/>
    </target>

    <target name="clean" depends="cleanCache"
            description="Delete the ${build} directory tree and generated files.">
        <delete dir="${build}"/>
        <delete dir="${nodes}"/>
        <delete dir="${junit.dir}"/>

        <!-- No longer needed, but eases the upgrade-->
        <delete file="${nodesUtil}/BaseNodeMaker.java"/>
        <!-- No longer needed, but eases the upgrade-->
        <delete file="${nodesUtil}/InterfaceMaker.java"/>
        <delete file="${parser}/Fortress.java"/>
        <delete file="${parser}/FortressInstrumented.java"/>
        <delete file="${preparser}/PreFortress.java"/>
        <delete file="${templateparser}/TemplateParser.java"/>
        <delete file="${precedenceResolver}/Operators.java"/>
        <!-- No longer needed, but eases the upgrade-->
        <delete file="${src}/com/sun/fortress/parser/precedence/resolver/Operators.java"/>
        <delete file="${instrumentation.outfile}"/>
        <delete file="${library}/FortressAst.fsi" />
        <delete file="${library}/FortressAst.fss" />
        <delete file="FortressLibrary.ast"/>
        <delete file="FortressLibrary.tfs"/>
        <delete file="testFile.txt"/>
        <delete dir="${basedir}/test-tmp" />
        <delete>
            <fileset dir="src" includes="**/*.class" />
        </delete>
    </target>

    <target name="cleanCache"
            description="Delete any cached Fortress ASTs in the development tree">
        <delete dir="${cache0}"/>
        <delete dir="${cache1}"/>
        <delete dir="${cache2}"/>
        <delete dir="${cache3}"/>
        <delete dir="${cache4}"/>
        <delete dir="${cache5}"/>
        <delete dir="${cache6}"/>
        <delete dir="${cache7}"/>
        <delete dir="${cache8}"/>
        <delete dir="${cache9}"/>
        <delete dir="${cache10}"/>
        <delete dir="${cache11}"/>
        <delete dir="${cache12}"/>
    </target>

    <!-- Generation of Operators.java depends only on the files listed below.
         Note that there are class files it depends on; if these class files are
         not up to date with respect to their sources, they are themselves
         recompiled by the compileCommon target.-->
    <target name="checkOperatorsUptodate" depends="init, compileCommon">
        <condition property="operators.uptodate">
            <and>
                <uptodate srcfile="${unicode.third}/UnicodeData.500.txt"
                          targetfile="${precedenceResolver}/Operators.java"/>
                <uptodate srcfile="${precedenceResolver}/operators.txt"
                          targetfile="${precedenceResolver}/Operators.java"/>
                <uptodate srcfile="${unicodeBuild}/OperatorStuffGenerator.class"
                          targetfile="${precedenceResolver}/Operators.java"/>
                <uptodate srcfile="${unicodeBuild}/Element.class"
                          targetfile="${precedenceResolver}/Operators.java"/>
            </and>
        </condition>
        <echo message="Operators up to date? ${operators.uptodate}"/>
    </target>

           <target name="operatorsGen"  unless="operators.uptodate"
                    depends="init, compileCommon, checkOperatorsUptodate"
             description="Automatically generate visitors for AST nodes.">
                <echo message="Regenerating operators"/>
                <java classname="${package.prefix}.unicode.OperatorStuffGenerator"
                      fork="true">
                    <classpath>
                        <pathelement location="${build}"/>
                        <pathelement location="${basedir}/third_party/plt/plt.jar"/>
                    </classpath>
                </java>
            </target>

           <target name="DumpProperties"
             description="Dump properties as seen by a Java program.">
            <java classname="${package.prefix}.repository.DumpProperties"
                      fork="true">
                <sysproperty key="DEBUG" value="true"/>
                    <classpath>
                        <pathelement location="${build}"/>
                    </classpath>
                </java>
            </target>

    <target name="checkAstgen">
        <condition property="astgenerators.uptodate">
                <uptodate targetfile="${basedir}/build/com/sun/fortress/astgen/FortressAstGenerator.class">
                    <srcfiles dir="${basedir}/src/com/sun/fortress/astgen/" includes="*.java"/>
                </uptodate>
        </condition>
    </target>

    <target name="astGenerators" unless="astgenerators.uptodate" depends="init,checkAstgen"
     description="Compile all AstGen custom generators.">
        <depend srcdir="${astgen.generators.src}"
         destdir="${build}"
         closure="yes"
         cache="${basedir}/.dependencies"/>
        <javac
            srcdir="${astgen.generators.src}"
            destdir="${build}"
            source="1.5"
            debug="true"
            includeantruntime="false"
            fork="true"
            memorymaximumsize="256M">
            <!-- Uncomment the following line to print unchecked warnings
                 (here and in the 'compileCommon' target. -->
            <!-- <compilerarg value="-Xlint:unchecked"/> -->
            <classpath refid="astgen.classpath"/>
            <include name="**/*.java"/>
            <exclude name="${usefulPackage}/*.java"/>
            <exclude name="${unicodePackage}/*.java"/>
        </javac>
    </target>

    <target name="checkNodesUptodate" depends="astGenerators">
        <condition property="nodes.uptodate">
          <and>
            <available file="${nodes}/AbstractNode.java"/>
            <uptodate srcfile="${astgen.src}/Fortress.ast"
                      targetfile="${nodes}/AbstractNode.java"/>
            <available file="${library}/FortressAst.fsi" />
            <uptodate srcfile="${astgen.src}/Fortress.ast"
                    targetfile="${library}/FortressAst.fsi" />
            <available file="${library}/FortressAst.fss" />
            <uptodate srcfile="${astgen.src}/Fortress.ast"
                    targetfile="${library}/FortressAst.fss" />
            <uptodate targetfile="${library}/FortressAst.fsi">
                  <srcfiles dir="${basedir}/src/com/sun/fortress/astgen/" includes="**/*.java"/>
            </uptodate>
          </and>
        </condition>
        <echo message="Nodes up to date? ${nodes.uptodate}"/>
    </target>

    <taskdef name="astgen" classpath="${astgen.third}/astgen.jar;${build}"
             classname="edu.rice.cs.astgen.AntTask"/>

    <target name="makeAST" unless="nodes.uptodate" depends="checkNodesUptodate"
     description="Automatically generate AST nodes.">
        <echo message="Processing ${generate-sourcefile}" />
        <astgen file="${generate-sourcefile}" />
        <move todir="${nodes}">
          <fileset dir="${astgen.src}">
            <include name="**/*.java"/>
            <exclude name="**/Fortress.ast"/>
          </fileset>
        </move>
        <move todir="${library}">
          <fileset dir="${astgen.src}">
            <include name="FortressAst.*" />
          </fileset>
        </move>
    </target>

    <target name="compile" depends="compileCommon, makeAST, parser, operatorsGen"
     description="Compile all Fortress code.">
        <depend srcdir="${src}"
         destdir="${build}"
         closure="yes"
         cache="${basedir}/.dependencies"/>
        <javac
            srcdir="${src}"
            destdir="${build}"
            source="1.5"
            debug="true"
            includeantruntime="false"
            fork="true"
            memorymaximumsize="256M">
            <!-- Uncomment the following line to print unchecked warnings
                 (here and in the 'compileCommon' target. -->
            <!-- <compilerarg value="-Xlint:unchecked"/> -->
            <classpath refid="compile.classpath"/>
            <include name="**/*.java"/>
            <exclude name="${usefulPackage}/*.java"/>
            <exclude name="${unicodePackage}/*.java"/>
        </javac>
    </target>

    <target name="check.blas" depends="init">
        <javac destdir="${build}" srcdir="${src}/com/sun/fortress/numerics">
            <classpath refid="compile.classpath"/>
        </javac>
        <java failonerror="true" classname="com.sun.fortress.numerics.CheckBlasEnvironment">
            <classpath refid="compile.classpath"/>
        </java>
    </target>

    <target name="check.linux">
        <condition property="blas.islinux">
             <equals arg1="${os.name}" arg2="Linux" />
        </condition>
    </target>

    <target name="blas.linux" depends="check.linux" if="blas.islinux">
            <echo message="Generating C header and stub files." />
            <javah class="com.sun.fortress.numerics.Blas"
                   destdir="c"
                   classpath="build"
                    />
            <echo message="Now compiling C stubs for blas on arch linux."/>
            <exec executable="gcc" failonerror="true">
                    <arg value="-fPIC" />
                    <arg value="-Ic" />
                    <arg value="-I${env.BLAS_INCLUDE}" />
                    <arg value="-L${env.BLAS_LIB}" />
                    <arg value="-I${env.JAVA_HOME}/include" />
                    <arg value="-I${env.JAVA_HOME}/include/linux" />
                    <arg value="c/blas.c" />
                    <arg value="-lcblas" />
                    <arg value="-lblas" />
                    <arg value="-shared" />
                    <arg value="-olibblas.so" />
            </exec>
    </target>

    <target name="check.osx">
        <condition property="blas.is.osx">
             <equals arg1="${os.name}" arg2="Mac OS X" />
        </condition>
    </target>

    <target name="blas.osx" depends="check.osx" if="blas.is.osx">
            <echo message="Generating C header and stub files." />
            <javah class="com.sun.fortress.numerics.Blas"
                   destdir="c"
                   classpath="build"
                    />
            <echo message="Now compiling C stubs for blas on arch OS X."/>