<?xml version="1.0" encoding="utf-8"?>
<!-- ===================================================================

   Build file for Xalan-J 2.x - for use with the Jakarta Ant java build tool
   
Setup instructions: 
   Before running an Ant build, you must
   
     - set the JAVA_HOME environment variable to the JDK root directory
     - To build 'servlet' sample: Include Servlet SDK in your classpath
     - To build docs/javadocs/xsltc: use JDK 1.2.x or higher
   
Build Instructions:   
  To build, run
    build.bat (win32) or build.sh (unix) [antoptions] [targets]
  in the directory where this file is located; you should also be 
  able to use an installation of Ant v1.4.1 or later.
   
  build -projecthelp  will show a list of supported targets.
   
  Developers: include a description="" attribute in all user-callable targets.
        
  If you build a target that depends on other targets, those other 
  targets are *usually* created in the correct order; however a 
  few of the larger targets like dist do not list all dependencies.

Other Important Notes:
- 'dist' produces a .tar file that works with GNU compatible tar 
  programs, because that's what Ant does when it finds a path that's 
  longer than 100 characters (like in our docs).  Sorry!
  
- External build maintainers: look for GUMP: comments; developers 
  please use great caution when changing these lines!

- Unusual build items: the docs and xsltc.compile targets leave 
  cruft in the source areas; various clean targets get most of this.
  
Authors:
  Shane Curcuru <shane_curcuru@lotus.com>
  Don Leslie <donald_leslie@lotus.com>

Copyright:
  Copyright (c) 1999-2003 The Apache Software Foundation.
   $Id$
==================================================================== -->

