/*
    * The Apache Software License, Version 1.1
    *
    * Copyright (c) 1999, 2000 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 acknowlegement:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowlegement may appear in the software itself,
   *    if and wherever such third-party acknowlegements normally appear.
   *
   * 4. The names "The Jakarta Project", "Ant", 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 names without prior written
   *    permission of the Apache Group.
   *
   * 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.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   */
  
  package org.xrn.ant;
  
  import org.apache.tools.ant.*;
  import org.apache.tools.ant.taskdefs.email.EmailTask;
  import org.apache.tools.ant.types.FileSet;
  import org.apache.tools.ant.types.Path;
  import org.apache.tools.ant.types.XMLCatalog;
  import org.w3c.dom.*;
  import org.xml.sax.SAXException;
  
  import javax.xml.parsers.DocumentBuilder;
  import javax.xml.parsers.DocumentBuilderFactory;
  import javax.xml.parsers.FactoryConfigurationError;
  import javax.xml.parsers.ParserConfigurationException;
  import javax.xml.transform.*;
  import javax.xml.transform.dom.DOMResult;
  import javax.xml.transform.dom.DOMSource;
  import javax.xml.transform.stream.StreamResult;
  import javax.xml.transform.stream.StreamSource;
  import java.io.*;
  import java.lang.reflect.Constructor;
  import java.util.ArrayList;
  import java.util.StringTokenizer;
  import java.util.Vector;
  
  /***
   * This task enables to use the XMLReleaseNotes framework via Ant.
   * <div class="noteBlock">
   * If you need to use the XRN task, this is place of reference that exhaustively shows all features.
   * </div>
   * <h2>Version</h2>
   * <p>
   * This manual has been generated from the source code of <b>XRN V@XRN_VERSION@</b>. This documentation is extracted from
   * the source code, hence it should be up-to-date.
   * </p>
   * <div class="importantBlock">
   * This manual just explains the Ant XRN task, but is not a documentation on the XRN framework. You will find
   * such a documentation on the official web site of the XRN framework at
   * <a href="http://xmlreleasenotes.free.fr">http://xmlreleasenotes.free.fr</a>.
   * </div>
   *
   * <h2>A wrapper above XRN</h2>
   * <p>
   * The XMLReleaseNotes framework can also be used from the Ant world, thanks to this tiny wrapper task.
   * </p>
  * <h3>Declare the task</h3>
  * <p>
  * In order to use the Ant plug-in task, declare it via the
  * <pre class="code">
  * &lt;taskdef
  *   classname="org.xrn.ant.XMLReleaseNotes"
  *   name="XMLReleaseNotes"
  * /&gt;
  * </pre>
  * snippet. Later on, you will use the <code>XMLReleaseNotes</code> task.
  * </p>
  * <h3>Runtime requirements</h3>
  * <p>
  * There is a place where you will find this information back:
  * <a href="http://xmlreleasenotes.free.fr/MultipleReleaseNotes_top.html">XRN release notes</a>,
  * so you'd better to refer to them, in order to have fresh information. The "<i>requirements</i>" section of the
  * XRN version that you are currently using should be self explanatory.
  * </p>
  * <p>
  * However, here are roughly the components you need at runtime in order it to work properly (at least by version 0.17.2
  * of the framework).
  * <ul>
  * <li>Ant V1.5.0+: older versions will not work because the <code>XMLCatalog</code> class is used.</li>
  * <li>It is required that the Ant <code>lib</code> directory contains an XSLT implementation library
  * (like Xalan or Saxon, for instance) of the <code>javax.xml.transform.TransformerFactory</code> Java interface.</li>
  * </ul>
  * </p>
  *
  * <h2>The two-phases</h2>
  * <p>
  * This task processes two steps:
  * <ol>
  * <li>the enrichment operated on the XML XRN file via optional XSL transformations,</li>
  * <li>the rendering of the resulting XML into HTML.</li>
  * </ol>
  * The detailed description of this feature is beyond this manual. However, let's see to what elements these two
  * phases correspond to.
  * <a name="enrichment"/>
  * <h3>Enrichment</h3>
  * <p>
  * This first step is optional, and is handled by the inner <a href="#model"><code>model</code></a> XML elements.
  * You can define as many transformers that you want to.
  * </p>
  * <a name="rendering"/>
  * <h3>Rendering</h3>
  * <p>
  * </p>
  * <p>
  *
  * <a name="renderingFeature"/>
  * <h2>Two different types of rendering</h2>
  * <p>
  * The HTML renders pages can be generated by using two distinct modes, either compact or expanded.
  * </p>
  * <a name="compactRendering"/>
  * <h3>Compact rendering</h3>
  * <p>
  * In that mode, only one HTML file is rendered per component release notes. This is a compact mode.
  * </p>
  * <a name="expandedRendering"/>
  * <h3>Expanded rendering</h3>
  * <p>
  * This mode renders the release notes in a very likely Javadoc way. This involves that a HTML page is rendered for
  * every release of each component.
  * </p>
  * <div class="noteBlock">
  * This feature is activated as soon as more one
  * XRN file is provided to the task, or when the <a href="#singlePage"><code>singlePage</code><a> is disabled.
  * </div>
  *
  * <a name="supportedHTML"/>
  * <h2>HTML supported</h2>
  * <p>
  * Some attributes or elements of the task support textual information mixed with HTML tags. Every time this is the
  * case, the end-user is directed here.
  * </p>
  *
  * <a name="xsltResource"/>
  * <h2>XSLT resource</h2>
  * <p>
  * Some inner XML elements of the XRN task enable to refer to a XSLT style sheet file. When this is the case, you
  * have the choice to use:
  * <ul>
  * <li>either <code>xsl</code>: this specifies the path of this stylesheet file,</li>
  * <li>or <code>plugin</code>: this specifies the name of the XSLT plug-in to be used, present in the XRN jar,
  * under <code>XMLReleaseNotes/plugin</code> hierarchy.
  * When you use it, provide the name of the plug-in XSLT file, without the file extension. For example, if you
  * intend to use the version and type filter that is performed through the <code>XMLReleaseNotes/plugin/VersionAndTypeFilterModel.xsl</code>,
  * set this attribute to <code>VersionAndTypeFilterModel</code>.</li>
  * </ul>
  * <span class="note">The attribute defined first takes precedence over the second one, in case when you define both.</span>
  * </p>
  *
  * <h2><b>Important</b></h2>
  * <div class="warningBlock">
  * Here are some miscellaneous important matters.
  * </div>
  * <a name="xmlcatalog"/>
  * <h3><code>XMLCatalog</code> feature</h3>
  * <p>
  * This is a rather advanced feature, so, unless you use XSLT plug-in feature, you do not need to care about it.
  * </p>
  * <p>
  * This feature is used via in the following locations within the task:
  * <ul>
  * <li><a href="#model"><code>model</code></a>,</li>
  * <li><a href="#layout"><code>layout</code></a>,</li>
  * <li><a href="#pluginLayout"><code>pluginLayout</code></a>.</li>
  * </ul>
  * </p>
  * <p>
  * Said shortly, the <code>XMLCatalog</code> nested XML element acts like a URI resolver, which is very handy when it comes
  * to the numerous XSLT that occur at runtime.
  * </p>
  * <p>
  * In the previous XML blocks, you can add a single <code>XMLCatalog</code> inner XML element, so as to tell the XSLT
  * transformations where to find resources according to their public ID. In that case, insert the following block:
  * <pre class="code">
  * &lt;xmlcatalog&gt;
  *     &lt;entity
  *       publicId="SomePublicID"
  *       location="its_actual_URI"
  *     /&gt;
  *    ...
  * &lt;/xmlcatalog&gt;
  * </pre>
  * Use as many <code>entity</code> as you need.
  * </p>
  * <p>
  * This <a href="http://ant.apache.org/manual/CoreTypes/xmlcatalog.html"><code>XMLCatalog</code></a>
  * feature has been developed in the Ant framework. This feature is also used in the
  * <a href="http://ant.apache.org/manual/CoreTasks/style.html"><code>Xslt/Style</code></a>: do not hesitate to take a
  * look in the previous hyperlinks, in order to understand its purpose and how it works. <b>Moreover, there are lots of
  * examples of usage there.</b>
  * </p>
  *
  * <a name="mail"/>
  * <h3>Mail feature</h3>
  * <p>
  * This task is also the official Ant <a href="http://ant.apache.org/manual/CoreTasks/mail.html">Mail</a> task,
  * so that you can send eventually the release notes by mail. If the <code>mail</code> parameter is set to <code>yes</code>,
  * then the generated release notes will be sent as <code>text/html</code>: define the traditional Ant <code>Mail</code>
  * parameters, except the <code>message</code>, <code>messagefile</code>, <code>messagemimetype</code>, <code>files</code>
  * and <code>includefilenames</code>.
  * </p>
  * <p>
  * The mail sent will contain the <code>abstract</code> as subject, and the content of the mail will be the
  * generated release notes.
  * </p>
  *
  * <h2>Example</h2>
  * <p>
  * <pre class="code">
  * &lt;XMLReleaseNotes
  *   xml="ReleaseNotes.xml"
  * /&gt;
  * </pre>
  * will render the HTML for the XML release notes file <code>ReleaseNotes.xml</code>.
  * </p>
  *
  * @author Edouard Mercier
  * @version @XRN_VERSION@
  * @taskname XMLReleaseNotes
  * @since V0.3.2, 2004.04.01. Shift in the <code>org.xrn.ant</code> package from V0.18.0.
  */
 public class XMLReleaseNotes
   extends Task
 {
 
   /*private void log(String message, int level)
   {
 
   }
 
   private Project getProject()
   {
     return null;
   }*/
 
   /***
    * The XMLReleaseNotes XML file that describes the component release note.
    */
   private File _xml_release_notes_file = new File("XMLReleaseNotes.xml");
 
   /***
    * Remembers whether the user has provided explicitely an XML release notes file.
    */
   private boolean _xml_release_notes_file_defined = false;
 
   /***
    * Remembers whether the user has provided more than one XML release notes file.
    */
   private boolean _mutiple_xml_release_notes_file_defined = false;
 
   /***
    * <a name="xml"/>
    * Defines the XRN-compliant file that describes the component release notes.
    * <p>
    * All operations will be performed on that release notes file.
    * </p>
    * <div class="seeBlock">
    * See the <a href="#fileset"><code>fileset</code></a> inner element.
    * </div>
    *
    * @optional defaults to <code>XMLReleaseNotes.xml</code>, which means that the task will attempt to process this
    * single release notes file
    */
   public void setXML(File xml_release_notes_file)
   {
     _xml_release_notes_file_defined = true;
     _xml_release_notes_file = xml_release_notes_file;
   }
 
   private String _xslt_transformer_factory_class_name = null;
 
   /***
    * Defines the Fully Qualified Name (FQN) of the XLST <code>TransformerFactory</code> class that will be used for
    * all transformations.
    * <p>
    * This will set the Java system property <code>javax.xml.transform.TransformerFactory</code> with the implementation
    * of interface <code>javax.xml.transform.TransformerFactory</code>.
    * </p>
    *
    * @optional the default implementation found in the classpath. <span class="warning">With the Sun JRE V1.4, it appears
    * that this Java system property is not always defined. For instance, define this property with
    * <code>org.apache.xalan.processor.TransformerFactoryImpl</code>, if you are using the Xalan V2 implementation.</span>
    */
   public void setProcessor(String xslt_transformer_factory_class_name)
   {
     _xslt_transformer_factory_class_name = xslt_transformer_factory_class_name;
   }
 
   /***
    * @return <code>true</code> if the current XSLT implementation is Xalan.
    */
   private boolean isUsingXalanImplementation()
   {
     final String xslt_implementation_fqn = getActualTransformerFactory();
     if (xslt_implementation_fqn.lastIndexOf("xalan") != -1)
     {
       return true;
     }
     else
     {
       return false;
     }
   }
 
   /***
    * The vector of {@link org.apache.tools.ant.types.FileSet} that defines all the XRN file sets that should be handled.
    */
   private Vector _fileset_vector = new Vector();
 
   /***
    * <a name="fileset"/>
    * <span class="important">As many occurrences of this element are allowed.</span>
    * Enables to define multiple XRN release notes files at the same time. In that case, the task will handle
    * all the release notes files declared hereby. It is supposed that all provided files are XRN-compliant release
    * notes file. If one is not, the task will fail.
    * <div class="warning">
    * When defined, the <a href="#xml"><code>xml<code></a> attribute is not taken into account.
    * </div>
    * <div class="noteBlock">
    * This XML element is the Ant <a href="http://ant.apache.org/manual/CoreTypes/fileset.html"><code>fileset</code></a> feature.
    * This same element is being used in the Ant <a href="http://ant.apache.org/manual/CoreTasks/copy.html"><code>copy</code></a> task.
    * </div>
    * <div class="seeBlock">
    * Read this <a href="#renderingFeature">section</a> for additional information.
    * </div>
    *
    * @optional when used, the generated HTML will contain the release notes of all the underlying components
    */
   public Object createFileSet()
   {
     _mutiple_xml_release_notes_file_defined = true;
     FileSet file_set = new FileSet();
     _fileset_vector.add(file_set);
     return file_set;
   }
 
   private Path _xslt_path = null;
 
   /***
    * <a name="XSLTPath"/>
    * <div class="importantBlock">
    * This feature is only relevant when the XSLT implementation lives outside from the Ant <code>lib</code> directory.
    * </div>
    * Indicates to Ant where the XSLT implementation jar file(s) required at runtime are located.
    *
    * @optional when the XSLT implementation to use is not in ant <code>lib</code> directory, provide its jar file
    * path via this element
    */
   public Object createXSLTPath()
   {
     _xslt_path = new Path(getProject());
     return _xslt_path;
   }
 
   private Path _uri_resolver_path = null;
 
   /***
    * <a name="URIResolverPath"/>
    * <div class="importantBlock">
    * This feature is only relevant when the XRN task jar file(s) lives outside from the Ant <code>lib</code> directory,
    * and thus that you declared it via the <code>typedef/taskdef</code> task, with a properly defined classpath.
    * </div>
    * Indicates to Ant where the internal resources (<code>.xsl</code>, for the most) that are required at runtime are
    * located. Those resources are present in the XRN Ant task jar file, so you only need to refer to this file.
    * <div class="exampleBlock">
    * Example:
    * <pre>
    * &lt;URIResolverPath&gt;
    *   &lt;pathelement location="&lt;the path to&gt;/XMLReleaseNotes.jar"/&gt;
    * &lt;/URIResolverPath&gt;
    * </pre>
    * </div>
    *
    * @optional when the XRN Ant task jar file is not in Ant <code>lib</code> directory,
    * put this jar into this classpath
    */
   public Object createURIResolverPath()
   {
     _uri_resolver_path = new Path(getProject());
     return _uri_resolver_path;
   }
 
   /***
    * Remembers the array of all XRN files implied in the process.
    */
   private File[] _xrn_file_array = null;
 
   /***
    * @return the raw array of all XRN files concerned and defined by the user
    */
   private File[] getXRNFiles()
   {
     if (_xrn_file_array == null)
     {
       if (_fileset_vector.size() > 0)
       {
         Vector file_vector = new Vector();
         // Iterates over the Ant buildfiles
         for (int index = 0; index < _fileset_vector.size(); index++)
         {
           FileSet file_set = (FileSet) _fileset_vector.elementAt(index);
           File directory = file_set.getDir(getProject());
           DirectoryScanner directory_scanner = file_set.getDirectoryScanner(getProject());
           String[] included_file_array = directory_scanner.getIncludedFiles();
           for (int file_index = 0; file_index < included_file_array.length; file_index++)
           {
             String file_name = included_file_array[file_index];
             File file = new File(directory, file_name);
             file_vector.add(file);
           }
         }
         _xrn_file_array = new File[file_vector.size()];
         file_vector.toArray(_xrn_file_array);
       }
       else
       {
         _xrn_file_array = new File[1];
         _xrn_file_array[0] = _xml_release_notes_file;
       }
     }
     return _xrn_file_array;
   }
 
   private File _destination_directory = new File(".");
 
   /***
    * <a name="destination"/>
    * Defines the path of the directory where all generated stuff will be generated into.
    *
    * @optional <code>.</code> (i.e., the current Ant buildfile <code>basedir</code> directory)
    */
   public void setDestination(File destination_directory)
   {
     _destination_directory = destination_directory;
   }
 
   private String _html_release_notes_file_name = new String("XMLReleaseNotes.html");
 
   /***
    * Defines the name (<span class="warning">and not the path!</span>) of the main rendered HTML page.
    * <div class="warningBlock">
    * <p>
    * This is the HTML page to be opened in order to browse the rendered HTML release notes.
    * </p>
    * This attribute is ignored if the <a href="#expandedRendering">expanded-rendering</a> feature is disabled.
    * </div>
    *
    * @optional defaults to <code>XMLReleaseNotes.html</code>
    */
   public void setHTML(String html_release_notes_file_name)
   {
     _html_release_notes_file_name = html_release_notes_file_name;
   }
 
   private Boolean _stand_alone_html = new Boolean(true);
 
   private Boolean _single_page = new Boolean(true);
 
   /***
    * <a name="singlePage"/>
    * <div class="importantBlock">
    * This attribute only makes sense when the inner <a href="#fileset"><code>fileset</code></a> element is not used.
    * </div>
    * Tells whether a single HTML page or multiple HTML pages should be generated for the component release notes.
    * <p>
    * This is handy when you want your rendered release notes to be encompassed in a single HTML file.
    * </p>
    * <div class="noteBlock">
    * Read this <a href="#renderingFeature">section</a> for additional information.
    * </div>
    *
    * @optional defaults to <code>yes</code>. When set to <code>yes</code>, only one HTML page is being generated for
    * the release notes
    */
   public void setSinglePage(Boolean single_page)
   {
     _single_page = single_page;
   }
 
   private boolean useTheMultiplePagesXSLT()
   {
     return (_single_page.booleanValue() == false || _mutiple_xml_release_notes_file_defined == true);
   }
 
   private Boolean _use_icons = null;
 
   /***
    * <div class="warningBlock">
    * This feature is still at its early stages and is still experimental.
    * </div>
    * Indicates whether the generated HTML pages should contains icons or not.
    *
    * @optional defaults to <code>no</code>
    */
   public void setUseIcons(Boolean use_icons)
   {
     _use_icons = use_icons;
   }
 
   /***
    * The CSS file to be used within the generated HTML pages. This CSS must conform to the default CSS style sheet format.
    */
   private File _css_file = null;
 
   /***
    * <a name="css"/>
    * Defines the path of the CSS file to be used within the generated HTML pages. This offers the opportunity to
    * customize the rendered release notes layout. Copy and paste the default CSS, then modify its CSS selectors
    * in order to customize the HTML rendering.
    * <p>
    * This file will be copied at the root of the <a href="#destination"><code>destination</code></a> directory with
    * the name <code>stylesheet.css</code>.
    * </p>
    * <div class="note">
    * This CSS must conform to the default CSS style sheet format.
    * </div>
    *
    * @optional the default XRN CSS style sheet (present under <code>XMLReleaseNotes/XMLReleaseNotes.css</code>)
    * embedded in the jar will be used
    */
   public void setCSS(File css_file)
   {
     _css_file = css_file;
   }
 
   private Boolean _inline_css = new Boolean(false);
 
   /***
    * Tells whether the generated HTML pages should inline the CSS content or not.
    * <p>
    * When enabled, the CSS will be embedded in the generated HTML, so that HTML the release notes is
    * stand-alone (the CSS style sheet will not be copied in the <a href="#destination"><code>destination</code></a> directory).
    * This is especially handy when you do not want to make a reference to another file inside the generated HTML.
    * </p>
    *
    * @optional defaults to <code>no</code>. When set to <code>yes</code>, the generated page will embed the CSS content
    */
   public void setInlineCSS(Boolean inline_css)
   {
     _inline_css = inline_css;
   }
 
   private String _abstract_string = "";
 
   /***
    * Enables to define an abstract for the generated main HTML page, that will be displayed at the top of the release notes.
    * <p>
    * This is an opportunity to provide some overall explanation about the release notes themselves.
    * </p>
    * <div class="note">
    * This element supports <a href="#supportedHTML">HTML tags</a>.
    * </div>
    *
    * @optional empty, by default
    */
   public void setAbstract(String abstract_string)
   {
     _abstract_string = abstract_string;
   }
 
   private Boolean _check_xml_validity = new Boolean(false);
 
   /***
    * Indicates whether the XML input release notes should be tested against its XML schema.
    * <p>
    * This enables to check that your XRN release notes are compliant with the framework (and all the more that the
    * file is well formed).
    * </p>
    *
    * @optional defaults to <code>no</code>. When set to <code>yes</code>, the release notes files are being tested
    * validated
    */
   public void setCheckValidity(Boolean check_validity)
   {
     _check_xml_validity = check_validity;
   }
 
   private Boolean _show_banner = new Boolean(true);
 
   /***
    * Tells whether the generated HTML pages should present an advertising footer banner for the XRN framework.
    * <div class="noteBlock">
    * If you want to promote the framework, you should consider letting this on.
    * </div>
    *
    * @optional defaults to <code>yes</code>. When set to <code>no</code>, the XRN bottom banner is not displayed
    */
   public void setBanner(Boolean show_banner)
   {
     _show_banner = show_banner;
   }
 
   /***
    * A class that enables to express HTML code.
    */
   public class HTML
   {
 
     protected String text = null;
 
     public HTML(String text)
     {
       addText(text);
     }
 
     /***
      * Convenience method in order to expand the inner text against the possible enclosed properties.
      */
     private String expand(String content)
     {
       return ProjectHelper.replaceProperties(project, content, project.getProperties());
     }
 
     public String getText()
     {
       return ((text != null) ? expand(text) : "");
     }
 
     public void addText(String text)
     {
       this.text = text;
     }
   }
 
   private HTML _title = null;
 
   /***
    * <span class="important">Only one occurrence of this element is allowed.</span>
    * <div class="warningBlock">
    * This element is ignored if the <a href="#expandedRendering">expanded-rendering</a> feature is not enabled.
    * </div>
    * This title will be used on the HTML first page (the one that displays all components).
    * <p>
    * It enables to display extra personal information about the generated documentation.
    * </p>
    * <div class="note">
    * This element supports <a href="#supportedHTML">HTML tags</a>.
    * </div>
    *
    * @optional if not defined, no special title will be used
    */
   public Object createTitle()
   {
     _title = new HTML("");
     return _title;
   }
 
   private HTML _header = null;
 
   /***
    * <span class="important">Only one occurrence of this element is allowed.</span>
    * <div class="warningBlock">
    * This element is ignored if the <a href="#expandedRendering">expanded-rendering</a> feature is not enabled.
    * </div>
    * This header will be displayed on multi-components HTML pages.
    * <div class="note">
    * This element supports <a href="#supportedHTML">HTML tags</a>.
    * </div>
    *
    * @optional if not defined, no header will be inserted
    */
   public Object createHeader()
   {
     _header = new HTML("");
     return _header;
   }
 
   private HTML _footer;
 
   /***
    * <span class="important">Only one occurrence of this element is allowed.</span>
    * <div class="warningBlock">
    * This element is ignored if the <a href="#expandedRendering">expanded-rendering</a> feature is not enabled.
    * </div>
    * This footer will be displayed on multi-components HTML pages.
    * <div class="note">
    * This element supports <a href="#supportedHTML">HTML tags</a>.
    * </div>
    *
    * @optional if not defined, no footer will be inserted
    */
   public Object createFooter()
   {
     _footer = new HTML("");
     return _footer;
   }
 
   private Boolean _deploy = new Boolean(false);
 
   /***
    * A boolean attribute that indicates whether the task just needs to deploy the XRN main resources:
    * for instance, the default <a href="#css">CSS style sheet</a> will be copied,
    * as well as the XRN <code>XMLReleaseNotes.xsd</code> schema file.
    * <p>
    * This is a helper that extracts all the necessary resources from the jar file. The deployed resources will be copied
    * into the <a href="#destination"><code>destination</code></a> directory.
    * </p>
    * <div class="note">
    * When enabled, no other processing than deploying the XRN framework main resources will be performed.
    * </div>
    *
    * @optional defaults to <code>no</code>. When set to <code>yes</code>, the task will only deploy the XRN framework
    * resources
    */
   public void setDeploy(Boolean deploy)
   {
     _deploy = deploy;
   }
 
   /***
    * A class that enables to express an XSL transformation.
    */
   public class XSLT
   {
 
     private File xslFile = null;
 
     /***
      * The path of the XSLT file to be used.
      *
      * @param xsl_file the <code>.xsl</code> file that will be used for the transformation
      */
     public void setXSL(File xsl_file)
     {
       if (pluginName != null)
       {
         log("The XSL file is already defined via the 'plugin' attribute: " +
           "the xsl (defined by the 'xsl' attribute) will not be taken into account", Project.MSG_WARN);
       }
       xslFile = xsl_file;
     }
 
     private String pluginName = null;
 
     /***
      * The name of the plugin to be used.
      *
      * @param plugin_name the name of the plugin within the jar that will be used
      */
     public void setPlugin(String plugin_name)
     {
       if (xslFile != null)
       {
         log("The XSL file is already defined via the 'xsl' attribute: " +
           "the plugin name (defined by the 'plugin' attribute) will not be taken into account", Project.MSG_WARN);
       }
       else
       {
         pluginName = plugin_name;
       }
     }
 
     /***
      * @return the underling XSLT input stream
      * @throws org.apache.tools.ant.BuildException if the input cannot be found
      */
     public InputStream getXSLTStream()
       throws BuildException
     {
       InputStream input_stream = null;
       String location = null;
       if (xslFile != null)
       {
         input_stream = getInputStream(xslFile);
       }
       else
       {
         location = plugin_common_prefix + pluginName + ".xsl";
         input_stream = getClass().getClassLoader().getResourceAsStream(location);
       }
       checkInputStream(input_stream, getXSLTLocation());
       return input_stream;
     }
 
     /***
      * @return the underling XSLT input stream
      * @throws org.apache.tools.ant.BuildException if the input cannot be found
      */
     public String getXSLTLocation()
       throws BuildException
     {
       if (xslFile != null)
       {
         return xslFile.getAbsolutePath();
       }
       else
       {
         return plugin_common_prefix + pluginName + ".xsl";
       }
     }
 
     private XMLCatalog uriResolver = null;
 
     /***
      * Acts as an URI resolver concerning the possible XSL transformation. When some URI resolution is needed during
      * this transformation, the task will use this catalog (see the Ant
      * <a href="http://ant.apache.org/manual/CoreTypes/xmlcatalog.html">XMLCatalog</a> for more information).
      *
      * @param xml_catalog the catalog that will be used during the XSL transformation, if necessary
      * @optional the default XSLT implementation URI resolver is used
      */
     public void addXMLCatalog(XMLCatalog xml_catalog)
     {
       uriResolver = xml_catalog;
     }
 
     /***
      * Copied from the {@link  org.apache.tools.ant.taskdefs.XSLTProcess.Param} class: acts as a parameter wrapper
      */
     public class Param
     {
 
       public void setName(String name)
       {
         this.name = name;
       }
 
       public void setExpression(String expression)
       {
         this.expression = expression;
       }
 
       public String getName()
         throws BuildException
       {
         if (name == null)
           throw new BuildException("Name attribute is missing.");
         else
           return name;
       }
 
       public String getExpression()
         throws BuildException
       {
         if (expression == null)
           throw new BuildException("Expression attribute is missing.");
         else
           return expression;
       }
 
       private String name;
       private String expression;
 
       public Param()
       {
         name = null;
         expression = null;
       }
     }
 
     private Vector parameterVector = new Vector();
 
     /***
      * Enables to add XSLT additional parameters (see the Ant
      * <a href="http://ant.apache.org/manual/CoreTypes/xslt.html">XSLT</a> task for more information).
      *
      * @return the parameters (and their value) that will be provided to the XSL transformation
      * @optional no parameters other than the ones defined in the default XSLT layout transformation
      */
     public Param createParam()
     {
       Param parameters = new Param();
       parameterVector.add(parameters);
       return parameters;
     }
 
   }
 
   /***
    * The vector of all user-specified model XSLT.
    */
   private Vector _model_xslt_vector = new Vector();
 
   /***
    * <a name="model"/>
    * <span class="important">As many occurrences of this element are allowed.</span>
    * Defines a additional XSL transformations to be applied on the XML input. The result of the transformation should
    * be some XRN-compliant XML file.
    * The XSL transformations will be applied in the same order as they are declared, from top to bottom.
    * <div class="noteBlock">
    * Read <a href="#xsltResource">this explanation</a> in order to understand how to express the XSLT that should be used.
    * </div>
    * <p>
    * This enables to provide multiple XSLT that aggregate information coming from another XML sources. This is part
    * of the <a href="#enrichment">enrichment</a> step.
    * </p>
    * <p>
    * If not defined, no preliminary XSL transformation is performed on the XML input release notes files;
    * the <a href="#layout"><code>layout</code></a> parameter is also ignored in this case.
    * </p>
    * <div class="noteBlock">
    * This element supports the <a href="#xmlcatalog"><code>XMLCatalog</code></a> inner XML element, that acts as a
    * URI resolver. Follow the previous link in order to understand what this is about.
    * </div>
    *
    * @optional
    */
   public Object createModel()
   {
     XSLT xslt = new XSLT();
     _model_xslt_vector.add(xslt);
     return xslt;
   }
 
   private XSLT _layout_xslt = null;
 
   /***
    * <a name="layout"/>
    * <span class="important">Only one occurrence of this element is allowed.</span>
    * Defines the XSL transformation that renders into HTML the XML release notes input.
    * <p>
    * The idea is to provide an XSLT that extends the <code>XMLReleaseNotes2HTML.xsl</code> default rendering so as to
    * take into account the new model information present in the input XML. This XSL will be given the same parameters
    * as the default ones. This is part of the <a href="#layout">layout</a> step.
    * </p>
    * <div class="noteBlock">
    * Read <a href="#xsltResource">this explanation</a> in order to understand how to express the XSLT that should be used.
    * </div>
    * <p>
    * If not defined, the usual XSL transformation renderer is used.
    * </p>
    * <div class="noteBlock">
    * This element supports the <a href="#xmlcatalog"><code>XMLCatalog</code></a> inner XML element, that acts as a
    * URI resolver. Follow the previous link in order to understand what this is about.
    * </div>
    *
    * @optional
    */
   public Object createLayout()
   {
     _layout_xslt = new XSLT();
     return _layout_xslt;
   }
 
   private XSLT _plugin_layout_xslt = null;
 
   /***
    * <a name="pluginLayout"/>
    * <span class="important">Only one occurrence of this element is allowed.</span>
    * <div class="warningBlock">
    * This element is ignored if the <a href="#expandedRendering">expanded-rendering</a> feature is not enabled.
    * </div>
    * Defines the XSLT layout plugin that should be used when it comes to the rendering into HTML.
    * <p>
    * The idea is to provide an XSLT that extends the <code>XRN2HTMLPlugin.xsl</code> default rendering.
    * </p>
    * <div class="noteBlock">
    * Read <a href="#xsltResource">this explanation</a> in order to understand how to express the XSLT that should be used.
    * </div>
    * <p>
    * This XSL will be given the same parameters as the default ones.
    * </p>
    * <div class="noteBlock">
    * This element supports the <a href="#xmlcatalog"><code>XMLCatalog</code></a> inner XML element, that acts as a
    * URI resolver. Follow the previous link in order to understand what this is about.
    * </div>
    *
    * @optional
    */
   public Object createPluginLayout()
   {
     _plugin_layout_xslt = new XSLT();
     return _plugin_layout_xslt;
   }
 
   private EmailTask _mail = null;
 
   /***
    * <span class="important">Only one occurrence of this element is allowed.</span>
    * Enables to send an e-mail at the end of the XSL layout final transformation.
    * <p>
    * If not defined, no e-mail will be sent. Otherwise, use this usual <code>mail</code> built-in Ant task
    * in order to define the e-mail inputs.
    * </p>
    * <div class="important">
    * <a href="#mail">Read this</a> some more explanation.
    * </div>
    *
    * @optional if not defined, no e-mail will be sent. Otherwise, use this usual <code>mail</code> built-in Ant task
    * in order to define the e-mail inputs. See <a href="#mail">the explaining at the top</a>
    */
   public Object createMail()
   {
     _mail = new EmailTask();
     return _mail;
   }
 
   private Boolean _migrate = new Boolean(false);
 
   /***
    * <a name="migrate"/>
    * Indicates that you want to perform a migration of the XRN input release notes files from their declared XRN framework version
    * into the current XRN version.
    * <span class="important">In that case, the release notes files must be writable, since they may be overwritten.</span>
    * <p>
    * For every XRN release note file concerned, the task will attempt to perform the necessary migration from the
    * version of the XRN declared via the <code>ReleaseNotes/@version</code> attribute, into the version of the present XRN task.
    * </p>
    * <div class="warningBlock">
    * When enabled, the rest of the standard processing is not performed.
    * </div>
    *
    * @optional defaults to <code>no</code>. When set to <code>yes</code>, if a migration is necessary, it is performed
    */
   public void setMigrate(Boolean migrate)
   {
     _migrate = migrate;
   }
 
   private Boolean _implicit_migration = new Boolean(false);
 
   /***
    * Indicates whether implicit XRN migration should be applied if necessary. This does not stop the process once the
    * implicit migration has been applied.
    * <p>
    * When your XRN release notes files are outdated compared to the XRN version of the Ant XRN task that you are
    * currently using, you can ask the task to first migrate (via the integrated <a href="#migrate">migration</a> feature)
    * your release notes, and then only, continue the standard process.
    * </p>
    *
    * @optional defaults to <code>no</code>. When set to <code>yes</code> implicit migration is performed
    */
   public void setImplicitlyMigrate(Boolean implicit_migration)
   {
     _implicit_migration = implicit_migration;
   }
 
   private Boolean _debug = new Boolean(false);
 
   /***
    * For internal purpose only. Triggers the debug behavior.
    * <div class="warningBlock">
    * This feature is not supposed to be used by persons not developing for the XRN framework, unless explicetly asked for.
    * </div>
    *
    * @optional default to <code>no</code>. Set it to <code>yes</code> only provided you know what you are doing!
    */
   public void setDebug(Boolean debug)
   {
     _debug = debug;
   }
 
   /***
    * Checks that the provided parameters are OK.
    *
    * @throws org.apache.tools.ant.BuildException if some of them will result in a fatal error
    */
   private void checkParameters()
     throws BuildException
   {
     if (_show_banner.booleanValue() == false)
     {
       log("------------<(-: Is that sure that you really want to disable the banner? ;->>------------", Project.MSG_WARN);
     }
     if (_deploy.booleanValue() == false)
     {
       File[] xrn_file_array = getXRNFiles();
       for (int index = 0; index < xrn_file_array.length; index++)
       {
         File xrn_file = xrn_file_array[index];
         if (xrn_file.isFile() == false)
         {
           throw new BuildException("There is no XML release notes file '" + xrn_file.getAbsolutePath() + "': " +
             "cannot generate the release notes layout");
         }
       }
     }
     for (int index = 0; index < _model_xslt_vector.size(); index++)
     {
       XSLT xslt = (XSLT) _model_xslt_vector.elementAt(index);
       if (xslt != null)
       {
         if (xslt.xslFile == null && xslt.pluginName == null)
         {
           throw new BuildException("The 'xsl' and 'plugin' attributes of the 'model' inner element cannot both be null");
         }
       }
     }
     if (_layout_xslt != null)
     {
       if (_layout_xslt.xslFile == null)
       {
         throw new BuildException("The 'xsl' attribute of the 'layout' inner element cannot be null");
       }
     }
     if (_mail != null)
     {
       if (_inline_css.booleanValue() == false)
       {
         log("Beware, you chose to send an e-mail with the release notes, but you did not chose to inline the CSS " +
           "content via the 'inlineCSS' parameter, so that the e-mail HTML content will miss it!", Project.MSG_WARN);
       }
     }
   }
 
   /***
    * @return the XRN version this element belongs to
    */
   public String getXRNVersion()
   {
     return "@XRN_VERSION@";
   }
 
   public void execute()
     throws BuildException
   {
     log("Running XRN V" + getXRNVersion(), Project.MSG_VERBOSE);
     // We check that the inputs are OK
     checkParameters();
 
     logRuntimeInformation();
 
     if (_deploy.booleanValue() == false)
     {
       if (_migrate.booleanValue() == true)
       {
         performMigrationIfNecessary(true);
         return;
       }
       if (_implicit_migration.booleanValue() == true)
       {
         performMigrationIfNecessary(false);
       }
       if (_check_xml_validity.booleanValue() == true)
       {
         checkXMLValidity();
       }
       generateReleaseNotes();
       // If a mail sending has been ask for, do it
       if (_mail != null)
       {
         sendMail();
       }
     }
     else
     {
       deploy();
     }
   }
 
   /***
    * Logs the current runtime environment, so that it is possible to debug more easily the task, especially as far
    * as XSLT is concerned.
    */
   protected void logRuntimeInformation()
   {
     log("The 'java.class.path' is currently set to '" + System.getProperty("java.class.path", "Error") + "'", Project.MSG_DEBUG);
   }
 
   /***
    * Scans all XRN files and perform a migration on them if necessary.
    *
    * @param in_situ indicates whether the XRN files should be migrated in situ, or in a temporary file
    * @see #performMigrationIfNecessaryForXRNFile
    */
   private void performMigrationIfNecessary(boolean in_situ)
     throws BuildException
   {
     File[] xrn_file_array = getXRNFiles();
     if (in_situ == true)
     {
       for (int index = 0; index < xrn_file_array.length; index++)
       {
         File xrn_file = xrn_file_array[index];
         performMigrationIfNecessaryForXRNFile(xrn_file, xrn_file);
       }
     }
     else
     {
       for (int index = 0; index < xrn_file_array.length; index++)
       {
         File xrn_file = xrn_file_array[index];
         File temporary_file = null;
         try
         {
           temporary_file = File.createTempFile("XRNMigrated", ".xml");
           performMigrationIfNecessaryForXRNFile(xrn_file, temporary_file);
           log("You can view the migrated XRN file '" + xrn_file.getAbsolutePath() + "' in the file '" +
             temporary_file.getAbsolutePath() + "'", Project.MSG_INFO);
           _xrn_file_array[index] = temporary_file;
         }
         catch (IOException io_exception)
         {
           throw new BuildException("Cannot create a temporary file in order to store the migrated XRN file '" +
             xrn_file.getAbsolutePath() + "': cannot continue");
         }
       }
     }
   }
 
   /***
    * Checks whether a migration is required on the XML release notes file, and then performs it if necessary.
    *
    * @param xrn_file the XRN file than may be migrated
    * @param output_file the file the migrated XRN file will be saved into
    * @throws org.apache.tools.ant.BuildException if the migration failed for any reason
    */
   private void performMigrationIfNecessaryForXRNFile(File xrn_file, File output_file)
     throws BuildException
   {
     log("You asked that a migration of the XML release notes file '" + xrn_file.getAbsolutePath() + "' be " +
       "performed if necessary", Project.MSG_INFO);
     Document document = getXMLDocumentFromXRNFile(xrn_file);
     String version = "0.3.2";
     if (document.getDocumentElement().hasAttribute("version") == true)
     {
       version = document.getDocumentElement().getAttribute("version");
       if (version.equals(getXRNVersion()) == true)
       {
         log("No XML file migration is required", Project.MSG_INFO);
         return;
       }
     }
     // In that case, some migration is required
     log("Some migration is required, since the version of the XML release notes file is '" + version + "' " +
       "and that the current XRN version is '" + getXRNVersion() + "'", Project.MSG_INFO);
     runNecessaryMigrationXSLT(xrn_file, output_file, version);
   }
 
   /***
    * Gets the DOM document of the provided XRN file.
    *
    * @param xrn_file the XRN file the DOM is being asked for
    * @return the DOM of the XML file
    * @throws org.apache.tools.ant.BuildException if the file is not XML-well-formed, or if it cannot be parsed
    */
   private Document getXMLDocumentFromXRNFile(File xrn_file)
     throws BuildException
   {
     DocumentBuilder document_builder = createADocumentBuilder();
     Document document = null;
     try
     {
       document = document_builder.parse(xrn_file);
     }
     catch (SAXException sax_exception)
     {
       throw new BuildException("Cannot parse properly the file '" + xrn_file.getAbsolutePath() + "', " +
         "which is supposed to be under the XML format");
     }
     catch (IOException io_exception)
     {
       throw new BuildException("Error while reading the file '" + xrn_file.getAbsolutePath() + "'");
     }
     return document;
   }
 
   /***
    * @return a newly created document builder
    * @throws org.apache.tools.ant.BuildException if the runtime cannot create such a builder
    */
   private DocumentBuilder createADocumentBuilder()
     throws BuildException
   {
     DocumentBuilder document_builder = null;
     try
     {
       DocumentBuilderFactory document_builder_factory = DocumentBuilderFactory.newInstance();
       document_builder_factory.setNamespaceAware(true);
       // We disable the validation, since it reports numerous unindentified problems
       document_builder_factory.setValidating(false);
       document_builder = document_builder_factory.newDocumentBuilder();
     }
     catch (ParserConfigurationException parser_configuration_exception)
     {
       throw new BuildException("Cannot create an XML document builder", parser_configuration_exception);
     }
     catch (FactoryConfigurationError factory_configuration_error)
     {
       throw new BuildException("Cannot create an XML document builder", factory_configuration_error);
     }
     return document_builder;
   }
 
   /***
    * @param version_string the version string to be analyzed
    * @return a version-increasing number that so that it should be greater with a later version compared to a earlier version
    */
   private long getVersionAsNumber(String version_string)
   {
     long version = 0;
     StringTokenizer tokenizer = new StringTokenizer(version_string, ".");
     while (tokenizer.hasMoreElements() == true)
     {
       version *= 1000;
       version += new Integer((String) tokenizer.nextElement()).intValue();
     }
     return version;
   }
 
   /***
    * The method that actually performs all necessary migrations on the XML release notes file.
    *
    * @param xrn_file the XRN file the migration should be applied to
    * @param output_file the file the migrated XRN file will be saved into
    * @param original_version the original XRN version of the file
    */
   private void runNecessaryMigrationXSLT(File xrn_file, File output_file, String original_version)
     throws BuildException
   {
     InputStream xml_input_stream = null;
     Vector input_stream_vector = new Vector();
     try
     {
       xml_input_stream = new FileInputStream(xrn_file);
       input_stream_vector.add(xml_input_stream);
     }
     catch (FileNotFoundException file_not_found_exception)
     {
       // This should not happen because of the preliminar checks
       throw new BuildException("Cannot find the file '" + xrn_file + "'", file_not_found_exception);
     }
     File temporary_file = null;
     Vector temporary_file_vector = new Vector();
     long original_version_number = getVersionAsNumber(original_version);
     try
     {
       if (original_version_number < getVersionAsNumber("0.3.3"))
       {
         temporary_file = File.createTempFile("XRNMigration", ".xml");
         temporary_file_vector.add(temporary_file);
         runMigration("0.3.3", "XMLReleaseNotesConvertorV0.3.2-0.3.3.xsl", xml_input_stream, new FileOutputStream(temporary_file));
         xml_input_stream = new FileInputStream(temporary_file);
         input_stream_vector.add(xml_input_stream);
       }
       if (original_version_number < getVersionAsNumber("0.6.2"))
       {
         temporary_file = File.createTempFile("XRNMigration", ".xml");
         temporary_file_vector.add(temporary_file);
         runMigration("0.6.2", "XMLReleaseNotesConvertorV0.6.1-0.6.2.xsl", xml_input_stream, new FileOutputStream(temporary_file));
         xml_input_stream = new FileInputStream(temporary_file);
         input_stream_vector.add(xml_input_stream);
       }
       if (original_version_number < getVersionAsNumber("0.6.4"))
       {
         temporary_file = File.createTempFile("XRNMigration", ".xml");
         temporary_file_vector.add(temporary_file);
         runMigration("0.6.4", "XMLReleaseNotesConvertorV0.6.2-0.6.4.xsl", xml_input_stream, new FileOutputStream(temporary_file));
         xml_input_stream = new FileInputStream(temporary_file);
         input_stream_vector.add(xml_input_stream);
       }
       if (original_version_number < getVersionAsNumber("0.14.0"))
       {
         temporary_file = File.createTempFile("XRNMigration", ".xml");
         temporary_file_vector.add(temporary_file);
         runMigration("0.14.0", "XMLReleaseNotesConvertorV0.13.0-0.14.0.xsl", xml_input_stream, new FileOutputStream(temporary_file));
         xml_input_stream = new FileInputStream(temporary_file);
         input_stream_vector.add(xml_input_stream);
       }
       if (original_version_number < getVersionAsNumber("0.18.0"))
       {
         temporary_file = File.createTempFile("XRNMigration", ".xml");
         temporary_file_vector.add(temporary_file);
         runMigration("0.18.0", "XMLReleaseNotesConvertorV0.17.3-0.18.0.xsl", xml_input_stream, new FileOutputStream(temporary_file));
         xml_input_stream = new FileInputStream(temporary_file);
         input_stream_vector.add(xml_input_stream);
       }
       // It may happen that the declared XRN version is not the current one, but that no migration is necessary
       if (temporary_file == null)
       {
         log("No migration is available and necessary from XRN V" + original_version + " to V" + getXRNVersion(), Project.MSG_INFO);
       }
       else
       {
         // At last, we output the result of all those transformation into the original XML release notes file
         FileOutputStream file_output_stream = new FileOutputStream(output_file);
         PrintWriter print_writer = new PrintWriter(file_output_stream);
         xml_input_stream = new FileInputStream(temporary_file);
         input_stream_vector.add(xml_input_stream);
         InputStreamReader input_stream_reader = new InputStreamReader(xml_input_stream);
         BufferedReader buffered_reader = new BufferedReader(input_stream_reader);
         String read_line = null;
         try
         {
           while ((read_line = buffered_reader.readLine()) != null)
           {
             print_writer.println(read_line);
           }
         }
         catch (IOException io_exception)
         {
           // Normal: the outstream may be at the end
         }
 
         finally
         {
           print_writer.flush();
           print_writer.close();
           file_output_stream.flush();
           file_output_stream.close();
         }
       }
     }
     catch (IOException io_exception)
     {
       throw new BuildException("Internal error while performing the XRN migration", io_exception);
     }
     finally
     {
       // We do not forget to delete all the temporary files generated
       for (int index = 0; index < temporary_file_vector.size(); index++)
       {
         File file = (File) temporary_file_vector.elementAt(index);
         file.delete();
       }
       // And to close all the input stream
       for (int index = 0; index < input_stream_vector.size(); index++)
       {
         InputStream input_stream = (InputStream) input_stream_vector.elementAt(index);
         try
         {
           input_stream.close();
         }
         catch (IOException io_exception)
         {
           // Does not matter
         }
       }
     }
   }
 
   /***
    * Performs an XSL transformation on the provided input stream and outputs the result into the provided output stream.
    *
    * @param target_version the version the XSL is supposed to XRN-migrate to
    * @param migration_xsl_file_name the name of the XSL file that enables this migration (and which should be present
    * in the jar file, under <code>XMLReleaseNotes</code>)
    * @param xml_input_stream
    * @param output_stream
    */
   private void runMigration(String target_version, String migration_xsl_file_name, InputStream xml_input_stream, OutputStream output_stream)
   {
     final String migration_common_path = common_prefix + "migration/";
     String xsl_resource_name = migration_common_path + migration_xsl_file_name;
     log("Migrating the XML release notes file into version '" + target_version + "' via the XSL resource '" +
       xsl_resource_name + "'", Project.MSG_INFO);
     InputStream xslt_input_stream = getClass().getClassLoader().getResourceAsStream(xsl_resource_name);
     if (xslt_input_stream == null)
     {
       throw new BuildException("The XRN jar file seems to be corrupted since it cannot find the resource '" +
         xsl_resource_name + "'");
     }
     // Creates an XSLT transformer that is properly set with all parameters defined
     String public_id = "XMLReleaseNotesConvertorCommon.xsl";
     String location = migration_common_path + "XMLReleaseNotesConvertorCommon.xsl";
     XMLCatalog xml_catalog = createCatalog(public_id, location);
     Transformer transformer = createTransformerFromInput(xslt_input_stream, xml_catalog);
     StreamResult stream_result = new StreamResult(output_stream);
     StreamSource stream_source = new StreamSource(xml_input_stream);
     try
     {
       transformer.transform(stream_source, stream_result);
     }
     catch (TransformerException transformer_exception)
     {
       log("Internal error during the XSLT transformation with the XSL resource '" +
         xsl_resource_name + "' when migrating to version '" + target_version + "'", Project.MSG_ERR);
       throw new BuildException(transformer_exception);
     }
   }
 
   /***
    * Tests the XML-validity of the XRN files.
    *
    * @see #checkXMLValidityForXRNFile
    */
   private void checkXMLValidity()
     throws BuildException
   {
     File[] xrn_file_array = getXRNFiles();
     for (int index = 0; index < xrn_file_array.length; index++)
     {
       File xrn_file = xrn_file_array[index];
       checkXMLValidityForXRNFile(xrn_file);
     }
   }
 
   /***
    * Checks the XML-validity of the input XML release notes file, agains its XSD.
    *
    * @throws org.apache.tools.ant.BuildException if the file is not well-formed, nor valid, or if an exception occured during the
    * validation
    */
   private void checkXMLValidityForXRNFile(final File xrn_file)
     throws BuildException
   {
     log("Checking the validity of the XML release notes file '" + xrn_file.getAbsolutePath() + "'", Project.MSG_INFO);
 
     /*XMLValidateTask xml_validate_task = new XMLValidateTask();
     xml_validate_task.setProject(getProject());
     xml_validate_task.setFile(_xml_release_notes_file);
     xml_validate_task.setLenient(false);
     xml_validate_task.setWarn(true);
     xml_validate_task.setFailOnError(true);
     xml_validate_task.execute();*/
     /*InputStream input_stream = null;
     File temporary_xsd_file = null;
     try
     {
       final String location = common_prefix + "XMLReleaseNotes.xsd";
       input_stream = getClass().getClassLoader().getResourceAsStream(location);
       if (input_stream == null)
       {
         log("Cannot find the XRN release notes schema file '" + location + "' in the jar: cannot validate", Project.MSG_WARN);
         return;
       }
       temporary_xsd_file = File.createTempFile("xrn", "xsd");
       if (JarHelper.copyInputStreamIntoFile(input_stream, temporary_xsd_file) == false)
       {
         log("Cannot copy the XRN release notes schema file '" + location + "' from the jar into the " +
                 "temporary file '" + temporary_xsd_file.getAbsolutePath() + "': cannot validate", Project.MSG_WARN);
         return;
       }
       DOMParser dom_parser = new DOMParser();
       try
       {
         dom_parser.setFeature("http://xml.org/sax/features/validation", true);
         dom_parser.setFeature("http://apache.org/xml/features/validation/schema", true);
         dom_parser.setFeature("http://apache.org/xml/features/validation/schema-full-checking", true);
         //dom_parser.setFeature("http://apache.org/xml/features/standard-uri-conformant",false);
         //dom_parser.setProperty("http://apache.org/xml/properties/schema/external-noNamespaceSchemaLocation", "V://XMLReleaseNotes//source//XML//XMLReleaseNotes.xsd");
         dom_parser.setProperty("http://apache.org/xml/properties/schema/external-schemaLocation", temporary_xsd_file.getAbsolutePath());
       }
       catch (SAXNotRecognizedException sax_not_recognized_exception)
       {
         throw new BuildException("Does not recognize an XSD validation feature or property", sax_not_recognized_exception);
       }
       catch (SAXNotSupportedException sax_not_supported_exception)
       {
         throw new BuildException("Cannot support an XSD validation feature or property", sax_not_supported_exception);
       }
       dom_parser.setErrorHandler(new ErrorHandler()
       {
         public void error(SAXParseException sax_parser_exception)
                 throws SAXException
         {
           throwException(sax_parser_exception);
         }
 
         public void fatalError(SAXParseException sax_parser_exception)
                 throws SAXException
         {
           throwException(sax_parser_exception);
         }
 
         public void warning(SAXParseException sax_parser_exception)
                 throws SAXException
         {
         }
 
         private void throwException(SAXParseException sax_parser_exception)
                 throws BuildException
         {
           if (sax_parser_exception.getMessage().startsWith("cvc-datatype-valid.1.2.1") == true)
           {
             return;
           }
           else if (sax_parser_exception.getMessage().startsWith("cvc-attribute.3") == true)
           {
             return;
           }
           else if (sax_parser_exception.getMessage().startsWith("cvc-complex-type.2.4.c") == true)
           {
             return;
           }
           throw new BuildException("Invalid XML release notes file '" + xrn_file.getAbsolutePath() + "' at line " +
                   sax_parser_exception.getLineNumber() + ", column " + sax_parser_exception.getColumnNumber() +
                   ": " + sax_parser_exception.getMessage(), sax_parser_exception);
         }
       });
       dom_parser.parse(xrn_file.getAbsolutePath());
     }
     catch (SAXException sax_exception)
     {
       throw new BuildException("Invalid XML release notes file", sax_exception);
     }
     catch (IOException io_exception)
     {
       throw new BuildException("Cannot read the XML release notes file", io_exception);
     }
     finally
     {
       if (input_stream != null)
       {
         try
         {
           input_stream.close();
         }
         catch (IOException io_exception)
         {
           // Does not matter
         }
       }
       temporary_xsd_file.delete();
     }*/
 
     /*try
         {
           XMLReader xml_reader = XMLReaderFactory.createXMLReader();
           xml_reader.setFeature("http://xml.org/sax/features/validation", true);
           xml_reader.parse(_xml_release_notes_file.getAbsolutePath());
         }
         catch (SAXException e)
         {
           e.printStackTrace();  //To change body of catch statement use Options | File Templates.
         }
         catch (IOException e)
         {
           e.printStackTrace();  //To change body of catch statement use Options | File Templates.
         }
 
         SAXParserFactory parser_factory = null;
         try
         {
           parser_factory = SAXParserFactory.newInstance();
           parser_factory.setValidating(true);
           parser_factory.setNamespaceAware(true);
         }
         catch (FactoryConfigurationError factory_configuration_error)
         {
           throw new BuildException("Cannot create a new SAX parser factory", factory_configuration_error);
         }
         SAXParser parser = null;
         try
         {
           parser = parser_factory.newSAXParser();
         }
         catch (ParserConfigurationException parser_configuration_exception)
         {
           throw new BuildException("Cannot create a new SAX parser: it is not properly intialized", parser_configuration_exception);
         }
         catch (SAXException sax_exception)
         {
           throw new BuildException("Cannot create a new SAX parser", sax_exception);
         }
         try
         {
           DefaultHandler default_handler = new DefaultHandler()
           {
 
             public void error(SAXParseException e)
               throws SAXException
             {
               throwException(e);
             }
 
             public void fatalError(SAXParseException e)
               throws SAXException
             {
               throwException(e);
             }
 
             public void warning(SAXParseException e)
               throws SAXException
             {
               throwException(e);
             }
 
             private void throwException(SAXParseException sax_parser_exception)
             {
               throw new BuildException("Invalid XML release notes file '" + _xml_release_notes_file.getAbsolutePath() + "' at line " +
                 sax_parser_exception.getLineNumber() + ", column " + sax_parser_exception.getColumnNumber() +
                 ": " + sax_parser_exception.getMessage(), sax_parser_exception);
 
             }
           };
           parser.parse(_xml_release_notes_file, default_handler);
         }
         catch (SAXException sax_exception)
         {
           throw new BuildException("Invalid XML release notes file", sax_exception);
         }
         catch (IOException io_exception)
         {
           throw new BuildException("Cannot read the XML release notes file", io_exception);
         }*/
     log("The XML release notes file '" + xrn_file.getAbsolutePath() + "' is valid against its schema", Project.MSG_INFO);
   }
 
   /***
    * The method creates an XML catalog, useful for URI resolution during XSLT.
    *
    * @return a newly created XML catalog, properly set
    * @throws org.apache.tools.ant.BuildException if there were a problem
    * @see #createCatalog(java.lang.String, java.lang.String)
    */
   private XMLCatalog createCatalog()
     throws BuildException
   {
     XMLCatalog xml_catalog = new XMLCatalog();
     xml_catalog.setProject(getProject());
     if (_uri_resolver_path != null)
     {
       xml_catalog.setClasspath(_uri_resolver_path);
     }
     return xml_catalog;
   }
 
   /***
    * The method creates an XML catalog, useful for URI resolution during XSLT, with already one URI resolution added.
    *
    * @param public_id the public id of the URI to be resolved
    * @param location the actual location of the URI when being resolved
    * @return a newly created XML catalog, properly set
    * @throws org.apache.tools.ant.BuildException if there were a problem
    * @see #addCatalogURI
    */
   private XMLCatalog createCatalog(String public_id, String location)
     throws BuildException
   {
     XMLCatalog xml_catalog = createCatalog();
     addCatalogURI(xml_catalog, public_id, location);
     return xml_catalog;
   }
 
   /***
    * @return if the dectected Ant runtime version is < 1.6.0
    */
   private boolean isAntInferiorTo160()
   {
     try
     {
       Class resouce_location_class = Class.forName("org.apache.tools.ant.loader.AntClassLoader2");
       return false;
     }
     catch (ClassNotFoundException class_not_found_exception)
     {
       // We should not be running under Ant V1.5=-
       return true;
     }
   }
 
   /***
    * Created because of incompabilities issues between Ant V1.5 and Ant V1.6+.
    * <p>
    * The method just adds an URI resolution to the provided catalog.
    * </p>
    *
    * @param xml_catalog the catalog a new resolution should be added to
    * @param public_id the public id of the URI to be resolved
    * @param location the actual location of the URI when being resolved
    * @throws org.apache.tools.ant.BuildException if there were a problem
    */
   private void addCatalogURI(XMLCatalog xml_catalog, String public_id, String location)
   {
     boolean location_set = false;
     Vector class_vector = new Vector();
     try
     {
       Class resouce_location_class = Class.forName("org.apache.tools.ant.types.ResourceLocation");
       // We should be running under Ant V1.6=+
       class_vector.add(resouce_location_class);
     }
     catch (ClassNotFoundException class_not_found_exception)
     {
       // We are not running under Ant V1.6=+
     }
     try
     {
       Class resouce_location_class = Class.forName("org.apache.tools.ant.types.DTDLocation");
       // We should be running under Ant V1.5=-
       class_vector.add(resouce_location_class);
     }
     catch (ClassNotFoundException class_not_found_exception)
     {
       // We should not be running under Ant V1.5=-
     }
     Exception potential_exception = null;
     for (int index = 0; index < class_vector.size(); index++)
     {
       Class resouce_location_class = (Class) class_vector.elementAt(index);
       try
       {
         Object resource_location = resouce_location_class.newInstance();
         resouce_location_class.getMethod("setPublicId", new Class[]{String.class}).invoke(resource_location, new Object[]{public_id});
         resouce_location_class.getMethod("setLocation", new Class[]{String.class}).invoke(resource_location, new Object[]{location});
         xml_catalog.getClass().getMethod("addEntity", new Class[]{resouce_location_class}).invoke(xml_catalog, new Object[]{resource_location});
       }
       catch (Exception exception)
       {
         potential_exception = exception;
         log("The seems to be some problem with the 'XMLCatalog'", Project.MSG_WARN);
       }
       location_set = true;
       break;
     }
     if (class_vector.size() == 0)
     {
       throw new BuildException("Cannot set properly an XMLCatalog, which enables to resolve URIs");
     }
     if (location_set == false)
     {
       throw new BuildException("Cannot set properly an XMLCatalog, which enables to resolve URIs", potential_exception);
     }
     log("URIResolver: the public id '" + public_id + "' will be resolved as '" + location + "'", Project.MSG_VERBOSE);
   }
 
   /***
    * The prefix where all public resources are present within the jar.
    */
   private final static String common_prefix = "XMLReleaseNotes/";
 
   /***
    * The common location of all plugin XSLTs.
    */
   private final static String plugin_common_prefix = common_prefix + "plugin/";
 
   /***
    * The part that just deploys the framework resources.
    */
   private void deploy()
   {
     log("You chose to deploy the XMLReleaseNotes framework into directory '" +
       _destination_directory.getAbsolutePath() + "'", Project.MSG_INFO);
     final String[] file_name_array = {common_prefix + _simple_xsl, common_prefix + "XMLReleaseNotesCommon.xsl",
                                       common_prefix + "XMLReleaseNotes.xsd",
                                       common_prefix + "XMLActors.xsd", common_prefix + "XMLReleaseNotes.css"};
     for (int index = 0; index < file_name_array.length; index++)
     {
       String file_name = file_name_array[index];
       File original_copied_file = new File(_destination_directory, file_name);
       File copied_file = new File(_destination_directory, original_copied_file.getName());
       if (JarHelper.copyFileFromJar(file_name, null, copied_file) == false)
       {
         throw new BuildException("Cannot copy the file present in the jar under '" + file_name +
           "' into '" + copied_file.getAbsolutePath() + "'");
       }
       else
       {
         log("Copied file from the jar under '" + file_name + "' into file '" + copied_file.getAbsolutePath() + "'", Project.MSG_VERBOSE);
       }
     }
   }
 
   /***
    * Sends the final e-mail.
    */
   private void sendMail()
   {
     log("An e-mail containing the generated release notes is bound to be sent: hope that you haved made the HTML inline " +
       "via the 'inlineCSS' parameter...", Project.MSG_INFO);
     _mail.setProject(getProject());
     _mail.setMessageFile(getMainOutputFile());
     _mail.setMessageMimeType("text/html");
     _mail.execute();
   }
 
   /***
    * The part of the task that actually generates the HTML release notes.
    */
   private void generateReleaseNotes()
   {
     log("You chose to generate the HTML release notes", Project.MSG_VERBOSE);
     // Prepares the disk environment (creation of directories, copy of files if necessary)
     prepareEnvironment();
     // If it's OK, we can go for the transformation
     generateXMLReleaseNotes();
   }
 
   /***
    * The name of the target CSS copied into the destination directory.
    */
   final static String copied_css_file_name = "stylesheet.css";
 
   /***
    * This method creates the environment so that the execution of the XSL transformation is OK and does not have
    * to bother about those details.
    * <p>
    * The method does the followingt things:
    * <ol>
    * <li>create the destionation directory if necessary,</li>
    * <li>copy the CSS file into the destination directory.</li>
    * </ol>
    * </p>
    */
   private void prepareEnvironment()
     throws BuildException
   {
     // Destination directory
     if (_destination_directory.isDirectory() == false)
     {
       if (_destination_directory.isFile() == true)
       {
         throw new BuildException("Cannot use the file '" + _destination_directory.getAbsolutePath() + "' as a destination " +
           "directory");
       }
       if (_destination_directory.mkdirs() == true)
       {
         log("Destination directory '" + _destination_directory.getAbsolutePath() + "' created", Project.MSG_VERBOSE);
       }
     }
     log("The HTML stuff will be generated into the directory '" + _destination_directory.getAbsolutePath() + "'", Project.MSG_INFO);
     // The CSS file is only copied if necessary
     if (_css_file == null)
     {
       if (JarHelper.copyFileFromJar(common_prefix + "XMLReleaseNotes.css", null, getDestinationCSSFile()) == false)
       {
         log("Cannot create the Cascading Style Sheet (CSS) file '" +
           getDestinationCSSFile().getAbsolutePath() + "': the CSS will miss", Project.MSG_WARN);
         return;
       }
       log("The CSS file used will be the default one", Project.MSG_VERBOSE);
     }
     else
     {
       final String aftermaths = "the default one will be used instead";
       // In that case, we use the CSS provided by the end-user
       try
       {
         FileInputStream file_input_stream = new FileInputStream(_css_file);
         if (JarHelper.copyInputStreamIntoFile(file_input_stream, getDestinationCSSFile()) == true)
         {
           log("The CSS file used will be '" + _css_file.getAbsolutePath() + "'", Project.MSG_VERBOSE);
         }
         else
         {
           log("The CSS file provided '" + _css_file.getAbsolutePath() + "' could not be copied: " +
             aftermaths, Project.MSG_WARN);
         }
       }
       catch (FileNotFoundException file_not_found_exception)
       {
         log("The CSS file provided '" + _css_file.getAbsolutePath() + "' does not exist: " +
           aftermaths, Project.MSG_WARN);
       }
     }
     if (_use_icons != null && _use_icons.booleanValue() == true)
     {
       final String[] icon_list = {"bug.png", "tech.png", "actor.png"};
       for (int index = 0; index < icon_list.length; index++)
       {
         String file_name = icon_list[index];
         if (JarHelper.copyFileFromJar(common_prefix + "image/" + file_name, null, new File(_destination_directory, file_name)) == false)
         {
           log("Cannot create the icons", Project.MSG_WARN);
         }
       }
     }
   }
 
   /***
    * A struct-like class that enables to describe an XSLT.
    */
   private class Transformation
   {
     InputStream xsltInputStream;
     String xsltLocation;
     XMLCatalog uriResolver;
     XSLT.Param[] parametersArray;
   }
 
   private Transformation getMavenXSLTModel(File maven_project_file)
     throws BuildException
   {
     Transformation transaction = new Transformation();
     final String location = common_prefix + "MavenModel.xsl";
     transaction.xsltInputStream = getClass().getClassLoader().getResourceAsStream(location);
     checkInputStream(transaction.xsltInputStream, location);
     transaction.parametersArray = new XSLT.Param[1];
     transaction.parametersArray[0].setName("MavenPOMFile");
     transaction.parametersArray[0].setExpression(maven_project_file.getAbsolutePath());
     return transaction;
   }
 
   private static int _counter = 0;
 
   /***
    * Performs an XSL tranformation, while applying the common parameters.
    *
    * @param source the XML source that will be transformed
    * @param xslt_input_stream the XSLT stream that will be used a style sheet for the transformation: <code>this
    * stream is being closed by this call!</b>
    * @param stream_result if not <code>null</code>, then the result of the transformation will be written into it
    * @param uri_resolver if not <code>null</code>, this URI resolver will be used by the transformer
    * @param parameters_array additional parameters that will be set; may be null
    * @return the resulting transformation DOM
    * @throws org.apache.tools.ant.BuildException if an error happened during the transformation, or in its preparation
    */
   private DOMResult performTransformation(Source source, InputStream xslt_input_stream, StreamResult stream_result,
                                           XMLCatalog uri_resolver, XSLT.Param[] parameters_array)
     throws BuildException
   {
     try
     {
       // Creates an XSLT transformer that is properly set with all parameters defined
       Transformer transformer = null;
       try
       {
         // Creates the transformer
         transformer = createTransformerFromInput(xslt_input_stream, uri_resolver);
       }
       catch (BuildException build_exception)
       {
         if (xslt_input_stream != null)
         {
           try
           {
             xslt_input_stream.close();
           }
           catch (IOException io_exception)
           {
             // Does not matter
           }
         }
         throw build_exception;
       }
 
       // Sets the common XSLT parameters, plus the provided ones
       setParameters(transformer, parameters_array);
 
       DOMResult dom_result = null;
       transformer.setErrorListener(new ErrorListener()
       {
         public void error(TransformerException transformer_exception)
           throws TransformerException
         {
           log("error during XSLT: '" + transformer_exception.getMessageAndLocation(), Project.MSG_WARN);
         }
 
         public void fatalError(TransformerException transformer_exception)
           throws TransformerException
         {
           log("fatalError during XSLT: '" + transformer_exception.getMessageAndLocation(), Project.MSG_ERR);
         }
 
         public void warning(TransformerException transformer_exception)
           throws TransformerException
         {
           log("warning during XSLT: '" + transformer_exception.getMessageAndLocation(), Project.MSG_WARN);
         }
       });
       // Now, go for the transformation!
       try
       {
         log("***************************************************************************", Project.MSG_VERBOSE);
         log("Now, launching an XSLT transformation...", Project.MSG_VERBOSE);
         if (stream_result != null)
         {
           transformer.transform(source, stream_result);
         }
         // In any case, we provide the DOM
         if (isUsingXalanImplementation() == false)
         {
           dom_result = new DOMResult(createADocumentBuilder().newDocument());
         }
         else
         {
           dom_result = new DOMResult();
         }
         transformer.transform(source, dom_result);
         log("... Transformation over", Project.MSG_VERBOSE);
         log("***************************************************************************", Project.MSG_VERBOSE);
         return dom_result;
       }
       catch (TransformerException transformer_exception)
       {
         log("Internal error during the layout transformation: the XSLT may be bugged...", Project.MSG_ERR);
         throw new BuildException(transformer_exception);
       }
       catch (Exception exception)
       {
         log("Internal unexpected error during the layout transformation: the XSLT may be bugged...", Project.MSG_ERR);
         throw new BuildException(exception);
       }
     }
     finally
     {
       try
       {
         xslt_input_stream.close();
       }
       catch (IOException io_exception)
       {
         // Does not matter
       }
     }
   }
 
   /***
    * @see #generateXMLReleaseNotesForXRNFile
    */
   private void generateXMLReleaseNotes()
     throws BuildException
   {
 
     log("---------------------------------------------------------------------------", Project.MSG_VERBOSE);
     log("Handling the individual release notes files", Project.MSG_INFO);
     File[] xrn_file_array = getXRNFiles();
     for (int index = 0; index < xrn_file_array.length; index++)
     {
       File xrn_file = xrn_file_array[index];
       log("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++", Project.MSG_VERBOSE);
       log("Handling the release notes files '" + xrn_file.getAbsolutePath() + "'", Project.MSG_VERBOSE);
       generateXMLReleaseNotesForXRNFile(xrn_file);
     }
     log("---------------------------------------------------------------------------", Project.MSG_VERBOSE);
     log("Handling the multiple release notes files", Project.MSG_INFO);
     // If a multiple-component release notes is being asked for, we finally perform the transformation that
     // generates the HTML glue
     if (useTheMultiplePagesXSLT() == true)
     {
       final String xrn_namespace_uri = "http://xmlreleasenotes.free.fr";
       Document document = createADocumentBuilder().newDocument();
       Element top_element = document.createElementNS(xrn_namespace_uri, "xrn:MultipleReleaseNotes");
       document.appendChild(top_element);
       Attr xrn_namespace_attribute = document.createAttribute("xmlns:xrn");
       xrn_namespace_attribute.setValue(xrn_namespace_uri);
       Attr xsi_namespace_attribute = document.createAttribute("xmlns:xsi");
       xsi_namespace_attribute.setValue("http://www.w3.org/2001/XMLSchema-instance");
       Attr xrn_version_attribute = document.createAttribute("XRNVersion");
       xrn_version_attribute.setValue(getXRNVersion());
       top_element.setAttributeNode(xrn_namespace_attribute);
       top_element.setAttributeNode(xsi_namespace_attribute);
       top_element.setAttributeNode(xrn_version_attribute);
 
       for (int index = 0; index < _xrn_top_node_array.size(); index++)
       {
         Node node = (Node) _xrn_top_node_array.get(index);
         Node imported_node = null;
         try
         {
           imported_node = document.importNode(node, true);
         }
         catch (DOMException dom_exception)
         {
           log("Cannot create the DOM that contains all the release notes", Project.MSG_ERR);
           throw new BuildException(dom_exception);
         }
         NamedNodeMap attributes = imported_node.getAttributes();
         attributes.removeNamedItem("xsi:schemaLocation");
         //attributes.removeNamedItem("xmlns:xrn");
         attributes.removeNamedItem("xmlns:xsi");
         top_element.appendChild(imported_node);
       }
 
       final String resource_location = getMultiplePageResourceName();
       InputStream xslt_input_stream = getClass().getClassLoader().getResourceAsStream(resource_location);
       checkInputStream(xslt_input_stream, resource_location);
 
       XMLCatalog uri_resolver = createCatalog();
       addCatalogURI(uri_resolver, "XMLReleaseNotes2HTML", common_prefix + _simple_xsl);
       addCatalogURI(uri_resolver, "XMLReleaseNotes2HTMLPlugin", getXRN2HTMLPluginResourceName());
       if (_plugin_layout_xslt != null)
       {
         addCatalogURI(uri_resolver, "XRN2HTMLPlugin", _plugin_layout_xslt.xslFile.getAbsolutePath());
       }
       else
       {
         addCatalogURI(uri_resolver, "XRN2HTMLPlugin", common_prefix + "XRN2HTMLPlugin.xsl");
       }
 
       // The XML file is flushed to a temporary file because of a bug in Xalan implementation
       final boolean debug_xalan = false;
       File multiple_releasenotes_file = null;
       if (_debug.booleanValue() == true)
       {
         multiple_releasenotes_file = new File(_destination_directory, "" + _counter + ".xml");
         _counter++;
       }
       else if (debug_xalan == true)
       {
         try
         {
           multiple_releasenotes_file = File.createTempFile("XRNMultipleReleaseNotess", "xml");
         }
         catch (IOException io_exception)
         {
           final String message = "Cannot create a temporary file for writing the multiple release notes file";
           log(message, Project.MSG_ERR);
           throw new BuildException(message, io_exception);
         }
       }
       if (_debug.booleanValue() == true || debug_xalan == true)
       {
         writeXMLDocument(document, multiple_releasenotes_file);
       }
 
       // If needed, the XRN-Java plug-ins are being called
       //callJavaPlugins(document, multiple_releasenotes_file);
 
       try
       {
         // The default main style sheet should not be written, this is why we do not write the output of the transformation
         performTransformation(new DOMSource(document)/*new StreamSource(multiple_releasenotes_file)*/, xslt_input_stream, null, uri_resolver, null);
       }
       finally
       {
         if (debug_xalan == true && _debug.booleanValue() == false)
         {
           multiple_releasenotes_file.delete();
         }
       }
     }
   }
 
   /***
    * Invokes all XRN-Java plug-ins
    *
    * @param document the XML DOM which is supposed to contain a top 'xrn:MultipleReleaseNotes' element
    */
   /*private void callJavaPlugins(Document document, File file)
     throws BuildException
   {
     Plugin plugin = new Plugin();
     try
     {
       if (document != null)
       {
         plugin.run(document);
       }
       else
       {
         plugin.run(file);
       }
     }
     catch (Exception exception)
     {
       final String message = "The execution of the XRN-Java plug-in was a failure";
       log(message, Project.MSG_ERR);
       throw new BuildException(message, exception);
     }
   }*/
 
   /***
    * Writes the DOM document into a given file; the file is overwritten.
    *
    * @param xml_document the DOM document root element to be output
    * @param file the file in which the XML document is being serialized
    * @throws org.apache.tools.ant.BuildException if the serialization went wrong
    */
   private void writeXMLDocument(Document xml_document, File file)
     throws BuildException
   {
     TransformerFactory transformer_factory = createATransformerFactory();
     DOMSource dom_source = new DOMSource(xml_document);
     Transformer transformer = null;
     try
     {
       transformer = transformer_factory.newTransformer();
     }
     catch (TransformerConfigurationException transformer_configuration_exception)
     {
       log("Cannot create a DOM transformer in order to serialize an XML document", Project.MSG_ERR);
       throw new BuildException(transformer_configuration_exception);
     }
     FileOutputStream file_output_stream = null;
     try
     {
       file_output_stream = new FileOutputStream(file);
     }
     catch (FileNotFoundException file_not_found_exception)
     {
       log("Cannot create file '" + file.getAbsolutePath() + "'", Project.MSG_ERR);
       throw new BuildException(file_not_found_exception);
     }
     StreamResult stream_result = new StreamResult(file_output_stream);
     try
     {
       transformer.transform(dom_source, stream_result);
     }
     catch (TransformerException transformer_exception)
     {
       log("Cannot serialize an XML document to a file", Project.MSG_ERR);
       throw new BuildException(transformer_exception);
     }
     finally
     {
       try
       {
         file_output_stream.flush();
         file_output_stream.close();
       }
       catch (IOException io_exception)
       {
         log("The file where the XML document has been serialized cannot be flushed or closed properly", Project.MSG_WARN);
       }
     }
   }
 
   /***
    * The method that actually performs the transformation, and that assumes that the environment is ready.
    *
    * @param xrn_file the XRN file for which the transformation must be run
    * @throws org.apache.tools.ant.BuildException if the transformation failed somewhere
    */
   private void generateXMLReleaseNotesForXRNFile(File xrn_file)
     throws BuildException
   {
     Source final_xml_source = null;
     final_xml_source = performUserModelTransformations(xrn_file);
     // We perform the internal XSL model transformations
     final_xml_source = performInternalModelTransformations(final_xml_source);
     // The last thing to do is to launch the HTML layout rendering
     performLayoutTransformation(final_xml_source);
   }
 
   /***
    * Part of the XSLT that only concerns the user XSLT models.
    *
    * @param xrn_file the XRN file to be handled
    * @return the transformed XRN file, or itself if no XSLT model if available
    */
   private Source performUserModelTransformations(File xrn_file)
   {
     Source output_xml_source = null;
     ArrayList model_transformation_array = new ArrayList();
     for (int index = 0; index < _model_xslt_vector.size(); index++)
     {
       XSLT xslt = (XSLT) _model_xslt_vector.elementAt(index);
       XSLT.Param[] parameters_array = new XSLT.Param[xslt.parameterVector.size()];
       xslt.parameterVector.toArray(parameters_array);
       Transformation transformation = new Transformation();
       transformation.xsltInputStream = xslt.getXSLTStream();
       transformation.xsltLocation = xslt.getXSLTLocation();
       transformation.uriResolver = createCatalog("XRNModelCommon.xsl", plugin_common_prefix + "XRNModelCommon.xsl");
       transformation.parametersArray = parameters_array;
       model_transformation_array.add(transformation);
     }
     Node top_node = null;
     if (model_transformation_array.size() > 0)
     {
       Source xml_source = new StreamSource(xrn_file);
       for (int index = 0; index < model_transformation_array.size(); index++)
       {
         Transformation transformation = (Transformation) model_transformation_array.get(index);
         log("Using the XSL model transformation defined in '" + transformation.xsltLocation + "'",
           Project.MSG_INFO);
         StreamResult stream_result = null;
         if (_debug.booleanValue() == true)
         {
           stream_result = new StreamResult(new File(_destination_directory, "" + _counter + ".xml"));
           _counter++;
         }
         DOMResult dom_result = performTransformation(xml_source, transformation.xsltInputStream, stream_result,
           transformation.uriResolver, transformation.parametersArray);
         xml_source = new DOMSource(dom_result.getNode());
         top_node = dom_result.getNode();
       }
       output_xml_source = new DOMSource(top_node);
     }
     else
     {
       log("No preliminar XSL transformation used", Project.MSG_INFO);
       output_xml_source = new StreamSource(xrn_file);
       top_node = getXMLDocumentFromXRNFile(xrn_file);
     }
     Node right_node = null;
     NodeList node_list = top_node.getChildNodes();
     for (int index = 0; index < node_list.getLength(); index++)
     {
       Node node = node_list.item(index);
       short node_type = node.getNodeType();
       // This is not possible to rely on the node local name because Saxon is bugged and always return null...
       if (/*node.getLocalName() != null && node.getLocalName().equals("ReleaseNotes") == true &&*/ node_type == Node.ELEMENT_NODE)
       {
         right_node = node;
         break;
       }
     }
     if (right_node == null)
     {
       throw new BuildException("Cannot find the 'ReleaseNotes' node from the model XSL transformation");
     }
     // If necessary, we remember the XML source
     rememberXRN(right_node);
     return output_xml_source;
   }
 
   /***
    * Remembers all XRN files the model XSLT have been applied to.
    */
   private ArrayList _xrn_top_node_array = new ArrayList();
 
   private void rememberXRN(Node top_node)
   {
     if (useTheMultiplePagesXSLT() == false)
     {
       // We do not need to remember the node in that case
       return;
     }
     _xrn_top_node_array.add(top_node);
   }
 
   /***
    * This part of the code performs all the XRN internal XSLT model transformations when necessary.
    *
    * @param input_xml_source the XML inout source to be handled
    * @return the XML output resulting from the various potential model transformations
    */
   private Source performInternalModelTransformations(Source input_xml_source)
   {
     Source output_xml_source = input_xml_source;
     /*if (useCumulative() == true)
     {
       // We perform an intermediate XSLT transformation if the cumulative option has been chosen
       final String cumulative_model_location = common_prefix + "CumulativeModel.xsl";
       log("The cumulative XSLT '" + cumulative_model_location + "' is being applied", Project.MSG_INFO);
       InputStream cumulative_input_stream = getClass().getClassLoader().getResourceAsStream(cumulative_model_location);
       if (cumulative_input_stream == null)
       {
         log("Error: the cumulative XSLT is missing from the jar: this feature will not be taken into account", Project.MSG_ERR);
       }
       else
       {
         DOMResult dom_result = performTransformation(input_xml_source, cumulative_input_stream, null, null, new XSLT.Param[0]);
         output_xml_source = new DOMSource(dom_result.getNode());
       }
     }*/
     return output_xml_source;
   }
 
   /***
    * Actually performs the last transformation that works on the HTML layout.
    *
    * @param final_xml_source the input source that will be used for this last transformation
    */
   private void performLayoutTransformation(Source final_xml_source)
     throws BuildException
   {
     XSLT.Param[] parameters_array = null;
     if (_layout_xslt != null)
     {
       parameters_array = new XSLT.Param[_layout_xslt.parameterVector.size()];
       _layout_xslt.parameterVector.toArray(parameters_array);
     }
     // We prepare the URI resolver
     XMLCatalog uri_resolver = null;
     if (_layout_xslt != null && _layout_xslt.uriResolver != null)
     {
       uri_resolver = _layout_xslt.uriResolver;
     }
     else
     {
       uri_resolver = createCatalog();
     }
 
     // Determines the XSLT input
     InputStream xslt_input_stream = null;
     String xsl_file_resouce_name = null;
     StreamResult stream_result = null;
     if (useTheMultiplePagesXSLT() == true)
     {
       // The multiple-HTML-page template XSLT is used
       log("Using the mutiple-HTML-page for the layout transformation", Project.MSG_INFO);
       xsl_file_resouce_name = getMultiplePageResourceName();
       xslt_input_stream = getClass().getClassLoader().getResourceAsStream(xsl_file_resouce_name);
       checkInputStream(xslt_input_stream, xsl_file_resouce_name);
       if (_layout_xslt != null)
       {
         addCatalogURI(uri_resolver, "XMLReleaseNotes2HTML", _layout_xslt.xslFile.getAbsolutePath());
       }
       else
       {
         addCatalogURI(uri_resolver, "XMLReleaseNotes2HTML", common_prefix + _simple_xsl);
       }
       addCatalogURI(uri_resolver, "XMLReleaseNotes2HTMLPlugin", getXRN2HTMLPluginResourceName());
       if (_plugin_layout_xslt != null)
       {
         addCatalogURI(uri_resolver, "XRN2HTMLPlugin", _plugin_layout_xslt.xslFile.getAbsolutePath());
       }
       else
       {
         addCatalogURI(uri_resolver, "XRN2HTMLPlugin", common_prefix + "XRN2HTMLPlugin.xsl");
       }
     }
     else
     {
       // A single-HTML-page template XSLT is used
       log("Using a single-HTML-page for the layout transformation", Project.MSG_INFO);
       if (_layout_xslt != null)
       {
         xsl_file_resouce_name = _layout_xslt.xslFile.getAbsolutePath();
         xslt_input_stream = getInputStream(_layout_xslt.xslFile);
         checkInputStream(xslt_input_stream, xsl_file_resouce_name);
       }
       else
       {
         xsl_file_resouce_name = common_prefix + _simple_xsl;
         xslt_input_stream = getClass().getClassLoader().getResourceAsStream(xsl_file_resouce_name);
         checkInputStream(xslt_input_stream, xsl_file_resouce_name);
       }
       if (_layout_xslt != null)
       {
         addCatalogURI(uri_resolver, _simple_xsl, common_prefix + _simple_xsl);
       }
       stream_result = new StreamResult(getMainOutputFile());
     }
 
     log("Using the XSLT '" + xsl_file_resouce_name + "' for the layout transformation", Project.MSG_VERBOSE);
     performTransformation(final_xml_source, xslt_input_stream, stream_result,
       uri_resolver, parameters_array);
   }
 
   /***
    * @return the name of the multiple-page XSLT resource within the jar
    */
   private String getMultiplePageResourceName()
   {
     String xsl_file_resouce_name;
     xsl_file_resouce_name = common_prefix + "XMLReleaseNotes2HTMLMultiple1.0.xsl";
     if (isUsingXalanImplementation() == true)
     {
       xsl_file_resouce_name = common_prefix + "XMLReleaseNotes2HTMLMultipleXalan.xsl";
     }
     return xsl_file_resouce_name;
   }
 
   /***
    * @return the name of the multiple-page plugin XSLT resource within the jar
    */
   private String getXRN2HTMLPluginResourceName()
   {
     String xsl_file_resouce_name;
     xsl_file_resouce_name = common_prefix + "XMLReleaseNotes2HTMLPlugin1.0.xsl";
     if (isUsingXalanImplementation() == true)
     {
       xsl_file_resouce_name = common_prefix + "XMLReleaseNotes2HTMLPluginXalan.xsl";
     }
     return xsl_file_resouce_name;
   }
 
   /***
    * Creates an input stream from the given file.
    *
    * @param file the file from which an input stream must be created
    * @return a newly created input sream
    * @throws org.apache.tools.ant.BuildException if the provided file canot be found
    */
   private InputStream getInputStream(File file)
     throws BuildException
   {
     InputStream xslt_input_stream = null;
     try
     {
       xslt_input_stream = new FileInputStream(file);
     }
     catch (FileNotFoundException file_not_found_exception)
     {
       log("Could not find file '" + file.getAbsolutePath() + "'", Project.MSG_ERR);
       throw new BuildException("XSL file '" + file.getAbsolutePath() + "' does not exist: cannot perform the XSLT");
     }
     return xslt_input_stream;
   }
 
   /***
    * Checks that the provided input stream is not null.
    *
    * @param input_stream the input stream to be tested
    * @param location the location it is supposed to come from
    * @throws org.apache.tools.ant.BuildException if the input stream is actually null
    */
   private void checkInputStream(InputStream input_stream, String location)
     throws BuildException
   {
     if (input_stream == null)
     {
       throw new BuildException("Cannot find the input stream with location '" + location + "': cannot continue the " +
         "processing");
     }
     try
     {
       input_stream.available();
     }
     catch (IOException io_exception)
     {
       throw new BuildException("Cannot read the input stream with location '" + location + "': cannot continue the " +
         "processing");
     }
   }
 
   /***
    * @return the CSS file that will be created and potentially used by the layout final XSL transformation
    */
   private File getDestinationCSSFile()
   {
     File copied_css_file = new File(_destination_directory, copied_css_file_name);
     return copied_css_file;
   }
 
   /***
    * @return the main file that is output at the end of the XSL transformations
    */
   private File getMainOutputFile()
   {
     return new File(_destination_directory, _html_release_notes_file_name);
   }
 
   /***
    * Sets the parameters that are expected for all transformations.
    *
    * @param transformer an already created XSLT transformer
    * @param parameter_array if not <code>null</code>, those parameters will be provided to the XSL transformation
    */
   private void setParameters(Transformer transformer, XSLT.Param[] parameter_array)
   {
     transformer.setParameter("XSLTImplementation", transformer.getClass().getName());
     if (useTheMultiplePagesXSLT() == true)
     {
       transformer.setParameter("destination", _destination_directory);
     }
     if (useTheMultiplePagesXSLT() == true)
     {
       transformer.setParameter("multipleComponents", new Boolean(true));
     }
     if (_inline_css.booleanValue() == true)
     {
       transformer.setParameter("CSSContent", getCSSContent());
       transformer.setParameter("CSS", "");
     }
     else
     {
       transformer.setParameter("CSS", copied_css_file_name);
     }
     transformer.setParameter("abstract", _abstract_string);
     if (_use_icons != null)
     {
       transformer.setParameter("useIcons", _use_icons);
     }
     // At last, we provide the provided parameter_array
     if (parameter_array != null)
     {
       log("The parameters provided will be used for the coming XSL transformation", Project.MSG_DEBUG);
       for (int index = 0; index < parameter_array.length; index++)
       {
         XSLT.Param parameter = parameter_array[index];
         transformer.setParameter(parameter.getName(), parameter.getExpression());
         log("Added the parameter with name '" + parameter.getName() + "' and value '" + parameter.getExpression() + "'",
           Project.MSG_VERBOSE);
       }
     }
     transformer.setParameter("banner", _show_banner);
     if (useTheMultiplePagesXSLT() == true)
     {
       if (_title != null)
       {
         transformer.setParameter("titleText", _title.getText());
       }
       if (_header != null)
       {
         transformer.setParameter("headerText", _header.getText());
       }
       if (_footer != null)
       {
         transformer.setParameter("footerText", _footer.getText());
       }
     }
   }
 
   /***
    * @return the input stream of the CSS that will be used
    * @throws org.apache.tools.ant.BuildException if the input stream material does not exist
    */
   private InputStream getCSSStream()
     throws BuildException
   {
     InputStream input_stream = null;
     String location = null;
     if (_css_file != null)
     {
       location = _css_file.getAbsolutePath();
       input_stream = getInputStream(_css_file);
     }
     else
     {
       location = common_prefix + "XMLReleaseNotes.css";
       input_stream = getClass().getClassLoader().getResourceAsStream(location);
     }
     checkInputStream(input_stream, location);
     return input_stream;
   }
 
   /***
    * @return the content of the CSS file
    * @throws org.apache.tools.ant.BuildException if the CSS content could not be read
    */
   private String getCSSContent()
     throws BuildException
   {
     // We use the Ant 'LoadFile' task in order to get the content of the CSS file, and remove the comments
     /*LoadFile load_file = new LoadFile();
     load_file.setProject(getProject());
     load_file.setSrcFile(getDestinationCSSFile());
     FilterChain filter_chain = new FilterChain();
     // Remove the comments
     filter_chain.addStripJavaComments(new StripJavaComments());
     load_file.addFilterChain(filter_chain);
     final String dummy_property = "DUMMY_PROPERTY" + new Random().nextLong();
     load_file.setProperty(dummy_property);
     load_file.execute();
     final String css_content = getProject().getProperty(dummy_property);
     return css_content;*/
     InputStream input_stream = getCSSStream();
     InputStreamReader input_stream_reader = new InputStreamReader(input_stream);
     BufferedReader buffered_reader = new BufferedReader(input_stream_reader);
     String line = null;
     String css_content = "";
     try
     {
       while ((line = buffered_reader.readLine()) != null)
       {
         css_content += line;
       }
     }
     catch (IOException io_exception)
     {
       throw new BuildException("Cannot read properly the CSS content", io_exception);
     }
     return css_content;
   }
 
   /***
    * Creates an XSLT transformer with the provided XSL input.
    * <p>
    * Whatever the URI resolver provided, the method wil add one in order to be able to get the other XSL stuff inside
    * the executing jar.
    * </p>
    *
    * @param xslt_input_stream the input XSL stream that will be used during the transformation
    * @param uri_resolver if not <code>null</code>, this URI resolver will be used during the transformation
    * @return a newly created transformer that can be used later on
    */
   private Transformer createTransformerFromInput(InputStream xslt_input_stream, XMLCatalog uri_resolver)
     throws BuildException
   {
     TransformerFactory transformer_factory = createATransformerFactory();
     // We provide an URI resolver to the factory (it does not work with the transformer itself) in all cases
     final String public_id = "XMLReleaseNotesCommon.xsl";
     // We add the common XSL to the resolver
     if (uri_resolver == null)
     {
       // We create an URI resolver
       uri_resolver = createCatalog(public_id, common_prefix + public_id);
     }
     else
     {
       addCatalogURI(uri_resolver, public_id, common_prefix + public_id);
     }
     transformer_factory.setURIResolver(uri_resolver);
     log("Using a URI resolver for the next coming XSLT transformation", Project.MSG_VERBOSE);
 
     // Defines an error listener so as to get more information when the XSLT is not well-formed
     transformer_factory.setErrorListener(new ErrorListener()
     {
       public void error(TransformerException transformer_exception)
         throws TransformerException
       {
         log("error during XSLT: '" + transformer_exception.getMessageAndLocation(), Project.MSG_WARN);
       }
 
       public void fatalError(TransformerException transformer_exception)
         throws TransformerException
       {
         log("fatalError during XSLT: '" + transformer_exception.getMessageAndLocation(), Project.MSG_ERR);
         throw transformer_exception;
       }
 
       public void warning(TransformerException transformer_exception)
         throws TransformerException
       {
         log("warning during XSLT: '" + transformer_exception.getMessage(), Project.MSG_WARN);
       }
     });
 
     // Creates the transformer
     Transformer transformer = null;
     try
     {
       log("Creating the transformer with the '" + xslt_input_stream + "' XSL...", Project.MSG_VERBOSE);
       StreamSource stream_source = new StreamSource(xslt_input_stream);
       transformer = transformer_factory.newTransformer(stream_source);
       log("... Transformer created", Project.MSG_VERBOSE);
     }
     catch (TransformerConfigurationException transformer_configuration_exception)
     {
       log("Internal error: could not create the XSL transformer: it may be that the XSL source file is bugged...", Project.MSG_ERR);
       throw new BuildException(transformer_configuration_exception);
     }
     return transformer;
   }
 
   /***
    * Remembers the XSLT created transformer factory, so that only one is being created
    */
   private TransformerFactory _transformer_factory = null;
 
   /***
    * This is the method that should always be invoked in order to create an XSLT transformer factory.
    *
    * @return a fresh new factory that can be used furtherly in order to create XSLT transformers
    * @throws BuildException if the factory could not be properly created
    */
   private TransformerFactory createATransformerFactory()
     throws BuildException
   {
     if (_transformer_factory != null)
     {
       return _transformer_factory;
     }
     TransformerFactory transformer_factory = null;
     log("Creating the XSLT transformer factory...", Project.MSG_DEBUG);
     if (_xslt_path == null)
     {
       log("Using an XSLT implementation taken from the classpath", Project.MSG_VERBOSE);
       try
       {
         // We set the XSLT Java system property right now, because we make use from now
         // Sets the XSLT implementation: the default one will be used if no special one is being asked for
         final String property_name = "javax.xml.transform.TransformerFactory";
         if (_xslt_transformer_factory_class_name != null)
         {
           log("The previous value of the '" + property_name + "' was '" +
             System.getProperty(property_name, _xslt_transformer_factory_class_name) + "'", Project.MSG_DEBUG);
           System.setProperty(property_name, _xslt_transformer_factory_class_name);
           log("Using the XSLT factory implementation '" + _xslt_transformer_factory_class_name + "'", Project.MSG_VERBOSE);
         }
         else
         {
           log("We use the '" + property_name + "' default value, which is '" +
             System.getProperty(property_name, _xslt_transformer_factory_class_name) + "'", Project.MSG_DEBUG);
         }
         transformer_factory = TransformerFactory.newInstance();
       }
       catch (TransformerFactoryConfigurationError transformer_factory_configuration_error)
       {
         throw new BuildException("Cannot create a XSLT factory", transformer_factory_configuration_error);
       }
     }
     else if (_xslt_transformer_factory_class_name != null && _xslt_path != null)
     {
       // Dependending on the Ant version, we use the specific class loader
       ClassLoader classloader = null;
       if (isAntInferiorTo160() == true)
       {
         final String classloader_fqn = "org.apache.tools.ant.AntClassLoader";
         try
         {
           Class ant_classloader_class = Class.forName(classloader_fqn);
           Constructor constructor = ant_classloader_class.getConstructor(new Class[]{Project.class, Path.class, boolean.class});
           // It is very important to use the parent classloader first, otherwise you may get 'java.lang.LinkageError'
           // under Ant V1.5!
           classloader = (ClassLoader) constructor.newInstance(new Object[]{getProject(), new Path(getProject()), new Boolean(true)});
         }
         catch (Exception exception)
         {
           final String message = "Cannot create an instance of the Ant classloader '" + classloader_fqn + "'";
           log(message, Project.MSG_ERR);
           throw new BuildException(message, exception);
         }
       }
       else
       {
         final String classloader_fqn = "org.apache.tools.ant.loader.AntClassLoader2";
         try
         {
           Class ant_classloader_class = Class.forName(classloader_fqn);
           classloader = (ClassLoader) ant_classloader_class.newInstance();
           ant_classloader_class.getMethod("setProject", new Class[]{Project.class}).invoke(classloader, new Object[]{getProject()});
         }
         catch (Exception exception)
         {
           final String message = "Cannot create an instance of the Ant classloader '" + classloader_fqn + "'";
           log(message, Project.MSG_ERR);
           throw new BuildException(message, exception);
         }
       }
       AntClassLoader ant_classloader = (AntClassLoader) classloader;
       //ant_classloader.setIsolated(true);
       for (int index = 0; index < _xslt_path.list().length; index++)
       {
         String path = _xslt_path.list()[index];
         ant_classloader.addPathElement(path);
       }
 
       Class transformer_factory_class = null;
       try
       {
         transformer_factory_class = Class.forName(_xslt_transformer_factory_class_name, false, ant_classloader);
       }
       catch (ClassNotFoundException class_not_found_exception)
       {
         final String message = "Cannot find the class '" + _xslt_transformer_factory_class_name + "', which is required";
         log(message, Project.MSG_ERR);
         throw new BuildException(message, class_not_found_exception);
       }
       try
       {
         Object object = transformer_factory_class.newInstance();
         transformer_factory = (TransformerFactory) object;
       }
       catch (InstantiationException instantiation_exception)
       {
         final String message = "Cannot create an instance of the class '" + _xslt_transformer_factory_class_name + "'";
         log(message, Project.MSG_ERR);
         throw new BuildException(message, instantiation_exception);
       }
       catch (IllegalAccessException illegal_access_exception)
       {
         final String message = "Cannot create an instance of the class '" + _xslt_transformer_factory_class_name + "'";
         log(message, Project.MSG_ERR);
         throw new BuildException(message, illegal_access_exception);
       }
     }
     log("... XSLT factory created", Project.MSG_DEBUG);
     final String transformer_factory_actual_class_name = transformer_factory.getClass().getName();
     log("Using the XSLT TransformerFactory implementation '" + transformer_factory_actual_class_name + "'",
       Project.MSG_VERBOSE);
     _transformer_factory = transformer_factory;
     return transformer_factory;
   }
 
   /***
    * @return the name of the actual transformation factory FQN
    * @throws org.apache.tools.ant.BuildException if no implementation is being present in the classpath
    */
   private String getActualTransformerFactory
     ()
     throws BuildException
   {
     return createATransformerFactory().getClass().getName();
   }
 
   /***
    * The name of the main XSLT defaut layout transformation style sheet.
    */
   private final String _simple_xsl = "XMLReleaseNotes2HTML.xsl";
 
 }