path: root/build.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- $Id$ -->

<project name="scala-core" default="build">

  <description>
    I am Sabbus for Scala-core, the build system for the Scala compiler and core
    library. Please check the 'docs/README' file for more information about me.
  </description>
  
  <echo>Running Sabbus for Scala-core</echo>

<!-- ===========================================================================
PROPERTIES
============================================================================ -->
  
  <property environment="env"/>
  <condition property="memory.set">
    <contains string="${env.ANT_OPTS}" substring="-Xmx"/>
  </condition>
  <fail unless="memory.set">
    Sabbus requires additional memory. Please set the 'ANT_OPTS' environment
    property to '-Xmx256M' or more.
  </fail>

  <!-- Prevents system classpath from being used -->
  <property name="build.sysclasspath" value="ignore"/>

  <!-- Base properties -->
  <property name="docs.dir" value="${basedir}/docs"/>
  <property name="lib.dir" value="${basedir}/lib"/>
  <property name="src.dir" value="${basedir}/src"/>
  <property name="test.dir" value="${basedir}/test"/>
  <!-- User properties -->
  <property file="${basedir}/build.properties"/>
  <!-- General properties -->
  <property name="copyright" value="(c) 2002-06 LAMP/EPFL"/>
  <!-- NSC configuration properties -->
  <property name="nsc.logging" value="none"/>
  <property name="nsc.debug-info" value="yes"/>
  <property name="nsc.excludes" value="build.excludes"/>
  <property name="nsc.params" value=""/>
  <!-- Location of pre-compiled libraries properties -->
  <property name="starr.lib.jar" value="${lib.dir}/scala-library.jar"/>
  <property name="starr.comp.jar" value="${lib.dir}/scala-compiler.jar"/>
  <property name="jaco.jar" value="${lib.dir}/jaco.jar"/>
  <property name="fjbg.name" value="fjbg.jar"/>
  <property name="fjbg.jar" value="${lib.dir}/${fjbg.name}"/>
  <property name="msil.name" value="msil.jar"/>
  <property name="msil.jar" value="${lib.dir}/${msil.name}"/>
  <property name="scala.dll" value="${lib.dir}/scala.dll"/>
  <property name="ant.jar" value="${ant.home}/lib/ant.jar"/>
  <property name="ant-contrib.jar" value="${lib.dir}/ant-contrib.jar"/>
  <!-- Location of build products properties -->
  <property name="build.dir" value="${basedir}/build"/>
  <property name="locker.dir" value="${build.dir}/locker"/>
  <property name="quick.dir" value="${build.dir}/quick"/>
  <property name="strap.dir" value="${build.dir}/strap"/>
  <!-- Location of source and build elements names properties -->
  <property name="lib.dir.name" value="library"/>
  <property name="comp.dir.name" value="compiler"/>
  <property name="exec.dir.name" value="exec"/>
  <!-- Location of structure of the distribution properties -->
  <property name="dist.dir" value="${basedir}/dists"/>
  <property name="dist.latest.dir" value="${dist.dir}/latest"/>
  <property name="dist.name" value="scala2"/>
  <property name="lib.jar.name" value="${dist.name}-${lib.dir.name}.jar"/>
  <property name="comp.jar.name" value="${dist.name}-${comp.dir.name}.jar"/>
  <property name="scala.exec.name" value="${dist.name}"/>
  <property name="scalai.exec.name" value="scalai2"/>
  <property name="scalac.exec.name" value="scalac2"/>
  <property name="scalatok.exec.name" value="scalatok2"/>
  <!-- Shorcut names -->
  <property name="locker.lib.dir" value="${locker.dir}/${lib.dir.name}"/>
  <property name="locker.comp.dir" value="${locker.dir}/${comp.dir.name}"/>
  <property name="quick.lib.dir" value="${quick.dir}/${lib.dir.name}"/>
  <property name="quick.comp.dir" value="${quick.dir}/${comp.dir.name}"/>
  <property name="strap.lib.dir" value="${strap.dir}/${lib.dir.name}"/>
  <property name="strap.comp.dir" value="${strap.dir}/${comp.dir.name}"/>

