<?xml version="1.0" standalone="no"?> 
<!DOCTYPE s1 SYSTEM "../../style/dtd/document.dtd"[
<!ENTITY done-j SYSTEM "DONE">]>

<!--
 * The Apache Software License, Version 1.1
 *
 *
 * Copyright (c) 1999 The Apache Software Foundation.  All rights 
 * reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer. 
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The end-user documentation included with the redistribution,
 *    if any, must include the following acknowledgment:  
 *       "This product includes software developed by the
 *        Apache Software Foundation (http://www.apache.org/)."
 *    Alternately, this acknowledgment may appear in the software itself,
 *    if and wherever such third-party acknowledgments normally appear.
 *
 * 4. The names "Xalan" and "Apache Software Foundation" must
 *    not be used to endorse or promote products derived from this
 *    software without prior written permission. For written 
 *    permission, please contact apache@apache.org.
 *
 * 5. Products derived from this software may not be called "Apache",
 *    nor may "Apache" appear in their name, without prior written
 *    permission of the Apache Software Foundation.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * ====================================================================
 *
 * This software consists of voluntary contributions made by many
 * individuals on behalf of the Apache Software Foundation and was
 * originally based on software copyright (c) 1999, Lotus
 * Development Corporation., http://www.lotus.com.  For more
 * information on the Apache Software Foundation, please see
 * <http://www.apache.org/>.
 -->
<s1 title="Release Notes">
<p>&xslt4j-current;</p>

 <ul>
  <li><link anchor="status0">Status</link></li>&xsltcreleasenotesentry;
  <li><link anchor="build">Build Notes</link></li>
  <li><link anchor="contact">Getting in touch</link></li>
  <li><link idref="history">History of software changes</link></li>
 </ul><anchor name="status0"/>
  <s2 title="Status">
   <ul>
    <li><link anchor="done">Changes since version 2.2</link></li>
    <li><link anchor="global2.3">Global 2.3 updates</link></li>
    <li><link anchor="other">Other points of interest</link></li>
    <li><link anchor="bugs">Bugs</link></li>
    <li><link anchor="status">Version of &xml4j; to use</link></li>
    <li><link anchor="developer-list">&xslt4j; developers</link></li>
   </ul>
     <anchor name="done"/>
     <s3 title="Changes since &xslt4j; 2.3.1">
     &done-j;     
     </s3><anchor name="global2.3"/>
    <s3 title="Global 2.3 updates">
     <ul>
     <li>Release 2.3 is integrated with release 2 of &xml4j;.</li>
     <li>Release 2.3 does not include support for the deprecated &xslt4j; 1 compatability API. The &xslt4j; 1 compatability code does 
     NOT compile with &xml4j2;.</li>
      </ul>
     <p>Our <link idref="samples" anchor="sql">SQL extension samples</link> continue to use InstantDB, but based on our realization of changes 
     that have occurred in the licensing of InstantDB, we no longer include InstantDB and the associated sample database with our distibution.
     We do, however, provide information on how to <link idref="samples" anchor="instantdbsetup">set up InstantDB</link> to support our SQL 
     extension samples.</p>
     <p>Documentation updates: We have subdivided the release notes into multiple files to accelerate HTML document loading, and we have added a
     document on <link idref="features">Transform features</link>.</p>         
     </s3>
     <anchor name="other"/>
     <s3 title="Other points of interest">
     <ul>
     <li>If an attempt is made to coerce a different namespace onto a prefix already in use in xsl:attribute, the attribute will come out 
     in the wrong namespace. Workaround: either provide an NCName instead of a QName for the attribute, or provide a QName with a prefix not
     used elsewhere.<br/><br/></li>
     <li>Handling xsl:namespace-alias declarations: In release 2.0.D01, we reported the need to do some research concerning exactly how &xslt;
     should handle xsl:namespace-alias declarations. As a result of discussions among members of the W3C Working Group on XSL, we have reached a
     more precise consensus on how namespaces should be represented when an xsl:namespace-alias declaration is in effect.<br/><br/>
     If a literal result element has a namespace prefix, the prefix will be preserved and the namespace URI of the element will be as
     specified in the xsl:namespace-alias element, but the result-prefix is not required to appear in the result. This also applies to the
     two other cases of "Literal namespace URI" mentioned in the XSLT Recommendation on 
     <jump href="http://www.w3.org/TR/xslt#literal-result-element">Literal Result Elements</jump>. More simply, if the stylesheet calls for
     &lt;axsl:foo&gt; to be output as a literal result element, then it will be output as &lt;axsl:foo&gt; in the result, but the namespace
     associated with this "axsl" prefix will be as designated in the xsl:namespace-alias declaration.<br/><br/></li>
     <li>For HTML output, &xslt4j2; outputs character entity references (&amp;copy; etc.) for the special characters designated in  
     <jump href="http://www.w3.org/TR/xhtml1/#dtds">Appendix A. DTDs of the XHTML 1.0: The Extensible HyperText Markup
     Language</jump>. &xslt4j; 1.x, on the other hand, outputs literal characters for some of these special characters.<br/><br/></li>
     <li>In conformance with the <jump href="http://www.w3.org/TR/xslt#section-HTML-Output-Method">XSLT Recommendation on the HTML 
     Output Method</jump> and <jump href="http://www.w3.org/TR/REC-html40/appendix/notes.html#h-B.2.1">Section B.2.1 of the HTML 4.0
     Recommendation</jump>, &xslt4j2; uses %hh encoding for each byte of the UTF-8 representation of non-ASCII characters in HTML URI
     attributes.<br/><br/></li>
     <li>When your stylesheet asks for an explicit carriage-return character (&amp;#13;) to be inserted into the output, it is output during
     the serialization process in escaped form unless escaping has been disabled.  When your stylesheet asks for an explicit line-feed character
     (&amp;#10;) to be output, the system-default line-break character(s) is/are output during the serialization process.  Also keep in mind that
     the XML parser normalizes line-breaks to line-feeds when it sends character events to the processor.<br/><br/></li>
     <li>If your XML input is a DOM, use the javax.xml.parsers.DocumentBuilderFactory setCoalescing() method to set coalescing to true (it is
     false by default), if you want to append CDATA sections to adjacent text sections to form a single text node (as the XPath standard calls
      for), and if the XML parser supports this feature (&xml4j-used; does not).<br/><br/></li>
     <li>When you traverse the namespace axis for a collection of element nodes, &xslt4j; includes <em>one</em> namespace node for each namespace in scope 
     for one or more of the nodes in that collection. The XPath expression does not return additional (redundant) namespace nodes for each element
     for which the namespace nodes are in scope.<br/><br/></li>
     <li>See <jump href="http://nagoya.apache.org/bugzilla/show_bug.cgi?id=2291">Bugzilla bug 2291</jump> for a discussion of issues surrounding
     use of the default character encoding to read META-INF/Services.<br/><br/></li>
     <li>As <jump href="http://nagoya.apache.org/bugzilla/show_bug.cgi?id=1800">Bugzilla bug 1800</jump> reports, the Transformer does not get the 
     setTransformState event until after the startDocument event. This could present a problem for tools developers, and we do intend to fix this 
     bug.</li> 
     </ul>
     </s3><anchor name="bugs"/>
     <s3 title="Bugs">
     <p>All known &xslt4j; bugs are listed in <resource-ref idref="bugzilla"/>. For a list of open bugs with links to each bug
      report, see <resource-ref idref="buglist"/>. If you find a new bug, please enter a XalanJ2 bug report in this
      database.</p>
     <note>Before you can enter your first bug report, you must submit your email address to Bugzilla and receive a password.</note> 
     <p>We strongly encourage you write patches for problems you find and submit them to
      xalan-dev@xml.apache.org. We review the patches we receive to make sure they do not break something else, and (assuming they 
     do not) include them in our next release. In the interest of fixing bugs, adding enhancements, and addressing outstanding design
     issues, we sincerely want (and need!) your active participation in the ongoing development of &xslt;.</p>
     </s3>     
     <anchor name="status"/>
     <s3 title="Version of Xerces to use"> 
       <p>The &xslt4j-current; has been tested with &xml4j-used;. &download; For information about including &xml4j-jar; and xml-apis.jar on the system class path, see <link idref="getstarted" anchor="classpath">Setting up the system class path</link>.</p>
       <p><em>Important</em> You may experience unpredictable anomalies if your &xslt4j; and &xml4j; builds are not in synch. If you download an update to &xslt4j;, check the release notes to determine which version of &xml4j; you should use.</p>
       <note>You can use &xslt4j; with other XML parsers that implement the <resource-ref idref="jaxp"/>. See 
       <link idref="usagepatterns" anchor="plug">Plugging in the Transformer and XML parser</link>.</note>
     </s3>
  </s2>
  <anchor name="build"/>  
  <s2 title="Build Notes">
  <p>We provide two distributions: a binary distribution, and a source distribution. See <link idref="getstarted" anchor="download">Downloading
  what you need</link>. If you have downloaded the binary distribution, you already have a build. If you downloaded the source
  distribution, you can use Ant to build &xslt4j;, including xalan.jar, xalansamples.jar, xalanservlet.jar, the
  user documentation, and the Javadoc API documentation. You need the source distribution to do builds. Keep in mind that if you have also
  downloaded the binary distribution, any builds you run will overwrite that binary distribution.</p>
<ul>
<li><link anchor="ant">Using Ant</link></li>
<li><link anchor="jar">Building xalan.jar</link></li>
<li><link anchor="samples">Building sample applications</link></li>
<li><link anchor="doc">Building the &xslt4j; documentation</link></li>
</ul>
<anchor name="ant"/>
   <s3 title="Using Ant">
     <p>Apache <resource-ref idref="ant"/> is a flexible, powerful, and easy-to-use Java build tool that we include with the
     &xslt4j; distribution. The Ant JAR file is in the bin directory, and the cross-platform XML build file (build.xml) is in 
     the root directory along with a Windows32 batch file (build.bat) and a UNIX shell file (build.sh). The build file defines 
     the "targets" that you can use Ant to build. The batch and shell files set up the classpath and launch Ant with the target 
     (and any other arguments) you provide.</p>
     <p><em>Instructions for using Ant</em></p>
     <ol>
       <li>Set the JAVA_HOME environment variable to the JDK root directory.<br/><br/>
       If you are using JDK 1.1.8, you must also put classes.zip in the JDK bin directory on the classpath. You can use Ant 
       with JDK 1.1.8 to compile and jar the &xslt4j; source files, but you must have JDK 1.2.2 or higher to build the
       documentation.<br/><br/></li>
       <li>Depending on your environment, run the batch file (build.bat) or shell file (build.sh) from the &xslt4j; root
       directory, optionally with arguments (see the table of targets below).<br/><br/>
       The batch/shell file adds several JAR files to the classpath and launches Ant with any arguments you provide. If you
       provide no target, Ant compiles the source files and rebuilds xalan.jar (the "jar" target).</li>
     </ol>
     <p>You can also set up your classpath manually (see build.bat or build.sh for the details), and then run Ant as
     follows:<br/><br/>
     <code>java org.apache.tools.ant.Main <ref>target</ref></code><br/><br/>
     where <ref>target</ref> is nothing (for the default target) or one of the following.</p>
     <table>
       <tr><td><em>Target</em></td><td><em>What Ant does</em></td></tr>
       <tr><td>compile</td><td>compiles &xslt4j; in build/classes.</td></tr>
       <tr><td>jar (the default)</td><td>creates xalan.jar in the build directory</td></tr>
       <tr><td>samples</td><td>compiles and jars the sample apps in build/xalansamples.jar</td></tr>
       <tr><td>servlet</td><td>compiles and jars the sample servlet in build/xalanservlet.jar</td></tr>       
       <tr><td>docs</td><td>creates the HTML User's Guide in build/docs</td></tr>
       <tr><td>javadocs</td><td>generates the API documentation in ./build/docs/apidocs</td></tr>
       <tr><td>dist</td><td>generates a complete distribution tree with zip and tar.gz distribution files in build</td></tr>
       <tr><td>clean</td><td>purges the build and distribution</td></tr> 
  </table>
  <p>If you build a target that depends on other targets, Ant creates those other targets in the correct order.</p>
   </s3><anchor name="jar"/> 
   <s3 title="Building &xslt4j;">
     <p>The &xslt4j; build is in xalan.jar. The &xslt4j; source code tree is in the src directory.</p>
     <p>If you are using Ant, the target is jar (the default). For more information, see <link anchor="ant">Using
     Ant</link>.</p>
     <p>If you want to do the build without Ant, keep the following in mind:</p>
     <ul>
     <li>Set the classpath to include the src directory, &xml4j-jar;, bsf.jar, and bsfengines.jar.</li>
     <li>Use a Java compiler (such as the IBM Just-In-Time compiler or the Sun javac) to compile all the .java files in the src
     tree. </li>
     <li>Use the Sun jar utility to store the resulting .class files in xalan.jar</li>
     </ul>
   </s3><anchor name="samples"/>
   <s3 title="Rebuilding a sample application">
   <p>If you modify a sample and want to recompile it, you can run the Java compiler in the directory containing the
   example. Be sure xalan.jar, xml-apis.jar, and &xml4j-jar; are on the classpath. To recompile (and run!) the class files in the
   Servlet subdirectory, the javax.servlet and javax.servlet.http packages must also be on the classpath. Sun
   distributes these packages in the JSWDK 1.0.1 servlet.jar file.</p> 
   <p>After recompiling a sample, you can use the Sun jar utility to place your new .class files in
    xalansamples.jar.</p>
    <p>You can use Ant with the samples target to recompile the samples and place the unpackaged class files in xalansamples.jar.
     For more information, see <link anchor="ant">Using Ant</link>.</p>
    <note>To rebuild (and to run) the sample servlet, the javax.servlet and javax.servlet.http packages must be on your
    classpath.</note>
   </s3><anchor name="doc"/>
   <s3 title="Rebuilding the &xslt4j; documentation">
     <p>&xslt4j; 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
      HTML User's Guide, and the overview and package-level documents used during the generation of Javadoc.</p>
      <p>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.</p>
      <p>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. For more information, see <link anchor="ant">Using Ant</link>.</p>
      <p>If you want to rebuild the documentation without using Ant, keep the following in mind:</p>
       <ul>
       <li>Unzip xml-site-style.tar.gz into the xdocs directory (the operation places files in a number of subdirectories).
       <br/><br/></li>
       <li>Be sure stylebook-1.0-b2.jar, xalan2jdoc.jar, xalan.jar, bsf.jar, bsfengines.jar, and &xml4j-jar; are on the class
       path.<br/><br/></li>
       <li>To build doc in a build/docs subdirectory, run StyleBook from the xdocs directory as follows:<br/><br/>
       <code>java org.apache.stylebook.StyleBook "targetDirectory=../build/docs/" sources/xalanLocal.xml style</code>
       <br/><br/></li>
       <li>To build the HTML source files that javadoc needs for the TrAX top-level and package-level documentation, add
       a build/docs/apdidocs/javax/xml/transform directory and run the Xalan command-line utility from the xdocs directory 
       as follows (all one line):<br/><br/>
<code>
java org.apache.xalan.xslt.Process 
  -in sources/trax/trax.xml
  -param package-root '../../../src/'
  -xsl style/stylesheets/spec.xsl 
  -out build/docs/apidocs/javax/xml/transform/trax.html</code><br/><br/></li>
        <li>Before you run javadoc, make sure the following directory structure exists under the Xalan root
         directory: build/docs/apidocs.<br/><br/></li>
       <li>To build the API documentation, run the JDK 1.2.2 javadoc tool from the xdocs directory (all one line):<br/><br/>
<code>
javadoc -doclet xalanjdoc.Standard 
 -docletpath ../bin/xalanjdoc.jar 
 -private
 -overview ../src/javadocOverview.html -sourcepath ../src 
 -group TrAX "javax.xml.transform*" 
 -group Xalan_Core "org.apache.xalan.processor:
        org.apache.xalan.templates:
 org.apache.xalan.transformer"
 -group XPath "org.apache.xpath*"
 -group Utilities "org.apache.xml.utils*"
 -group Xalan_Other "org.apache.xalan.client:
        org.apache.xalan.dtm:
 org.apache.xalan.extensions:org.apache.xalan.res:
 org.apache.xalan.stree:org.apache.xalan.trace:
 org.apache.xalan.xslt" 
 -group Xalan_Extensions "org.apache.xalan.lib*" 
 -group Serializers "org.apache.xalan.serialize" 
 org.apache.xalan.client org.apache.xalan.dtm 
 org.apache.xalan.extensions org.apache.xalan.lib 
 org.apache.xalan.lib.sql org.apache.xalan.processor 
 org.apache.xalan.res org.apache.xalan.stree 
 org.apache.xalan.templates org.apache.xalan.trace 
 org.apache.xalan.transformer org.apache.xalan.xslt 
 org.apache.xpath org.apache.xpath.axes 
 org.apache.xpath.compiler org.apache.xpath.functions 
 org.apache.xpath.objects org.apache.xpath.operations 
 org.apache.xpath.patterns org.apache.xpath.res
 org.apache.xalan.serialize javax.xml.transform  
 javax.xml.transform.dom javax.xml.transform.sax 
 javax.xml.transform.stream javax.xml.parsers
 -d ../build/docs/apidocs -windowtitle "&xslt4j; 2" 
 -doctitle "xslt4j; 2" -bottom "Copyright &#169; 
  2000 Apache XML Project. All Rights Reserved."
</code></li>
</ul>
  </s3>    
 </s2><anchor name="contact"/>
 <s2 title="Getting in Touch">
  <p>Your feedback is more than welcome. Offers of help are even more so! Perhaps you would like to take on an active role in the ongoing development, testing, and documentation of &xslt4j;?</p> 
<p>Please email your comments, questions, suggestions, and offers to join the Xalan team to <human-resource-ref idref="xalandev"/>.</p>
 </s2><anchor name="developer-list"/>
 <s2 title="Developers">
<p>A list of some of people currently working on working on &xslt4j;:</p>
  <!-- in alphabetical order, by last name -->
  <ul>
  <li><human-resource-ref idref="sboag"/>
    <br/>Xalan architect, lead developer on Xalan-J.
  </li>
  <li><human-resource-ref idref="scurcuru"/>
    <br/>Lead tester for API issues, automation framework.
  </li>
  <li><human-resource-ref idref="pdick"/>
    <br/>XSLT Conformance stylesheet issues and Xalan-C testing.
  </li>
  <li><human-resource-ref idref="jkesselman"/>
    <br/>Xalan-J developer, compiling/compiled stylesheets experiments.
  </li>
  <li><human-resource-ref idref="dleslie"/>
    <br/>Xalan-J and -C documentation, servlets, applets, and samples.
  </li>
  <li><human-resource-ref idref="cmanolache"/>
    <br/>Xalan-Jdeveloper and JAXP expert.
  </li>
  <li><human-resource-ref idref="dmarston"/>
    <br/>Lead tester for XSLT Conformance stylesheet issues.
  </li>
  <li><human-resource-ref idref="mmidy"/>
    <br/>Xalan-J  developer.
  </li>
  <li><human-resource-ref idref="gpeskin"/>
    <br/>Xalan-J developer, especially extension mechanisim.
  </li>
  <li><human-resource-ref idref="jgentilin"/>
    <br/>Major work on the SQL extensions library.
  </li>
 </ul>
 </s2>
</s1>