Trademark Logo Xalan XSL Transformer User's Guide
Xalan-Java Release builds
Apache Foundation Xalan Project Xerces Project Web Consortium Oasis Open

Xalan-Java Release builds



This page is not for users who want to download pre-built jars of Xalan-Java or download the source code for Xalan-Java and build from that. Users who want to do that should see the Download/Build page.

This page is intended for Xalan committers and developers and is about the process to create a new release. It provides a selection of brief checklists for committers and developers about build procedures for the Xalan-Java community. Community input is appreciated; if you have questions, please ask on xalan-dev.

note The product build related sections of this document are still quite thin - they're mainly bullet points almost in checklist style. If you don't fully understand the procedures in this document, then you probably should ask for help first!


Developer Guidelines

note This section is meant to become a set of guidelines for all Xalan-Java committers and developers who wish to submit patches. It's still in progress; suggestions to appreciated.

The project's technical mailing list for all committers and developers interested in the API and inner workings is; it's a good idea to subscribe if you plan to work on Xalan-Java. Logs of all Subversion commits are automatically sent to, although discussions should happen on xalan-dev. You can read more about mailing lists.

Xalan-Java is a fairly mature project; one where most committers and many users expect that the daily build will be mostly functional. Very risky changes or major architecture updates should be discussed ahead of time or committed onto branches.

Developers should always run the Smoketest before checking in files or submitting patches to the list. If the Smoketest does not pass, you should either fix whatever you broke or get consensus from xalan-dev that it's OK to break the Smoketest temporarily. The Smoketest is a selection of API functionality tests and a pass through a wide variety of XSLT conformance tests that ensure basic functionality. You can also read a full set of documentation about the tests.

(Smoketest doc is TBD!)

cvs co xml-xalan/java xml-xalan/test
cd xml-xalan/java
build smoketest
# Ant build will fail if smoketest fails.


Running Product Builds - Overview

Official builds of Xalan-Java require a few more steps than simply doing 'build fulldist'. This is a quick checklist of the steps; if you are not comfortable following this list, then please seek help on xalan-dev.


Release Types

Official builds come in several flavors:


Condensed Build Checklist

A very brief list of stages in running a build.

  1. Email xalan-dev with build plan.

  2. Verify all code changes are checked in.

  3. Verify any doc updates for code changes are in.

  4. Update build numbers in doc, code, and build scripts.

  5. Do a clean checkout and tag the sources.

  6. build fulldist -logfile ..\fulldist.log

  7. build fulldist-separatejars -logfile ..\fulldist-separatejars.log

  8. Run the smoketest for Xalan Interpretive and XSLTC.

  9. Verify smoketest passed; check docs built with new build numbers.

  10. PGP/GPG sign all .zip/.tar.gz distribution files (distros).

  11. Copy distros up to the website.

  12. Update website documentation set.

  13. Email xalan-dev with build notice!


Running Product Builds - Details

This section is still in progress, but should have all the basics. You should already have read the build overview above and you should already be familiar with our build.xml script and development processes.


Pre-Build Steps

Preparation before you run a build.

Apache projects are communities: you should always let the community know what the plans for builds are. The xalan-dev mailing list is the primary communication mechanisim for committers and developers working on Xalan-Java; you may also wish to cc: the xalan-j-users list to let other users and folks know what's coming. For major releases you may also want to cc: the list so that other projects know our plans, although this is not required.

Ensure that any code changes you're planning to have in this release are actually checked in; make sure any open work by other committers is in a stable state. You should also review any other projects we're dependent on and make sure that (when possible) we've updated to the latest version of their .jar files: like xercesImpl.jar, ant.jar, etc. Note that occasionally we will have a specific development need to stay with a different version of these projects.


Updating Doc And Version Numbers

Getting documentation and version numbers in sync.

Check that the documentation is up to date. Make sure that any new features or major functionality changes are properly documented.

Update the commits list and the 'what was done' list in xdocs/sources/xalan/readme.xml and whatsnew.xml. Note that currently some of the status information for the XSLTC portion of Xalan-Java is stored separately in xsltc_history.xml and XSLTCDONE

Check in all your work!

Once you know what the version number should be, you'll need to update it in a number of places - both for the product itself, for the build system, and for the documentation. If you don't understand how to update any of these files, then please get help - don't just try to wing it.

I did remind you to check in all your work, didn't I?


Run A Candidate Distribution Build

Get clean sources and build a distribution and (at least) the smoketest.

Of course, you checked in all your earlier work to the Subversion repository, right?

The safest way to perform a build for distribution is to check out a fresh new copy of the repository from Subversion. This avoids any potential problems with uncommitted changes or extra files on your local machine.

Check out a new copy of both xml-xalan/java and xml-xalan/test repositories to a blank directory on your local machine. You then need to tag the files in the repository with a marker noting that these versions are the actual ones being used in the build (you could actually do this after running the build below). Use the Subversion tag command to add the tag to both repositories (/java and /test). The tag name should be something like 'xalan-j_2_4'; look at the log of any file to see the exact format of previous builds.

The above command will build the binary and source distribution .zip/.tar.gz files, in which the Xalan Interpretive and Xalan Compiled (XSLTC) processors are combined into the xalan.jar file. All the samples and the documentation are built as well. The log of the build is saved in ..\fulldist.log. Note that this will take up a moderate amount of space, especially when building the .tar.gz files, so ensure you have plenty of disk space first.

Review the fulldist.log file quickly to ensure there were no build errors. Note that you can ignore any 'warnings' from the javadoc target; however any 'error's in the documentation must be fixed.