<!-- ===========================================================================
INITIALISATION
============================================================================ -->

  <target name="init">
    <!-- Testing if everything is in place -->
    <echo level="verbose">starr.lib.jar=${starr.lib.jar}</echo>
    <fail message="STARR library in 'lib/' is not available">
      <condition><not><and>
        <available classname="scala.Predef" 
                   classpath="${starr.lib.jar}"/>
        <available classname="scala.List"
                   classpath="${starr.lib.jar}"/>
        <available classname="scala.runtime.ObjectRef"
                   classpath="${starr.lib.jar}"/>
      </and></not></condition>
    </fail>
    <echo level="verbose">starr.comp.jar=${starr.comp.jar}</echo>
    <fail message="STARR compiler in 'lib/' is not available">
      <condition><not>
        <available classname="scala.tools.ant.Scalac"
                   classpath="${starr.comp.jar}:${starr.lib.jar}"/>
      </not></condition>
    </fail>
    <echo level="verbose">fjbg.jar=${fjbg.jar}</echo>
    <fail message="FJBG library in 'lib/' is not available">
      <condition><not>
        <available classname="ch.epfl.lamp.fjbg.JCode"
                   classpath="${fjbg.jar}"/>
      </not></condition>
    </fail>
    <echo level="verbose">msil.jar=${msil.jar}</echo>
    <fail message="MSIL library in 'lib/' is not available">
      <condition><not>
        <available classname="ch.epfl.lamp.compiler.msil.Assembly"
                   classpath="${msil.jar}"/>
      </not></condition>
    </fail>
    <echo level="verbose">jaco.jar=${jaco.jar}</echo>
    <fail message="JaCo compiler in 'lib/' is not available">
      <condition><not>
        <available classname="jaco.pizza.Main" classpath="${jaco.jar}"/>
      </not></condition>
    </fail>
    <echo level="verbose">ant.jar=${ant.jar}</echo>
    <echo level="verbose">ant-contrib.jar=${ant-contrib.jar}</echo>
    <fail message="Additional Ant tasks in 'lib/' is not available">
      <condition><not>
        <available classname="net.sf.antcontrib.AntContribVersion"
                   classpath="${ant-contrib.jar}"/>
      </not></condition>
    </fail>
    <!-- Creating class-pathes -->
    <path id="common.classpath">
      <pathelement location="${fjbg.jar}"/>
      <pathelement location="${msil.jar}"/>
    </path>
    <path id="starr.classpath">
      <pathelement location="${starr.lib.jar}"/>
      <pathelement location="${starr.comp.jar}"/>
      <path refid="common.classpath"/>
    </path>
    <!-- Creating boot-level tasks -->
    <taskdef name="starr"
             classname="scala.tools.ant.Scalac"
             classpathref="starr.classpath"/>
    <taskdef name="starrtool"
             classname="scala.tools.ant.ScalaTool"
             classpathref="starr.classpath"/>
    <taskdef name="pico"
             classname="jaco.pizza.ant.Pico"
             classpath="${jaco.jar}"/>
    <taskdef resource="net/sf/antcontrib/antlib.xml">
      <classpath>
        <pathelement location="${ant-contrib.jar}"/>
      </classpath>
    </taskdef>
    <!-- Finding out what is available -->
    <available property="excludes.avail" file="${nsc.excludes}"/>
    <condition property="locker.avail">
      <and>
        <available classname="scala.Predef" classpath="${locker.lib.dir}"/>
        <available classname="scala.List" classpath="${locker.lib.dir}"/>
        <available classname="scala.runtime.ObjectRef"
                   classpath="${locker.lib.dir}"/>
        <available classname="scala.tools.ant.Scalac"
                   classpath="${locker.comp.dir}:${locker.lib.dir}"/>
        <available file="${locker.dir}/${exec.dir.name}/${scalac.exec.name}"/>
      </and>
    </condition>
    <!-- Finding out what system architecture is being used -->
    <condition property="os.win">
      <os family="windows"/>
    </condition>
    <if><isset property="os.win"/>
      <then>
        <exec executable="cygpath"
              vmlauncher="no"
              errorproperty="cygpath.err"
              outputproperty="cygpath.out">
          <arg value="--windir"/>
        </exec>
        <condition property="os.cygwin">
          <equals arg1="${cygpath.err}" arg2=""/>
        </condition>
      </then>
    </if>
    <condition property="os.unix">
      <or>
        <os family="unix"/>
        <os family="mac"/>
        <isset property="os.cygwin"/>
      </or>
    </condition>
    <if><isset property="os.cygwin"/>
      <then><echo>Sabbus detected a Cygwin environnement</echo></then>
      <elseif><isset property="os.win"/>
        <then><echo>Sabbus detected a Windows environnement</echo></then>
      </elseif>
      <elseif><isset property="os.unix"/>
        <then><echo>Sabbus detected a UNIX environnement</echo></then>
      </elseif>
      <else>
        <fail>System environment could not be determined</fail>
      </else>
    </if>
    <!-- Defining version number -->
    <tstamp prefix="start"/>
    <property name="version.number" value="${start.DSTAMP}-${start.TSTAMP}"/>
    <property name="dist.current.dir"
              value="${dist.dir}/${dist.name}-${version.number}"/>
  </target>
  
  <target name="init.locker" depends="init, build.locker">
    <path id="locker.classpath">
      <pathelement location="${locker.dir}/${lib.dir.name}"/>
      <pathelement location="${locker.dir}/${comp.dir.name}"/>
      <path refid="common.classpath"/>
    </path>
    <taskdef name="locker"
             classname="scala.tools.ant.Scalac"
             classpathref="locker.classpath"/>
    <taskdef name="lockertool"
             classname="scala.tools.ant.ScalaTool"
             classpathref="locker.classpath"/>
  </target>
  
  <target name="init.quick" depends="init, build">
    <path id="quick.classpath">
      <pathelement location="${quick.dir}/${lib.dir.name}"/>
      <pathelement location="${quick.dir}/${comp.dir.name}"/>
      <path refid="common.classpath"/>
    </path>
    <taskdef name="quick"
             classname="scala.tools.ant.Scalac"
             classpathref="quick.classpath"/>
    <taskdef name="quicktool"
             classname="scala.tools.ant.ScalaTool"
             classpathref="quick.classpath"/>
    <taskdef name="quicksbaz"
             classname="scala.tools.ant.ScalaBazaar"
             classpathref="quick.classpath"/>
  </target>