<project name="Xalan" default="jar" basedir=".">
  <!-- =================================================================== -->
  <!-- Defines paths/names of prerequisite jar files we compile against    -->
  <!-- =================================================================== -->
  <!-- We keep checked-in known-good .jars here -->
  <property name="bin.dir" value="./bin"/>

  <!-- GUMP: Allows external build systems to replace .jars Xalan 
       is dependent on as needed.  Most have separate name and 
       location properties to make it simpler to reset these values; 
       please provide feedback if this is useful. 
  -->
  <property name="xmlapis.jar.name" value="xml-apis.jar"/>
  <property name="xmlapis.jar" value="${bin.dir}/${xmlapis.jar.name}"/>
  <property name="parser.jar.name" value="xercesImpl.jar"/>
  <property name="parser.jar" value="${bin.dir}/${parser.jar.name}"/>
  <property name="bsf.jar.name" value="bsf.jar"/>
  <property name="bsf.jar" value="${bin.dir}/${bsf.jar.name}"/>
  <property name="stylebook.jar.name" value="stylebook-1.0-b3_xalan-2.jar"/>
  <property name="stylebook.jar" value="${bin.dir}/${stylebook.jar.name}"/>
  <property name="doclet.jar.name" value="xalan2jdoc.jar"/>
  <property name="doclet.jar" value="${bin.dir}/${doclet.jar.name}"/>

  <!-- GUMP: Currently 18-Apr-01 used only for xsltc.compile -->
  <property name="bcel.jar.name" value="BCEL.jar"/>
  <property name="bcel.jar" value="${bin.dir}/${bcel.jar.name}"/>
  <property name="java_cup.jar.name" value="java_cup.jar"/>
  <property name="java_cup.jar" value="${bin.dir}/${java_cup.jar.name}"/>
  <property name="jlex.jar.name" value="JLex.jar"/>
  <property name="jlex.jar" value="${bin.dir}/${jlex.jar.name}"/>
  <property name="runtime.jar.name" value="runtime.jar"/>
  <property name="runtime.jar" value="${bin.dir}/${runtime.jar.name}"/>
  <property name="regexp.jar.name" value="regexp.jar"/>
  <property name="regexp.jar" value="${bin.dir}/${regexp.jar.name}"/>

  <!-- Defines general variables used by the other targets; name controls output xalan.jar  -->
  <property name="version.VERSION" value="2"/>
  <property name="version.RELEASE" value="5"/>
  <property name="version.DEVELOPER" value="D"/><!-- Set this to 'D' if a developer release; blank "" if maintenance release -->
  <property name="version.MINOR" value="1"/><!-- EITHER the developer release number, or a maintenance release number -->
  <property name="version" value="${version.VERSION}_${version.RELEASE}_${version.DEVELOPER}${version.MINOR}"/><!-- GUMP: version # of dist file -->
  <property name="impl.version" value="${version.VERSION}.${version.RELEASE}.${version.DEVELOPER}${version.MINOR}"/><!-- Used in jar task for filtering MANIFEST.MF file -->
  <property name="name" value="xalan"/><!-- GUMP: base name of jar target's file -->
  <property name="year" value="2003"/>
  <property name="build.debug" value="on"/>

  <!-- Relative locations of source directories -->
  <property name="manifest.mf" value="./src/MANIFEST.MF"/>
  <property name="manifest.xsltc.mf" value="./src/manifest.xsltc"/>
  <property name="XSLTInfo.props" value="./src/org/apache/xalan/res/XSLTInfo.properties"/>  
  <property name="src.dir" value="./src"/>
  <property name="apachexml.reldir" value="org/apache/xml"/>
  <property name="xpath.reldir" value="org/apache/xpath"/>
  <property name="xalan.reldir" value="org/apache/xalan"/>
  <property name="domxpath.reldir" value="org/w3c/dom/xpath"/>
  <property name="xsltc.reldir" value="${xalan.reldir}/xsltc"/>
  <property name="generated.xpathparser" value="${src.dir}/${xsltc.reldir}/compiler/XPathParser.java"/>
  <property name="generated.xpathlexer" value="${src.dir}/${xsltc.reldir}/compiler/XPathLexer.java"/>
  <property name="generated.xpathsym" value="${src.dir}/${xsltc.reldir}/compiler/sym.java"/>
  
  <!-- Build and distribution output areas -->
  <property name="build.dir" value="./build"/><!-- GUMP: root of all normal builds output -->
  <property name="build.xalan.jar" value="${build.dir}/${name}.jar"/><!-- GUMP: actual path/name of jar target output -->
  <property name="build.xsltc.jar" value="${build.dir}/xsltc.jar"/>
  <property name="build.classes" value="${build.dir}/classes"/>
  <property name="build.docs" value="${build.dir}/docs"/>
  <property name="build.samples" value="${build.dir}/samples"/>
  <property name="build.servlet" value="${build.samples}/servlet"/>
  <property name="build.apidocs" value="${build.docs}/apidocs"/>
  <property name="dist.file" value="${name}-j_${version}"/><!-- GUMP: actual path/name of dist target .tar.gz/.zip-->
  <property name="dist.dir" value="${build.dir}/${dist.file}"/>
  
   <!-- xml-commons sources (for Javadoc) -->                                                                        
   <property name="xml-commons-srcs.tar.gz" value="${src.dir}/xml-commons-src.tar.gz"/>                                                                         
   <property name="xml-commons-srcs.tar" value="${build.dir}/xml-commons-src.tar"/>
 
  <!-- Documentation and samples information  -->
  <property name="Name-in-docs" value="Xalan-Java"/>
  <property name="version.file" value="${xalan.reldir}/processor/XSLProcessorVersion.java"/>
  <property name="samples.dir" value="./samples"/>
  <property name="build.samples.jar" value="${build.dir}/xalansamples.jar"/>
  <property name="build.servlet.war" value="${build.dir}/xalanservlet.war"/>
  <property name="xdocs.dir" value="./xdocs"/>
  <property name="xdocs.book" value="${xdocs.dir}/sources/xalan-jlocal.xml"/>
  <property name="xdocs.style" value="${xdocs.dir}/style"/>
  <property name="xalanonly-styledocs"
            value="dtd/xsl-html40s.dtd,dtd/spec.dtd,stylesheets/patterns.xsl,stylesheets/notice.xsl,stylesheets/spec.xsl,stylesheets/done.xsl,loaderdesign.xml,stylesheets/design2project.xsl,stylesheets/designdoc2html.xsl,stylesheets/xml2fo.xsl"/>
  <property name="xalan.cmdline.class" value="org.apache.xalan.xslt.Process"/>
  <property name="doc.generator" value="org.apache.stylebook.StyleBook"/>
  <property name="doc.generator.styletargz" value="${xdocs.dir}/xml-site-style.tar.gz"/>
  <property name="doc.generator.styletar" value="${xdocs.dir}/xml-site-style.tar"/>
  <property name="site.root" value="./xml-site"/>
  <property name="site.dir" value="${site.root}/target/xalan-j"/>
  <property name="site.book" value="${xdocs.dir}/sources/xalan-jsite.xml"/>
  <property name="xdocs.DONE.file" value="${xdocs.dir}/sources/xalan/DONE"/>
  <property name="xdocs.XSLTCDONE.file" value="XSLTCDONE"/>
  <property name="xdocs.XSLTCDONE.location" value="${xdocs.dir}/sources/xalan/${xdocs.XSLTCDONE.file}"/>    
  <path id="docs.class.path">
    <pathelement location="${xmlapis.jar}" />
    <pathelement location="${parser.jar}" />
    <pathelement location="${bsf.jar}" />
    <pathelement location="${bcel.jar}" />
    <pathelement location="${runtime.jar}" />
    <pathelement location="${stylebook.jar}" />
    <pathelement location="${doclet.jar}" />
    <pathelement location="${build.xalan.jar}" />
    <pathelement path="${java.class.path}" />
  </path>
  <path id="samples.class.path">
    <pathelement location="${xmlapis.jar}" />
    <pathelement location="${parser.jar}" />
    <pathelement location="${build.xalan.jar}" />
    <pathelement path="${java.class.path}" />
  </path>
  <path id="compile.class.path">
    <!-- Ensure the selected parser.jar file is used to compile against -->
    <pathelement location="${build.classes}" />
    <pathelement location="${xmlapis.jar}" />
    <pathelement location="${parser.jar}" />
    <pathelement path="${java.class.path}" />
  </path>
  <path id="xslt.boot.class.path">
    <!-- Put this version of xalan in front of the jdk's for JDK 1.4+ -->
    <!-- Set build.boot.class.path to a JDK 1.1.x classes.zip file to check
         compatibility with 1.1.x.  If you omit this property, compatability
         with 1.1.x will not be checked even though javac specifies a target of 1.1 -->
    <pathelement location="${build.classes}" />
    <pathelement path="${build.boot.class.path}" />
    <pathelement path="${sun.boot.class.path}" />
  </path>
  <path id="compile.source.path">
    <dirset dir="${src.dir}" includes="/org/apache/**" />
  </path>


  <!-- =================================================================== -->
  <!-- Creates output build directories and doc prerequistes               -->
  <!-- =================================================================== -->
  <target name="prepare">
    <echo message="Project:${Name-in-docs} version:${version} build.xml $Revision$"/>
    <mkdir dir="${build.dir}"/>
    <mkdir dir="${build.classes}"/>
    <!-- Note that all testing-related targets *must* depend on 
         this target, either directly or indirectly, to get 
         the tests-available property set for them.
    -->
    <available file="${test.relpath}" property="tests-available" />
    <available property="xerces.present" 
      classname="org.apache.xerces.parsers.SAXParser"/>
  </target>

  <!-- Must depend on jar since we use Xalan to process xml files -->
  <target name="prepare.docs" depends="jar">
    <mkdir dir="${build.docs}"/> 
    <mkdir dir="${build.apidocs}"/>

    <gunzip src="${doc.generator.styletargz}"/>
    <untar src="${doc.generator.styletar}" dest="${xdocs.dir}"/>
    <delete file="${doc.generator.styletar}"/>

    <!-- We use a Notes agent to periodically extract Xalan-Java 2 commits from our team database into commits.xml.  The following operation 
    transforms commits.xml (just including source code commits) and puts the result in xdocs/sources/xalan for inclusion in the 
    readme.xml -->      
    <echo message="Transform commits.xml and put the result in ${xdocs.dir}"/>
    <java fork="yes" classname="${xalan.cmdline.class}" >
      <classpath refid="docs.class.path" />
      <arg line="-in commits.xml -xsl ${xdocs.style}/stylesheets/done.xsl -out ${xdocs.DONE.file} -param xsltcdone ${xdocs.XSLTCDONE.file}"/>
    </java>
    <echo message="Generate Xalan-J 2.x design document"/>
    <java fork="yes" classname="${doc.generator}" >
      <classpath refid="docs.class.path" />
      <arg line="loaderConfig=sbk:/style/loaderdesign.xml targetDirectory=./build/docs/design/
                 ./xdocs/sources/xalandesign.xml ./xdocs/style"/>
    </java>
  </target>

  <!-- =================================================================== -->
  <!-- Compile entire source tree                                          -->
  <!-- =================================================================== -->
  <target name="compile" depends="prepare"
    description="Compile Xalan-J 2.x (skips XSLTC)" >
    <echo message="compile entire source tree and copy .properties and .res files to build tree."/>
    <javac srcdir="${src.dir}" 
           destdir="${build.classes}"
           debug="${build.debug}"
           target="1.1" >
      <include name="${apachexml.reldir}/**/*.java" />
      <!-- But exclude unused synthetic* files; should be obsoleted from CVS -->
      <exclude name="${apachexml.reldir}/utils/synthetic/**/*.java" />
      <include name="${xpath.reldir}/**/*.java" />
      <include name="${xalan.reldir}/**/*.java" />
      <exclude name="${xsltc.reldir}/**/*.java" />
      <include name="${domxpath.reldir}/**/*.java" />
      <exclude name="**/CoroutineSAXFilterTest.java" 
        unless="xerces.present"	 />
      <exclude name="**/CoroutineSAXParser_Xerces.java" 
        unless="xerces.present"	 />
      <exclude name="**/IncrementalSAXSource_Xerces.java" 
        unless="xerces.present"	 />
      <classpath refid="compile.class.path" />
      <bootclasspath refid="xslt.boot.class.path" />
      <sourcepath refid="compile.source.path" />
    </javac>
    <!-- Copy needed properties, resource, etc. files to be put into .jar file -->
    <copy todir="${build.classes}">
      <fileset dir="${src.dir}" includes="**/*.properties,**/*.res,META-INF/services/*" excludes="**/XSLTInfo.properties"/>
    </copy>  
    <filter token="impl.version" value="${impl.version}"/>
    <copy todir="${build.classes}/org/apache/xalan/res" file="${XSLTInfo.props}" filtering="true"/>
  </target>

  <!-- =================================================================== -->
  <!-- Compile just the XSLTC compiler portion (to be integrated soon!) -->
  <!-- =================================================================== -->
  <path id="xsltc.class.path">
    <pathelement location="${xmlapis.jar}" />
    <pathelement location="${bcel.jar}" />
    <pathelement location="${jlex.jar}" />
    <pathelement location="${java_cup.jar}" />
    <pathelement location="${runtime.jar}" />
    <!-- build.classes needed for 
         org.apache.xalan.xsltc.util.JavaCupRedirect -->
    <pathelement location="${build.classes}" />
    <pathelement path="${java.class.path}" />
  </path>

  <!-- Attempt to determine dependency info for generated sources -->
  <target name="xsltc.prepare" depends="prepare" >
    <!-- The first step compiles the utils directory, which includes 
         a special wrapper for the xsltc.codegen / java_cup step next. -->
    <echo message="Compiling XSLTC utilities"/>
    <javac srcdir="${src.dir}" 
           destdir="${build.classes}"
           includes="${xsltc.reldir}/util/**/*.java"
           debug="${build.debug}">
      <classpath refid="xsltc.class.path" />
      <bootclasspath refid="xslt.boot.class.path" />
    </javac>
    <!-- These tricky uptodate statements hopefully determine if we 
         actually need to generate the java_cup and jlex files 
         in the two sub-targets below
    -->
    <!-- NOTE: The two uptodate tasks below do not yet work! 28-Nov-01 -sc -->
    <uptodate property="xsltc.java_cup.needed"  >
      <srcfiles dir= "${src.dir}/${xsltc.reldir}/compiler" includes="xpath.cup"/>
      <mapper type="merge" to="${generated.xpathparser}"/>
    </uptodate>
    <uptodate property="xsltc.jlex.needed"  >
      <srcfiles dir= "${src.dir}/${xsltc.reldir}/compiler" includes="xpath.lex"/>
      <mapper type="merge" to="${generated.xpathlexer}"/>
    </uptodate>
  </target>

  <!-- Generate code sources for xsltc if needed -->
  <target name="xsltc.java_cup" depends="xsltc.prepare" > <!-- if="xsltc.java_cup.needed" -->
    <!-- The second step generates sym.java and XPathParser.java. -->
    <echo message="java_cup preparsing"/>
    <java fork="yes" failonerror="true" 
       classname="org.apache.xalan.xsltc.util.JavaCupRedirect" >
      <classpath refid="xsltc.class.path" />
      <!-- We're using JavaCupRedirect to call the java_cup application -->
      <arg line="-parser XPathParser -expect 0 
         -stdin ${src.dir}/${xsltc.reldir}/compiler/xpath.cup"/>
    </java>
    <echo message="java_cup move output files"/>
    <move file="XPathParser.java" tofile="${generated.xpathparser}"/>
    <move file="sym.java" tofile="${generated.xpathsym}"/>

  </target>
  <target name="xsltc.jlex" depends="xsltc.java_cup" ><!--if="xsltc.jlex.needed" -->
    <!-- The third step generates XPathLexer.java. The lexiographical analyser
    has to be generated after sym.java, so order is important. -->
    <echo message="JLex preparsing"/>
    <java fork="yes" failonerror="true" classname="JLex.Main" >
      <classpath refid="xsltc.class.path" />
      <arg line="-static ${src.dir}/${xsltc.reldir}/compiler/xpath.lex"/>
    </java>
    <echo message="JLex move output file"/>
    <move file="${src.dir}/${xsltc.reldir}/compiler/xpath.lex.java" tofile="${generated.xpathlexer}"/>
  </target>

  <!-- The xsltc.compile target should be rewritten to properly 
       do dependencies on the generated sources: right now, it 
       will always regenerate the sources, even if it's not needed
       (which forces all later steps to re-run as well) -->
  <target name="xsltc.compile" depends="xsltc.java_cup,xsltc.jlex"
    description="Compile just the XSLTC classes" >
    <echo message="Compiling remaining XSLTC classes"/>
    <javac srcdir="${src.dir}" 
           destdir="${build.classes}"
           includes="${xsltc.reldir}/**/*.java"
           debug="${build.debug}">
      <classpath refid="xsltc.class.path" />
      <bootclasspath refid="xslt.boot.class.path" />
    </javac>
  </target>

  <target name="xsltc.fcompile" 
    description="Compile just the XSLTC classes w/o JLex, JCup recompilation" >
    <echo message="Compiling remaining XSLTC classes"/>
    <javac srcdir="${src.dir}" 
           destdir="${build.classes}"
           includes="${xsltc.reldir}/**/*.java"
           debug="${build.debug}">
      <classpath refid="xsltc.class.path" />
      <bootclasspath refid="xslt.boot.class.path" />
    </javac>
  </target>

  <target name="xsltc.unbundledjar" depends="xsltc.compile"
    description="Jar just the xsltc.jar file" >
    <!-- Copy over the manifest, with filtering (for version number) -->
    <filter token="impl.version" value="${impl.version}"/>
    <copy todir="${build.dir}" file="${manifest.xsltc.mf}" filtering="true"/>
    <jar jarfile="${build.xsltc.jar}" manifest="${build.dir}/manifest.xsltc" basedir="${build.classes}" >
      <patternset><!-- relative to jar/@basedir -->
        <include name="${xsltc.reldir}/**/*" />
      </patternset>
    </jar>
  </target>


  <target name="xsltc.jar" depends="xsltc.compile"
     description="Jar xsltc, BCEL,JLex,java_cup,runtime and jakarta regexp">
    <!-- make a tmp directory to work in -->
    <delete dir="${build.dir}/xsltctmp" includeEmptyDirs="true" quiet="true"/>
    <mkdir  dir="${build.dir}/xsltctmp" />

    <!-- create jar of xsltc classes in the tmp directory -->
    <jar jarfile="${build.dir}/xsltctmp/xsltc.jar"
        basedir="${build.dir}/classes"
        includes="org/apache/xalan/xsltc/**" />

    <!-- copy the xsltc 3rd party support jar files and licenses 
         to tmp dist dir 
    -->
    <copy todir="${build.dir}/xsltctmp"
      file="${bin.dir}/BCEL.jar"/>
    <copy todir="${build.dir}/xsltctmp"
      file="${bin.dir}/BCEL.LICENSE.txt"/>
    <copy todir="${build.dir}/xsltctmp"
      file="${bin.dir}/BCEL.README.txt"/>

    <copy todir="${build.dir}/xsltctmp"
      file="${bin.dir}/JLex.jar"/>
    <copy todir="${build.dir}/xsltctmp"
      file="${bin.dir}/JLex.LICENSE.txt"/>
    <copy todir="${build.dir}/xsltctmp"
      file="${bin.dir}/JLex.README.txt"/>

    <copy todir="${build.dir}/xsltctmp"
      file="${bin.dir}/java_cup.jar"/>
    <copy todir="${build.dir}/xsltctmp"
      file="${bin.dir}/java_cup.LICENSE.txt"/>
    <copy todir="${build.dir}/xsltctmp"
      file="${bin.dir}/java_cup.README.txt"/>

    <copy todir="${build.dir}/xsltctmp"
      file="${bin.dir}/runtime.jar"/>
    <copy todir="${build.dir}/xsltctmp"
      file="${bin.dir}/runtime.LICENSE.txt"/>
    <copy todir="${build.dir}/xsltctmp"
      file="${bin.dir}/runtime.README.txt"/>

    <copy todir="${build.dir}/xsltctmp"
      file="${bin.dir}/regexp.jar"/>
    <copy todir="${build.dir}/xsltctmp"
      file="${bin.dir}/regexp.LICENSE.txt"/>
    <copy todir="${build.dir}/xsltctmp"
      file="${bin.dir}/regexp.README.txt"/>

    <!-- unjar all jars -->
    <unjar src="${build.dir}/xsltctmp/xsltc.jar"
           dest="${build.dir}/xsltctmp" />
    <unjar src="${build.dir}/xsltctmp/BCEL.jar"
           dest="${build.dir}/xsltctmp" />
    <unjar src="${build.dir}/xsltctmp/JLex.jar"
           dest="${build.dir}/xsltctmp" />
    <unjar src="${build.dir}/xsltctmp/java_cup.jar"
           dest="${build.dir}/xsltctmp" />
    <unjar src="${build.dir}/xsltctmp/runtime.jar"
           dest="${build.dir}/xsltctmp" />
    <unjar src="${build.dir}/xsltctmp/regexp.jar"
           dest="${build.dir}/xsltctmp" />

    <!-- remove jar files -->
    <delete file="${build.dir}/xsltctmp/xsltc.jar" />
    <delete file="${build.dir}/xsltctmp/BCEL.jar" />
    <delete file="${build.dir}/xsltctmp/JLex.jar" />
    <delete file="${build.dir}/xsltctmp/java_cup.jar" />
    <delete file="${build.dir}/xsltctmp/runtime.jar" />

    <!-- remove old META-INF dir -->
    <delete dir="${build.dir}/xsltctmp/META-INF"
        includeEmptyDirs="true" quiet="true"/>

    <!-- create new META-INF dir w/ transformer factory default -->
    <!-- GTM: comment this out so that bundled xsltc.jar does not have
         service provider default until further notice 2/20/2002
    <mkdir dir="${build.dir}/xsltctmp/META-INF"/>
    <mkdir dir="${build.dir}/xsltctmp/META-INF/services"/>
    <copy todir="${build.dir}/xsltctmp/META-INF/services"
      file="${src.dir}/${xsltc.reldir}/javax.xml.transform.TransformerFactory"
    />
    -->

    <!-- Copy over the manifest, with filtering (for version number) -->
    <filter token="impl.version" value="${impl.version}"/>
    <copy todir="${build.dir}" file="${manifest.xsltc.mf}" filtering="true"/>
    
    <!-- make bundled jar named xsltc.jar -->
    <jar jarfile="${build.dir}/xsltc.jar" manifest="${build.dir}/manifest.xsltc"
         basedir="${build.dir}/xsltctmp" />

    <!-- clean up tmp directory -->
    <delete dir="${build.dir}/xsltctmp" includeEmptyDirs="true" quiet="true"/>
  </target>
  
  <!-- =================================================================== -->
  <!-- Creates the xalan JAR                                               -->
  <!-- =================================================================== -->
  <target name="jar" depends="compile"
    description="Jar up xalan.jar, plus the ${xmlapis.jar.name}" >
    <!-- Copy over the manifest, with filtering (for version number) -->
    <filter token="impl.version" value="${impl.version}"/>
    <copy todir="${build.dir}" file="${manifest.mf}" filtering="true"/>
    <jar jarfile="${build.xalan.jar}" manifest="${build.dir}/MANIFEST.MF" basedir="${build.classes}" >
      <patternset><!-- relative to jar/@basedir -->
        <exclude name="${xsltc.reldir}/**/*" />
      </patternset>
    </jar>
  </target>
  
  <!-- =================================================================== -->
  <!-- Default all target simply Creates the xalan JAR                     -->
  <!-- =================================================================== -->
  <target name="all" depends="jar"><!-- 'Standardizing build.xml files' <bloritsch@apache.org> -->
    <echo message="Redirect to jar target; please provide input on desired functionality of this target"/>
  </target>
  
  <!-- =================================================================== -->
  <!-- Compiles the samples (servlet excluded) and jars the class files    -->  
  <!-- =================================================================== -->
  <target name="samples" depends="jar"
    description="Compile and jar the samples (except servlet)" >
    <property name="exclude" value="*.xml,*.xsl,*.txt,*.html,*.properties,*.out"/>
    <mkdir dir="${build.samples}"/>
    <!-- Since the samples are packageless, they must be compiled separately. -->   
    <javac srcdir="${samples.dir}/SimpleTransform" 
           destdir="${build.samples}"  excludes="${exclude}"
           debug="${build.debug}" bootclasspathref="xslt.boot.class.path" >
      <classpath refid="samples.class.path" />
    </javac>           
    <javac srcdir="${samples.dir}/UseStylesheetPI"   
           destdir="${build.samples}"  excludes="${exclude}"
           debug="${build.debug}" bootclasspathref="xslt.boot.class.path" >
      <classpath refid="samples.class.path" />
    </javac>           
    <javac srcdir="${samples.dir}/UseStylesheetParam" 
           destdir="${build.samples}"  excludes="${exclude}"
           debug="${build.debug}" bootclasspathref="xslt.boot.class.path" >
      <classpath refid="samples.class.path" />
    </javac>           
    <javac srcdir="${samples.dir}/SAX2SAX"  
           destdir="${build.samples}"  excludes="${exclude}"
           debug="${build.debug}" bootclasspathref="xslt.boot.class.path" >
      <classpath refid="samples.class.path" />
    </javac>           
    <javac srcdir="${samples.dir}/DOM2DOM"  
           destdir="${build.samples}"  excludes="${exclude}"
           debug="${build.debug}" bootclasspathref="xslt.boot.class.path" >
      <classpath refid="samples.class.path" />
    </javac>           
    <javac srcdir="${samples.dir}/Pipe"  
           destdir="${build.samples}"  excludes="${exclude}"
           debug="${build.debug}" bootclasspathref="xslt.boot.class.path" >
      <classpath refid="samples.class.path" />
    </javac>           
    <javac srcdir="${samples.dir}/UseXMLFilters"  
           destdir="${build.samples}"  excludes="${exclude}"
           debug="${build.debug}" bootclasspathref="xslt.boot.class.path" >
      <classpath refid="samples.class.path" />
    </javac>           
    <javac srcdir="${samples.dir}/Trace"   
           destdir="${build.samples}"  excludes="${exclude}"
           debug="${build.debug}" bootclasspathref="xslt.boot.class.path" >
      <classpath refid="samples.class.path" />
    </javac>           
    <javac srcdir="${samples.dir}/ApplyXPath"  
           destdir="${build.samples}" excludes="${exclude}" 
           debug="${build.debug}" bootclasspathref="xslt.boot.class.path" >
      <classpath refid="samples.class.path" />
    </javac>
    <javac srcdir="${samples.dir}/ApplyXPathDOM"  
           destdir="${build.samples}" excludes="${exclude}" 
           debug="${build.debug}" bootclasspathref="xslt.boot.class.path" >
      <classpath refid="samples.class.path" />
    </javac>             
    <javac srcdir="${samples.dir}/trax"  
           destdir="${build.samples}" excludes="${exclude}" 
           debug="${build.debug}" bootclasspathref="xslt.boot.class.path" >
      <classpath refid="samples.class.path" />
    </javac>           
    <javac srcdir="${samples.dir}/extensions"  
           destdir="${build.samples}" excludes="${exclude}" 
           debug="${build.debug}" bootclasspathref="xslt.boot.class.path" >
      <classpath refid="samples.class.path" />
    </javac>           
    <javac srcdir="${samples.dir}/Validate"  
           destdir="${build.samples}" excludes="${exclude}" 
           debug="${build.debug}" bootclasspathref="xslt.boot.class.path" >
      <classpath refid="samples.class.path" />
    </javac>           
    <jar jarfile="${build.samples.jar}" basedir="${build.samples}"
         includes="*.class"/>                   
  </target>
   
  <!-- =================================================================== -->
  <!-- Compiles the sample servlet and jars the class files.                -->  
  <!-- The javax.servlet and javax.servlet.http packages                    -->
  <!-- must be on the classpath                                             -->
  <!-- =================================================================== -->
 <target name="servlet" depends="jar"
    description="Compile and jar the servlet samples in xalanservlet.war" >
     <echo message="To compile the sample servlets, javax.servlet and javax.servlet.http must be on the classpath"/>   
     <mkdir dir="${build.servlet}"/>
     <mkdir dir="${build.servlet}/WEB-INF/classes/servlet"/>
     <mkdir dir="${build.servlet}/WEB-INF/lib"/>
     <javac srcdir="${samples.dir}/servlet"
            destdir="${build.servlet}/WEB-INF/classes"
            debug="${build.debug}"
            bootclasspathref="xslt.boot.class.path" >
       <classpath refid="samples.class.path" />
     </javac>           
      <copy todir="${build.servlet}/WEB-INF/classes/servlet">
        <fileset dir="${samples.dir}/servlet" includes="media.properties"/>
      </copy>  		         
      <copy todir="${build.servlet}/WEB-INF">
        <fileset dir="${samples.dir}/servlet" includes="web.xml"/>
      </copy>
      <copy todir="${build.servlet}">
        <fileset dir="${samples.dir}/servlet" 
        		includes="birds.xml, birds.xsl, booklist1.xsl, 
        		booklist2.xsl, catalog.xml, fooparam.xml, fooparam.xsl, jspSample.jsp"/>
      </copy>
      <copy todir="${build.servlet}/WEB-INF/lib">
      	<fileset dir="${bin.dir}" includes="${parser.jar.name}, ${xmlapis.jar.name}"/>
      </copy>
      <copy file="${build.xalan.jar}" todir="${build.servlet}/WEB-INF/lib" />
    <jar jarfile="${build.servlet.war}" 
         basedir="${build.servlet}" 
         includes="**"/>
 </target>
 
  <!-- =================================================================== -->
  <!-- Compiles (does not jar) the translet samples in translets.          -->
  <!-- For time being, classes are generated in place.                     -->
  <!-- To run these samples, add xsltc.jar, runtime.jar, bcel.jar,         -->
  <!-- and java_cup.jar (all in the bin directory) to the classpath        --> 
  <!--                                                                     -->
  <!-- When we have straightened out classpath issues,                     -->
  <!-- add samples in CompiledApplet, CompiledBrazil, and CompiledServlet  -->
  <!-- =================================================================== -->
  <target name="xsltc.samples" depends="jar,xsltc.jar">
    <javac srcdir="${samples.dir}/translets" classpath="${java.class.path}:${build.xsltc.jar}" 
           destdir="${samples.dir}/translets" excludes="${exclude}" 
           debug="${build.debug}"
           bootclasspathref="xslt.boot.class.path" />
  </target>
 
 
  <!-- =================================================================== -->
  <!-- Generate HTML docs                                                  -->
  <!-- =================================================================== -->
  <target name="docs" depends="jar,prepare.docs,autodocs"
    description="Build the documentation (overview, readme, etc.)" >
    <echo message="docs is human-usable target with dependencies"/>  
  </target>
  
  <target name="autodocs">
    <echo message="autodocs is for automated build process, without dependencies"/>   
    <java fork="yes" 
          classname="${doc.generator}" 
          classpathref="docs.class.path" >
       <arg line="targetDirectory=${build.docs} ${xdocs.book} ${xdocs.style}"/>
    </java>	 
  </target>
  
  <!-- =================================================================== -->
  <!-- Creates the API documentation                                       -->
  <!-- =================================================================== -->
  <target name="javadocs" depends="jar,prepare.docs,autojavadocs"
    description="Build the Javadocs for Xalan 2.x and xml-commons sources" >
    <echo message="javadocs is human-usable target with dependencies"/>  
  </target>

  <target name="autojavadocs">
    <echo message="autojavadocs is for automated build process, without dependencies"/>
    
      <!-- Expand xml-commons sources (JAXP 1.1, DOM 2, and SAX 2) into source tree for 
           inclusion in the Javadoc. -->                                            
     <gunzip src="${xml-commons-srcs.tar.gz}" dest="${build.dir}" />                                                                         
     <untar src="${xml-commons-srcs.tar}" dest="${src.dir}" /><!-- Note this is into the src area.-->                                                                         
     <delete file="${xml-commons-srcs.tar}"/>
      
    <!-- Ant ignores destdir arg if doclet is set, so must send to doclet in doclet subelement-->
    <javadoc
         public="true"
         sourcepath="${src.dir}"
         overview="${src.dir}/javadocOverview.html"
         packagenames="org.apache.*,org.xml.*,org.w3c.*,javax.xml.*"
         author="true"
         version="true"
         use="true"
         windowtitle="${Name-in-docs} 2" 
         doctitle="${Name-in-docs} 2"
         bottom="Copyright &#169; ${year} Apache XML Project. All Rights Reserved.">
          <classpath refid="docs.class.path" />
          <doclet name="xalanjdoc.Standard" path="${doclet.jar}">
            <param name="-d" value="${build.apidocs}"/>
          </doclet>
          <group title="Transformations API for XML (TrAX)" packages="javax.xml.transform*"/>
          <group title="Java API for XML Parsing" packages="javax.xml.parsers"/>
          <group title="Xalan Core"
                 packages="org.apache.xalan.processor:org.apache.xalan.templates:org.apache.xalan.transformer"/>
          <group title="XPath" packages="org.apache.xpath*"/>
          <group title="Document Table Model (DTM)" packages="org.apache.xml.dtm*"/>          
          <group title="Utilities" packages="org.apache.xml.utils*"/>
          <group title="Xalan Other" packages="org.apache.xalan.client:org:org.apache.xalan.extensions:org.apache.xalan.res:org.apache.xalan.stree:org.apache.xalan.trace:org.apache.xalan.xslt"/>
          <group title="Xalan Extensions" packages="org.apache.xalan.lib*"/>
          <group title="Serializers" packages="org.apache.xalan.serialize"/>
          <group title="SAX 2" packages="org.xml.sax*"/>
          <group title="DOM 2" packages="org.w3c.dom*"/>
          <group title="XSLTC Core"
                 packages="org.apache.xalan.xsltc*"/>
    </javadoc>
    
  </target>

  <!-- =================================================================== -->
  <!-- Various targets to clean the build tree                             -->
  <!-- =================================================================== -->
  <target name="distclean" depends="clean"
    description="Clean everything, including dist/jar/docs/xsltc.*" >
    <delete dir="${dist.dir}"/>
  </target>

  <target name="clean" depends="xsltc.clean"
    description="Clean the ${build.dir} tree and doc outputs" >
    <delete dir="${build.dir}"/>
    <delete dir="${site.root}"/>
    <delete>
      <fileset dir="${xdocs.style}" excludes="${xalanonly-styledocs}"/>
    </delete>
    <delete file="${xdocs.DONE.file}"/>
    <delete file="${xdocs.XSLTCDONE.location}"/>
    <!-- Also delete files expanded from ${xml-commons-srcs.tar.gz}-->
    <delete dir="${src.dir}/javax" includeEmptyDirs="true" quiet="true"/>
    <delete dir="${src.dir}/org/xml" includeEmptyDirs="true" quiet="true"/>
    <delete includeEmptyDirs="true" quiet="true">
      <fileset dir="${src.dir}/org/w3c">
        <exclude name="dom/xpath/**"/>
      </fileset>
    </delete>
  </target>
 
  <target name="xsltc.clean"
    description="Clean miscellaneous generated sources from xsltc.compile" >
    <delete file="${generated.xpathparser}" />
    <delete file="${generated.xpathsym}" />
    <delete file="${generated.xpathlexer}" />
  </target>

  <!-- =================================================================== -->
  <!-- Install/Uninstall targets - not currently applicable                -->
  <!-- =================================================================== -->
  <target name="install"><!-- 'Standardizing build.xml files' <bloritsch@apache.org> -->
    <echo message="install target currently not supported in ${Name-in-docs}; try jar or dist instead"/>
  </target>
  <target name="uninstall"><!-- 'Standardizing build.xml files' <bloritsch@apache.org> -->
    <echo message="uninstall target currently not supported in ${Name-in-docs}; try distclean instead"/>
  </target>

  <!-- =================================================================== -->
  <!-- Creates the distribution                                            -->
  <!-- =================================================================== -->
  <target name="dist" depends="jar,docs,javadocs,samples,servlet,xsltc.jar,xsltc.docs,autodist"
    description="Create a .zip/.tar.gz distribution module" >
    <echo message="dist is human-useable target for distribution, with all dependencies"/>
  </target>
  <target name="autodist">
    <echo message="autodist is for automated build processes, without dependencies"/>
    <mkdir dir="${dist.dir}"/>
    <mkdir dir="${dist.dir}/bin"/>    
    <mkdir dir="${dist.dir}/src"/>
    <mkdir dir="${dist.dir}/xdocs"/>
    <mkdir dir="${dist.dir}/docs"/>
    <mkdir dir="${dist.dir}/docs/apidocs"/>
    <mkdir dir="${dist.dir}/samples"/>
        
    <!-- Copy bin directory, which includes preexisting checked-in .jar files -->
    <copy todir="${dist.dir}/bin">
      <!-- But skip copying old xerces.jar, which will be removed soon -->
      <fileset dir="${bin.dir}" excludes="xerces.jar" />
    </copy>  

    <!-- Copy sources and source documentation -->
    <copy todir="${dist.dir}/src">
      <fileset dir="${src.dir}"/>
    </copy>
    <copy todir="${dist.dir}/xdocs">
      <fileset dir="${xdocs.dir}"/>
    </copy>
    
    <!-- Copy built documentation and javadoc, and samples src and jars -->
    <copy todir="${dist.dir}/docs">
      <fileset dir="${build.docs}"/>
    </copy>  
    <copy todir="${dist.dir}/samples">
      <fileset dir="${samples.dir}"/>
    </copy>   
    <copy file="${build.dir}/xalansamples.jar" todir="${dist.dir}/bin"/>
    <copy file="${build.dir}/xalanservlet.war" todir="${dist.dir}/bin"/>

    <!-- Copy various built product .jars into the bin directory 
         of the distro, note that changes to what .jars we ship 
         must also be duplicated in the appropriate patternsets 
         below that actually define the contents of our two 
         *-bin.zip/tar.gz and *-src.zip/tar.gz files.
    -->
    <copy file="${build.xalan.jar}" todir="${dist.dir}/bin" />
    <copy file="${build.xsltc.jar}" todir="${dist.dir}/bin"/>

    <copy todir="${dist.dir}">
      <fileset dir="." includes="readme.html,KEYS,License,build.xml,build.sh,build.bat,xsltc_todo.xml,todo.xsl,commits.xml"/>
    </copy>
          
    <!-- Build separate -src and -bin distros for both .zip and .tar.gz -->
    <!-- Explicitly list xercesImpl.jar in patternsets since we 
         always want Xerces in distros, immaterial of parser 
         used to compile (at least for official builds) -->
    <patternset id="bin-distro" >
      <include name="${dist.file}/readme.html"/>
      <include name="${dist.file}/License"/>
      <include name="${dist.file}/KEYS"/>
      <include name="${dist.file}/bin/${name}.jar"/>
      <include name="${dist.file}/bin/${xmlapis.jar.name}"/>
      <include name="${dist.file}/bin/xsltc.jar"/>
      <include name="${dist.file}/bin/xercesImpl.jar"/>
      <include name="${dist.file}/bin/${bsf.jar.name}"/>
      <include name="${dist.file}/bin/xalansamples.jar"/>
      <include name="${dist.file}/bin/xalanservlet.war"/>
      <include name="${dist.file}/samples/"/>
      <include name="${dist.file}/docs/"/>
    </patternset>
    <patternset id="src-distro" >
      <include name="${dist.file}/*"/>
      <include name="${dist.file}/bin/ant.jar"/>
      <include name="${dist.file}/bin/xercesImpl.jar"/>
      <include name="${dist.file}/bin/${xmlapis.jar.name}"/>
      <include name="${dist.file}/bin/${bsf.jar.name}"/>
      <include name="${dist.file}/bin/${stylebook.jar.name}"/>
      <include name="${dist.file}/bin/${doclet.jar.name}"/>
      <include name="${dist.file}/bin/*.LICENSE.txt"/>
      <include name="${dist.file}/bin/*.README.txt"/>
      <include name="${dist.file}/samples/"/>
      <include name="${dist.file}/src/"/>
      <include name="${dist.file}/xdocs/"/>
    </patternset>
    <!-- For convenience, list the assorted XSLTC engine dependency
         .jar files separately, since they go in both -bin and -src.
    -->
    <patternset id="xsltc-deps-jars" >
      <include name="${dist.file}/bin/${bcel.jar.name}"/>
      <include name="${dist.file}/bin/${java_cup.jar.name}"/>
      <include name="${dist.file}/bin/${jlex.jar.name}"/>
      <include name="${dist.file}/bin/${runtime.jar.name}"/>
      <include name="${dist.file}/bin/${regexp.jar.name}"/>
    </patternset>

    <tar tarfile="${build.dir}/${dist.file}-bin.tar" >
      <tarfileset dir="${build.dir}">
        <patternset refid="bin-distro"/>
        <patternset refid="xsltc-deps-jars"/>
      </tarfileset>
    </tar>
    <gzip src="${build.dir}/${dist.file}-bin.tar" zipfile="${build.dir}/${dist.file}-bin.tar.gz"/>
    <delete file="${build.dir}/${dist.file}-bin.tar" />

    <tar tarfile="${build.dir}/${dist.file}-src.tar" >
      <tarfileset dir="${build.dir}">
        <patternset refid="src-distro"/>
        <patternset refid="xsltc-deps-jars"/>
      </tarfileset>
    </tar>
    <gzip src="${build.dir}/${dist.file}-src.tar" zipfile="${build.dir}/${dist.file}-src.tar.gz"/>
    <delete file="${build.dir}/${dist.file}-src.tar" />

    <zip zipfile="${build.dir}/${dist.file}-bin.zip" >
      <fileset dir="${build.dir}">
        <patternset refid="bin-distro"/>
        <patternset refid="xsltc-deps-jars"/>
      </fileset>
    </zip>
    <zip zipfile="${build.dir}/${dist.file}-src.zip" >
      <fileset dir="${build.dir}">
        <patternset refid="src-distro"/>
        <patternset refid="xsltc-deps-jars"/>
      </fileset>
    </zip>
  </target>
  
  <!-- =================================================================== -->
  <!-- Creates the documentation tree for the org.apache.xml website       -->
  <!-- =================================================================== -->
  <target name="site" depends="prepare.docs"
    description="Build documentation for posting to the website" >
 
    <mkdir dir="${site.dir}/apidocs"/>
    <mkdir dir="${site.dir}/design"/>
    <java fork="yes" 
          classname="${doc.generator}" 
          classpathref="docs.class.path" >
       <arg line="targetDirectory=${site.dir} ${site.book} ${xdocs.style}"/>
    </java>

    <!-- put xalan design doc in the site design subdir -->
    <copy todir="${site.dir}/design">
      <fileset dir="${build.docs}/design"/>
    </copy>
    <!-- put xsltc design doc in the site xsltc subdir -->
    <copy todir="${site.dir}/xsltc">
      <fileset dir="${build.docs}/xsltc"/>
    </copy>  
    
    <!-- put in the javadoc -->
    <copy todir="${site.dir}/apidocs">
      <fileset dir="${build.apidocs}"/>
    </copy>      
  </target>
   
  <!-- =================================================================== -->
  <!-- Compiles and runs mini/smoketest from xml-xalan\test, if present    -->
  <!-- =================================================================== -->
  <property name="test.relpath" value="../test"/>

  <target name="minitest" depends="prepare,minitest-run,tests-not-available" 
    description="Run the Minitest from xml-xalan/test" >
    <!-- This target simply asks the minitest-run worker target to 
         actually have the Minitest run (by the test/build.xml file);
         we then also call the tests-not-available target in case 
         the user never checked out the tests.
    -->
  </target>
  <target name="minitest-run" if="tests-available" depends="jar" >
    <echo message=" [minitest] Calling ${test.relpath}/build.xml to run the Minitest" />
    <ant dir="${test.relpath}" antfile="build.xml" target="minitest.gump" >
    </ant>
  </target>

  <target name="smoketest" depends="prepare,smoketest-run,tests-not-available" 
    description="Run Smoketests (Minitest, conf, harness) from xml-xalan/test" >
  </target>
  <target name="smoketest-run" if="tests-available" depends="jar" >
    <echo message=" [minitest] Calling ${test.relpath}/build.xml to run the Smoketest" />
    <ant dir="${test.relpath}" antfile="build.xml" target="smoketest.dev" >
    </ant>
  </target>

  <target name="check" depends="smoketest"><!-- 'Standardizing build.xml files' <bloritsch@apache.org> -->
    <echo message="Redirect to smoketest target"/>
  </target>

  <!-- Called from various testing targets if the test dir doesn't exist. -->
  <target name="tests-not-available" unless="tests-available" >
    <echo message=" [tests] The tests do not seem to be present in ${test.relpath}" />
    <echo message=" [tests] You must have checked out from CVS to run the tests," />
    <echo message=" [tests]   it is not included in binary distributions." />
    <echo message=" [tests] See http://xml.apache.org/xalan-j/test/ for more info." />
  </target>

  <!-- =================================================================== -->
  <!-- Creates the xalan design document                                   -->
  <!-- =================================================================== -->
    <target name="xalan-j2-design">
    <java fork="yes" 
          classname="${doc.generator}" 
          classpathref="docs.class.path" >
      <arg line="loaderConfig=sbk:/style/loaderdesign.xml targetDirectory=${build.dir}/docs/design/
      ${xdocs.dir}/sources/xalandesign.xml ${xdocs.style}"/>
    </java>
  </target>
  
  <!-- =================================================================== -->
  <!-- Use FOP to create preliminary print (pdf) doc                       -->
  <!-- Note: fop.jar and xml.jar (from xml-fop) must be on classpath       -->
  <!-- This is VERY preliminary, not yet for inclusion in distribution     -->
  <!-- =================================================================== -->
  <!--Collate the xml sources into a single xml source with a litle extra structure -->
  <target name="printerdocs" depends="prepare.docs">
    <echo message="NOTICE: requires fop.jar and xml.jar on the classpath"/>
    <java fork="yes" 
          classname="${xalan.cmdline.class}"
          classpathref="docs.class.path" >
      <arg line="-xsl ${xdocs.dir}/sources/xalan-collate.xsl 
                 -out xdocs/sources/xalan/xalan-collate.xml"/>
    </java>
    
    <!-- Transform collation into Formatting Objects 
         (with a little work on links along the way) -->    
    <java fork="yes" 
          classname="${xalan.cmdline.class}"
          classpathref="docs.class.path" >
      <arg line="-in  ${xdocs.dir}/sources/xalan/xalan-collate.xml
                 -param resourceFile '../../sources/xalan/resources.xml'
                 -param project ${Name-in-docs}      
                 -xsl ${xdocs.style}/stylesheets/xml2fo.xsl 
                 -out build/docs/xalan-collate.fo"/>
    </java>
    
    <!-- Use FOP to generate a pdf file (classpath may need updating! -sc 18-Apr-01)-->
    <java fork="yes" 
          classname="org.apache.fop.apps.CommandLine"
      classpath="${java.class.path}:${build.xalan.jar}:${bin.dir}/fop.jar:${bin.dir}/w3c.jar">
      <arg line="${build.docs}/xalan-collate.fo build/docs/xalan.pdf"/>
    </java>
  </target>

 
  <!-- =================================================================== -->
  <!-- Build XSLTC design documentation. Eventually intend to incorporate -->
  <!-- XSLTC into the Xalan book.                                         -->
  <!-- =================================================================== -->


  <target name="xsltc.prepare.docs" depends="prepare.docs">
      <echo message="Transform xsltc_todo.xml and put the result in ${build.docs}/xsltc"/>
   <mkdir dir="${build.docs}/xsltc"/>
    <java fork="yes" classname="${xalan.cmdline.class}">
      <classpath refid="docs.class.path" />
      <arg line="-in xsltc_todo.xml -xsl todo.xsl -out build/docs/xsltc/todo.html"/>
    </java>
  </target>  
 
 <target name="xsltc.docs" depends="xsltc.prepare.docs">
   <echo message="Build the XSLTC Architectural documentation"/>
   <java fork="yes" 
         classname="${doc.generator}" 
         classpathref="docs.class.path" >
      <arg line="targetDirectory=${build.docs}/xsltc ${xdocs.dir}/sources/xsltc.xml ${xdocs.style}"/>
    </java>	 
    <copy todir="${build.docs}/xsltc" 
	file="${xdocs.dir}/sources/xsltc/README.xslt" />
    <copy todir="${build.docs}/xsltc" 
	file="${xdocs.dir}/sources/xsltc/README.xsltc" />
 </target>
 
   <!-- pack all doc for transfer to website -->
 <target name="pack.docs">
    <!--tar tarfile="./build/xalan-j-docs.tar" basedir="./xml-site/target/xalan-j" includes="**"/>
    <gzip src="./build/xalan-j-docs.tar" zipfile="./build/xalan-j-docs.tar.gz"/-->
    <zip zipfile="./build/xalan-j-docs.zip" basedir="./xml-site/target/xalan-j" includes="**"/>
  </target>

 
</project>