Before running this command, rename the generated ./build directory from the 'fulldist' command above to another name, for example, build-combinedjar. The 'fulldist-separatejars' command will build the binary and source distribution .zip/.tar.gz files, in which the Xalan Interpretive and Xalan Compiled (XSLTC) processors are built into separate jars; xalan.jar and xsltc.jar respectively. All the samples and the documentation are built as well. The log of the build is saved in ..\fulldist-separatejars.log. Note that this will take up a moderate amount of space, especially when building the .tar.gz files, so ensure you have plenty of disk space first.

Review the fulldist-separatejars.log file quickly to ensure there were no build errors. Note that you can ignore any 'warnings' from the javadoc target; however any 'error's in the documentation must be fixed.

The results of the build will be placed in the ./build directory. Rename the and xalan-j_2_x_x-bin.tar.gz files to and xalan-j_2_x_x-bin-2jars.tar.gz respectively so that this binary distribution can be distinguished from the binary distributions created by the 'fulldist' target. The source distributions, and xalan-j_2_x_x-src.tar.gz are duplicates of those created by the 'fulldist' target.

Change to the xml-xalan\test directory and build the test harness by entering "build jar -logfile jar.log". Run the smoketest for the Xalan Interpretive processor by entering "build smoketest -logfile smoketest.log". Run the smoketest for the XSLTC by entering "build smoketest.xsltc -logfile smoketest.xsltc.log".

Review the smoketest.log and smoketest.xsltc.log files. If they do not say that the Smoketest passed, then you must fix the test results before posting the build. Even for developer's builds, we must ensure that at least the Smoketest passes. For major or minor releases, we should also perform more testing to ensure stability. More detailed log files for the Smoketest can be found in the xml-xalan/test/smoketest/ directory.

You should also test that the documentation built properly, and that it has the proper build or release number that you edited above.

IMPORTANT: if you changed any files at all, be sure to check in your work and re-start this process!


Code Signing and Posting

Sign the distribution units so end-users can trust them, then copy to the website.

As a security measure, all projects must sign or otherwise ensure the integrity of their public distributions. This is most commonly done by signing the actual .zip/.tar.gz files with your personal PGP or GPG key. Note that you must sign the files before copying them up to the website.

The Xalan Java distributions consist of: the source distribution files ( and xalan-j_x_x_x-src.tar.gz) and the two binary distributions files ( and xalan-j_x_x_x-bin.tar.gz, and and xalan-j_x_x_x-bin-2jars.tar.gz).

Two prerequisites to signing the distribution are: 1) you must have a personal PGP or GPG key, and 2) the public half of your key must be in the appropriate KEYS file before you begin a build. If you hadn't previously checked in your public key to the KEYS file before beginning this whole process, you'll have to go back and start again.

note We need some good links on getting PGP and GPG, and on actually code signing and verifying signatures. Jakarta has some, but they're scattered. This would be a good volunteer project for someone.

Sign every .zip and .tar.gz file with your personal key, and make a detached text file with the signature - this will usually create a or file for each file you sign.

You'll need to copy all of the distros plus all of your detached signature files to the website so people can download them. Note that machines generally do not allow inbound ftp, so you'll need to either scp them or login to the apache machines and use scp or pftp from there outbound to some server that you've copied them to.

(Subject to change as gets ready for mirroring) You'll need to log on to (which is a separate machine from and upload the files to /www/

You should also update the distribution directory's html files to note the new build numbers. Carefully edit the .htaccess file to update the 'Latest Stable Build' and 'Latest Developers Build' lines as needed. If you don't understand the format of this file, ask for help.


Rebuilding the Xalan-Java documentation

Xalan-Java includes a number of XML source files, XSL stylesheets, document type definition (DTD) files, entity relationship (ENT) files, graphics, and a JavaScript file that provide the input for the Xalan-Java HTML User's Guide, and the overview and package-level documents used during the generation of Javadoc.

Before rebuilding the documentation there are probably a number of pages that need to be updated, at a minimum consider these:

XML source file Description of contents
downloads.xml how to download releases
readme.xml has the release notes for each release (most recent to the oldest release)
whatsnew.xml describes what is new in the latest release

For a new release it is quite likely that some information in the whatesnew.xml page needs to be moved into the appropriate section of the readme.xml or release notes page before updating both of these pages with the information for the new release.

To rebuild the documentation, you must use the StyleBook tool and the JDK 1.2.2 java and javadoc tools. StyleBook (which uses Xalan and Xerces) is in stylebook-1.0-b2.jar. Some of the document definition files, stylesheets, and resources are stored in xml-site-style.tar.gz, and are unzipped when you run Ant as described below.

You can use Ant with the docs target to regenerate the User's Guide and with the javadocs target to regenerate the Javadoc API documentation.

When building the Javadoc API documentation, or the HTML pages for the website the following Ant Targets are of interest:

Ant Target What Ant does
javadocs creates the API documentation
serializer.javadocs creates the API documetation for the serializer
site creates the HTML pages for the site creates the HTML pages for the site


Post-Build Docs and Email

Update the live website doc and let the community know you're done!

Now that the distribution is available for downloading, you should also update the static copy of the documentation that's posted to

After everything is posted, you need to let the community know that a new build is available. Write up a short email announcing this with just a couple of the highlights of the new build, and a link to the distribution area.

Make the subject something like: [ANN] Xalan-J 2.x Point/Developers/Whatever Release posted to and send your email to:,, Note that for developers releases, you can omit the address if you don't think it will be of interest to the larger audience.