<!-- ===========================================================================
BUILD SUPPORT MACROS
============================================================================ -->
  
  <macrodef name="build.support">
    <attribute name="build.dir"/>
    <sequential>
      <copy todir="@{build.dir}/${lib.dir.name}">
        <fileset dir="${src.dir}/${lib.dir.name}">
          <include name="**/*.tmpl"/>
          <include name="**/*.xml"/>
        </fileset>
      </copy>
      <copy todir="@{build.dir}/${comp.dir.name}">
        <fileset dir="${src.dir}/${comp.dir.name}">
          <include name="**/*.tmpl"/>
          <include name="**/*.xml"/>
        </fileset>
      </copy>
    </sequential>
  </macrodef>

<!-- ===========================================================================
BUILD LOCAL REFERENCE (LOCKER) LAYER
============================================================================ -->
  
  <target name="build.locker" depends="init" unless="locker.avail">
    <property name="built.locker" value="yes"/>
    <!-- Build library -->
    <mkdir dir="${locker.lib.dir}"/>
    <pico srcdir="${src.dir}/${lib.dir.name}"
          destdir="${locker.lib.dir}"
          scalahack="yes">
      <classpath>
        <pathelement location="${locker.lib.dir}"/>
      </classpath>
      <include name="**/*.java"/>
    </pico>
    <starr srcdir="${src.dir}/${lib.dir.name}"
           destdir="${locker.lib.dir}"
           usepredefs="no">
      <classpath>
        <pathelement location="${locker.lib.dir}"/>
      </classpath>
      <include name="scala/Predef.scala"/>
      <include name="scala/runtime/ScalaRunTime.scala"/>
    </starr>
    <starr srcdir="${src.dir}/${lib.dir.name}"
           destdir="${locker.lib.dir}">
      <classpath>
        <pathelement location="${locker.lib.dir}"/>
      </classpath>
      <include name="**/*.scala"/>
      <exclude name="scala/Predef.scala"/>
      <exclude name="scala/runtime/ScalaRunTime.scala"/>
      <excludesfile name="${nsc.excludes}" if="excludes.avail"/>
    </starr>
    <!-- Build compiler -->
    <mkdir dir="${locker.comp.dir}"/>
    <pico srcdir="${src.dir}/${comp.dir.name}"
          destdir="${locker.comp.dir}"
          scalahack="yes">
      <classpath>
        <pathelement location="${locker.lib.dir}"/>
        <pathelement location="${locker.comp.dir}"/>
      </classpath>
      <include name="**/*.java"/>
    </pico>
    <starr srcdir="${src.dir}/${comp.dir.name}"
           destdir="${locker.comp.dir}">
      <classpath>
        <pathelement location="${locker.lib.dir}"/>
        <pathelement location="${locker.comp.dir}"/>
        <path refid="starr.classpath"/>
        <pathelement location="${ant.jar}"/>
      </classpath>
      <include name="**/*.scala"/>
      <excludesfile name="${nsc.excludes}" if="excludes.avail"/>
    </starr>
    <!-- Copy support files to build folder -->
    <build.support build.dir="${locker.dir}"/>
    <!-- Link to libraries -->
    <if><isset property="os.unix"/>
      <then>
        <symlink link="${locker.dir}/${fjbg.name}"
                 resource="${fjbg.jar}"
                 overwrite="yes"
                 failonerror="no"/>
        <symlink link="${locker.dir}/${msil.name}"
                 resource="${msil.jar}"
                 overwrite="yes"
                 failonerror="no"/>
      </then>
      <else>
        <copy file="${fjbg.jar}" tofile="${locker.dir}/${fjbg.name}"/>
        <copy file="${msil.jar}" tofile="${locker.dir}/${msil.name}"/>
      </else>
    </if>
    <!-- Build executable files -->
    <mkdir dir="${locker.dir}/${exec.dir.name}"/>
    <starrtool file="${locker.dir}/${exec.dir.name}/${scalac.exec.name}"
                genericFile="${locker.dir}/${exec.dir.name}/${scala.exec.name}"
                name="Scala compiler"
                class="scala.tools.nsc.Main"
                version="${version.number}"
                copyright="${copyright}"
                classpath="#PREFIX#/${lib.dir.name}:#PREFIX#/${comp.dir.name}:#PREFIX#/${fjbg.name}:#PREFIX#/${msil.name}"
                properties="scala.boot.class.path=#CLASSPATH#"
                javaFlags="-Xmx256M -Xms16M"/>
    <chmod file="${locker.dir}/${exec.dir.name}/${scalac.exec.name}"
           perm="ugo+rx"/>
    <chmod file="${locker.dir}/${exec.dir.name}/${scala.exec.name}"
           perm="ugo+rx"/>
  </target>

<!-- ===========================================================================
BUILD QUICK-TEST LAYER
============================================================================ -->
  
  <target name="build" depends="init.locker">
    <!-- Build library -->
    <mkdir dir="${quick.lib.dir}"/>
    <pico srcdir="${src.dir}/${lib.dir.name}"
          destdir="${quick.lib.dir}"
          scalahack="yes">
      <classpath>
        <pathelement location="${quick.lib.dir}"/>
      </classpath>
      <include name="**/*.java"/>
    </pico>
    <locker srcdir="${src.dir}/${lib.dir.name}"
           destdir="${quick.lib.dir}"
           usepredefs="no"
           addparams="${nsc.params}"
           scalacdebugging="yes">
      <classpath>
        <pathelement location="${quick.lib.dir}"/>
      </classpath>
      <include name="scala/Predef.scala"/>
      <include name="scala/runtime/ScalaRunTime.scala"/>
    </locker>
    <locker srcdir="${src.dir}/${lib.dir.name}"
           destdir="${quick.lib.dir}"
           addparams="${nsc.params}"
           scalacdebugging="yes">
      <classpath>
        <pathelement location="${quick.lib.dir}"/>
      </classpath>
      <include name="**/*.scala"/>
      <exclude name="scala/Predef.scala"/>
      <exclude name="scala/runtime/ScalaRunTime.scala"/>
      <excludesfile name="${nsc.excludes}" if="excludes.avail"/>
    </locker>
    <!-- Build compiler -->
    <mkdir dir="${quick.comp.dir}"/>
    <pico srcdir="${src.dir}/${comp.dir.name}"
          destdir="${quick.comp.dir}"
          scalahack="yes">
      <classpath>
        <pathelement location="${quick.lib.dir}"/>
        <pathelement location="${quick.comp.dir}"/>
      </classpath>
      <include name="**/*.java"/>
    </pico>
    <locker srcdir="${src.dir}/${comp.dir.name}"
           destdir="${quick.comp.dir}"
           addparams="${nsc.params}"
           scalacdebugging="yes">
      <classpath>
        <pathelement location="${quick.lib.dir}"/>
        <pathelement location="${quick.comp.dir}"/>
        <path refid="locker.classpath"/>
        <pathelement location="${ant.jar}"/>
      </classpath>
      <include name="**/*.scala"/>
      <excludesfile name="${nsc.excludes}" if="excludes.avail"/>
    </locker>
    <!-- Copy templates to build -->
    <build.support build.dir="${quick.dir}"/>
    <!-- Link to libraries -->
    <if><isset property="os.unix"/>
      <then>
        <symlink link="${quick.dir}/${fjbg.name}"
                 resource="${fjbg.jar}"
                 overwrite="yes"
                 failonerror="no"/>
        <symlink link="${quick.dir}/${msil.name}"
                 resource="${msil.jar}"
                 overwrite="yes"
                 failonerror="no"/>
      </then>
      <else>
        <copy file="${fjbg.jar}" tofile="${quick.dir}/${fjbg.name}"/>
        <copy file="${msil.jar}" tofile="${quick.dir}/${msil.name}"/>
      </else>
    </if>
    <!-- Build executable files -->
    <mkdir dir="${quick.dir}/${exec.dir.name}"/>
    <lockertool file="${quick.dir}/${exec.dir.name}/${scalac.exec.name}"
                genericFile="${quick.dir}/${exec.dir.name}/${scala.exec.name}"
                name="Scala compiler"
                class="scala.tools.nsc.Main"
                version="${version.number}"
                copyright="${copyright}"
                classpath="#PREFIX#/${lib.dir.name}:#PREFIX#/${comp.dir.name}:#PREFIX#/${fjbg.name}:#PREFIX#/${msil.name}"
                properties="scala.boot.class.path=#CLASSPATH#"
                javaFlags="-Xmx256M -Xms16M"/>
    <chmod file="${quick.dir}/${exec.dir.name}/${scalac.exec.name}"
           perm="ugo+rx"/>
    <chmod file="${quick.dir}/${exec.dir.name}/${scala.exec.name}"
           perm="ugo+rx"/>
  </target>

<!-- ===========================================================================
TEST
============================================================================ -->
  
  <target name="test" depends="init.quick">
    <!-- Build the bootstrap layer -->
    <!-- Build library -->
    <mkdir dir="${strap.lib.dir}"/>
    <pico srcdir="${src.dir}/${lib.dir.name}"
          destdir="${strap.lib.dir}"
          scalahack="yes">
      <classpath>
        <pathelement location="${strap.lib.dir}"/>
      </classpath>
      <include name="**/*.java"/>
    </pico>
    <quick srcdir="${src.dir}/${lib.dir.name}"
           destdir="${strap.lib.dir}"
           usepredefs="no"
           addparams="${nsc.params}"
           scalacdebugging="yes">
      <classpath>
        <pathelement location="${strap.lib.dir}"/>
      </classpath>
      <include name="scala/Predef.scala"/>
      <include name="scala/runtime/ScalaRunTime.scala"/>
    </quick>
    <quick srcdir="${src.dir}/${lib.dir.name}"
           destdir="${strap.lib.dir}"
           addparams="${nsc.params}"
           scalacdebugging="yes">
      <classpath>
        <pathelement location="${strap.lib.dir}"/>
      </classpath>
      <include name="**/*.scala"/>
      <exclude name="scala/Predef.scala"/>
      <exclude name="scala/runtime/ScalaRunTime.scala"/>
      <excludesfile name="${nsc.excludes}" if="excludes.avail"/>
    </quick>
    <!-- Build compiler -->
    <mkdir dir="${strap.comp.dir}"/>
    <pico srcdir="${src.dir}/${comp.dir.name}"
          destdir="${strap.comp.dir}"
          scalahack="yes">
      <classpath>
        <pathelement location="${strap.lib.dir}"/>
        <pathelement location="${strap.comp.dir}"/>
      </classpath>
      <include name="**/*.java"/>
    </pico>
    <quick srcdir="${src.dir}/${comp.dir.name}"
           destdir="${strap.comp.dir}"
           addparams="${nsc.params}"
           scalacdebugging="yes">
      <classpath>
        <pathelement location="${strap.lib.dir}"/>
        <pathelement location="${strap.comp.dir}"/>
        <path refid="quick.classpath"/>
        <pathelement location="${ant.jar}"/>
      </classpath>
      <include name="**/*.scala"/>
      <excludesfile name="${nsc.excludes}" if="excludes.avail"/>
    </quick>
    <!-- Copy templates to build -->
    <build.support build.dir="${strap.dir}"/>
    <!-- Link to libraries -->
    <if><isset property="os.unix"/>
      <then>
        <symlink link="${strap.dir}/${fjbg.name}"
                 resource="${fjbg.jar}"
                 overwrite="yes"
                 failonerror="no"/>
        <symlink link="${strap.dir}/${msil.name}"
                 resource="${msil.jar}"
                 overwrite="yes"
                 failonerror="no"/>
      </then>
      <else>
        <copy file="${fjbg.jar}" tofile="${strap.dir}/${fjbg.name}"/>
        <copy file="${msil.jar}" tofile="${strap.dir}/${msil.name}"/>
      </else>
    </if>
    <!-- Build executable files -->
    <mkdir dir="${strap.dir}/${exec.dir.name}"/>
    <quicktool file="${strap.dir}/${exec.dir.name}/${scalac.exec.name}"
               genericFile="${strap.dir}/${exec.dir.name}/${scala.exec.name}"
               name="Scala compiler"
               class="scala.tools.nsc.Main"
               version="${version.number}"
               copyright="${copyright}"
               classpath="#PREFIX#/${lib.dir.name}:#PREFIX#/${comp.dir.name}:#PREFIX#/${fjbg.name}:#PREFIX#/${msil.name}"
               properties="scala.boot.class.path=#CLASSPATH#"
               javaFlags="-Xmx256M -Xms16M"/>
    <chmod file="${strap.dir}/${exec.dir.name}/${scalac.exec.name}"
           perm="ugo+rx"/>
    <chmod file="${strap.dir}/${exec.dir.name}/${scala.exec.name}"
           perm="ugo+rx"/>
    <!-- Compares quick and test level -->
    <checksum totalproperty="quick.md5">
      <fileset dir="${quick.dir}">
        <include name="${lib.dir.name}/**"/>
        <include name="${comp.dir.name}/**"/>
      </fileset>
    </checksum>
    <delete quiet="yes" failonerror="no">
      <fileset dir="${quick.dir}"><include name="**/*.MD5"/></fileset>
    </delete>
    <checksum totalproperty="strap.md5">
      <fileset dir="${strap.dir}">
        <include name="${lib.dir.name}/**"/>
        <include name="${comp.dir.name}/**"/>
      </fileset>
    </checksum>
    <delete quiet="yes" failonerror="no">
      <fileset dir="${strap.dir}"><include name="**/*.MD5"/></fileset>
    </delete>
    <fail message="Build is not stable">
      <condition><not>
        <equals arg1="${quick.md5}" arg2="${strap.md5}"/>
      </not></condition>
    </fail>
    <echo>Build is stable</echo>
  </target>

<!-- ===========================================================================
DOCUMENT
============================================================================ -->
  
  <target name="docs">
    <echo>Docs is not available yet.</echo>
  </target>

<!-- ===========================================================================
GENERATES A DISTRIBUTION
============================================================================ -->

  <target name="dist" depends="test">
    <mkdir dir="${dist.current.dir}"/>
    <mkdir dir="${dist.current.dir}/lib"/>
    <jar destfile="${dist.current.dir}/lib/${comp.jar.name}"
         basedir="${strap.comp.dir}">
      <manifest>
        <attribute name="Signature-Version" value="${version.number}"/>
<!-- For a sbaz package, the Main-Class should not be included
        <attribute name="Main-Class" value="scala.tools.nsc.Main"/>
        <attribute name="Class-Path" value="${lib.jar.name}"/>
-->
      </manifest>
    </jar>
    <jar destfile="${dist.current.dir}/lib/${lib.jar.name}"
         basedir="${strap.lib.dir}">
      <manifest>
        <attribute name="Signature-Version" value="${version.number}"/>
      </manifest>
    </jar>
    <copy file="${fjbg.jar}" todir="${dist.current.dir}/lib"/>
    <copy file="${msil.jar}" todir="${dist.current.dir}/lib"/>
    <mkdir dir="${dist.current.dir}/bin"/>
    <!-- Build executable files -->
    <mkdir dir="${dist.current.dir}/bin"/>
    <quicktool file="${dist.current.dir}/bin/${scalac.exec.name}"
                genericFile="${dist.current.dir}/bin/${scala.exec.name}"
                name="Scala compiler"
                class="scala.tools.nsc.Main"
                version="${version.number}"
                copyright="${copyright}"
                classpath=""
                properties="scala.boot.class.path=#CLASSPATH#"
                javaFlags="-Xmx256M -Xms16M"/>
    <chmod file="${dist.current.dir}/bin/${scalac.exec.name}"
           perm="ugo+rx"/>
    <chmod file="${dist.current.dir}/bin/${scala.exec.name}"
           perm="ugo+rx"/>
    <if><isset property="os.unix"/>
      <then>
        <symlink link="${dist.latest.dir}"
                 resource="${dist.current.dir}"
                 overwrite="yes"
                 failonerror="no"/>
      </then>
    </if> 

    <quicksbaz
       file="${dist.dir}/scalac2-${version.number}.sbp"
       adfile="${dist.dir}/scalac2-${version.number}.advert"
       name="scalac2"
       version="${version.number}"
       desc="The Scala compiler.  This is used to compile Scala programs
into Java .class files.">
      <libset dir="${dist.current.dir}/lib" includes="scala2-compiler.jar"/>
      <binset dir="${dist.current.dir}/bin" includes="scalac2*"/>
      <manset dir="${docs.dir}/man" includes="scalac2.1"/>
    </quicksbaz>

    <quicksbaz
       file="${dist.dir}/scala2-${version.number}.sbp"
       adfile="${dist.dir}/scala2-${version.number}.advert"
       name="scala2"
       version="${version.number}"
       desc="The Scala command runner.  It is a wrapper around the Java VM that,
by default, sets up a large CLASSPATH including the Scala library
as well as all jars installed in the lib directory of the sbaz-
managed directory.">
      <binset dir="${dist.current.dir}/bin" includes="scala2*"/>
      <manset dir="${docs.dir}/man" includes="scala2.1"/>
    </quicksbaz>

    <quicksbaz
       file="${dist.dir}/scala2-library-${version.number}.sbp"
       adfile="${dist.dir}/scala2-library-${version.number}.advert"
       name="scala2-library"
       version="${version.number}"
       desc="The base Scala library, required for running all Scala programs.">
      <libset dir="${dist.current.dir}/lib" includes="scala2-library.jar"/>
    </quicksbaz>
  </target>

<!-- ===========================================================================
CLEAN
============================================================================ -->
  
  <macrodef name="remove">
    <attribute name="dir"/>
    <sequential>
      <delete dir="@{dir}"
              includeemptydirs="yes"
              quiet="yes"
              failonerror="no"/>
    </sequential>
  </macrodef>
  
  <target name="clean">
    <remove dir="${quick.dir}"/>
    <remove dir="${strap.dir}"/>
  </target>
  
  <target name="clean.all">
    <remove dir="${locker.dir}"/>
    <remove dir="${quick.dir}"/>
    <remove dir="${strap.dir}"/>
    <remove dir="${dist.unix.dir}"/>
    <remove dir="${dist.win.dir}"/>
    <remove dir="${dist.unix.latest.dir}"/>
  </target>

</project>