You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@xalan.apache.org by gg...@apache.org on 2019/04/20 23:33:58 UTC

[xalan-java] annotated tag xalan_2_0_D02 created (now 25ce9a3)

This is an automated email from the ASF dual-hosted git repository.

ggregory pushed a change to annotated tag xalan_2_0_D02
in repository https://gitbox.apache.org/repos/asf/xalan-java.git.


      at 25ce9a3  (tag)
 tagging e690cd401785bfda7e53ba332e8a56bcc621ffd2 (commit)
      by No Author
      on Thu Nov 16 22:50:01 2000 +0000

- Log -----------------------------------------------------------------
This commit was manufactured by cvs2svn to create tag \'xalan_2_0_D02\'.
-----------------------------------------------------------------------

This annotated tag includes the following new commits:

     new e690cd4  This commit was manufactured by cvs2svn to create tag 'xalan_2_0_D02'.

The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.



---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@xalan.apache.org
For additional commands, e-mail: dev-help@xalan.apache.org


[xalan-java] 01/01: This commit was manufactured by cvs2svn to create tag 'xalan_2_0_D02'.

Posted by gg...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

ggregory pushed a commit to annotated tag xalan_2_0_D02
in repository https://gitbox.apache.org/repos/asf/xalan-java.git

commit e690cd401785bfda7e53ba332e8a56bcc621ffd2
Author: No Author <de...@apache.org>
AuthorDate: Thu Nov 16 22:50:01 2000 +0000

    This commit was manufactured by cvs2svn to create tag
    'xalan_2_0_D02'.
---
 xdocs/sources/trax/trax.xml      | 798 ---------------------------------------
 xdocs/style/dtd/spec.dtd         | 578 ----------------------------
 xdocs/style/stylesheets/spec.xsl | 220 -----------
 3 files changed, 1596 deletions(-)

diff --git a/xdocs/sources/trax/trax.xml b/xdocs/sources/trax/trax.xml
deleted file mode 100644
index 592cbaa..0000000
--- a/xdocs/sources/trax/trax.xml
+++ /dev/null
@@ -1,798 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE spec SYSTEM "../../style/dtd/spec.dtd">
-<spec> 
-  <title>Transformation API For XML (TrAX)</title><frontmatter> 
-  <pubdate>November 12, 2000</pubdate> 
-  <copyright>Copyright 2000 Java Community Process (Sun Microsystems,
-	 Inc.)</copyright> 
-  <author><firstname>Scott</firstname> 
-	 <surname>Boag</surname> 
-	 <orgname>IBM Research</orgname> 
-	 <address> 
-		<email>sboag@lotus.com</email> 
-	 </address> 
-  </author></frontmatter> <introduction> 
-  <title>Introduction</title> 
-  <para>This overview describes the set of APIs contained in
-	 <ulink url="package-summary.html">javax.xml.transform</ulink>. For the sake of brevity, these interfaces are referred to
-	 as TrAX (Transformations for XML). </para> 
-  <para>There is a broad need for Java applications to be able to transform XML
-	 and related tree-shaped data structures. In fact, XML is not normally very
-	 useful to an application without going through some sort of transformation,
-	 unless the semantic structure is used directly as data. Almost all XML-related
-	 applications need to perform transformations. Transformations may be described
-	 by Java code, Perl code, <ulink url="http://www.w3.org/TR/xslt">XSLT</ulink>
-	 Stylesheets, other types of script, or by proprietary formats. The inputs, one
-	 or multiple, to a transformation, may be a URL, XML stream, a DOM tree, SAX
-	 Events, or a proprietary format or data structure. The output types are the
-	 pretty much the same types as the inputs, but different inputs may need to be
-	 combined with different outputs.</para> 
-  <para>The great challenge of a transformation API is how to deal with all the
-	 possible combinations of inputs and outputs, without becoming specialized for
-	 any of the given types.</para> 
-  <para>The Java community will greatly benefit from a common API that will
-	 allow them to understand and apply a single model, write to consistent
-	 interfaces, and apply the transformations polymorphically. TrAX attempts to
-	 define a model that is clean and generic, yet fills general application
-	 requirements across a wide variety of uses. </para> 
-  <sect2> 
-	 <title>General Terminology</title> 
-	 <para>This section will explain some general terminology used in this
-		document. Technical terminology will be explained in the Model section. In many
-		cases, the general terminology overlaps with the technical terminology.</para> 
-	 <variablelist> 
-		<varlistentry> 
-		  <term>Tree</term> 
-		  <listitem>This term, as used within this document, describes an
-			 abstract structure that consists of nodes or events that may be produced by
-			 XML. A Tree physically may be a DOM tree, a series of well balanced parse
-			 events (such as those coming from a SAX2 ContentHander), a series of requests
-			 (the result of which can describe a tree), or a stream of marked-up
-			 characters.</listitem> 
-		</varlistentry> 
-		<varlistentry> 
-		  <term>Source Tree(s)</term> 
-		  <listitem>One or more trees that are the inputs to the
-			 transformation.</listitem> 
-		</varlistentry> 
-		<varlistentry> 
-		  <term>Result Tree(s)</term> 
-		  <listitem>One or more trees that are the output of the
-			 transformation.</listitem> 
-		</varlistentry> 
-		<varlistentry> 
-		  <term>Transformation</term> 
-		  <listitem>The processor of consuming a stream or tree to produce
-			 another stream or tree.</listitem> 
-		</varlistentry> 
-		<varlistentry> 
-		  <term>Identity (or Copy) Transformation</term> 
-		  <listitem>The process of transformation from a source to a result,
-			 making as few structural changes as possible and no informational changes. The
-			 term is somewhat loosely used, as the process is really a copy. from one
-			 "format" (such as a DOM tree, stream, or set of SAX events) to
-			 another.</listitem> 
-		</varlistentry> 
-		<varlistentry> 
-		  <term>Serialization</term> 
-		  <listitem>The process of taking a tree and turning it into a stream. In
-			 some sense, a serialization is a specialized transformation.</listitem> 
-		</varlistentry> 
-		<varlistentry> 
-		  <term>Parsing</term> 
-		  <listitem>The process of taking a stream and turning it into a tree. In
-			 some sense, parsing is a specialized transformation.</listitem> 
-		</varlistentry> 
-		<varlistentry> 
-		  <term>Transformer</term> 
-		  <listitem>A Transformer is the object that executes the transformation.
-			 </listitem> 
-		</varlistentry> 
-		<varlistentry> 
-		  <term>Transformation instructions</term> 
-		  <listitem>Describes the transformation. A form of code, script, or
-			 simply a declaration or series of declarations.</listitem> 
-		</varlistentry> 
-		<varlistentry> 
-		  <term>Stylesheet</term> 
-		  <listitem>The same as "transformation instructions," except it is
-			 likely to be used in conjunction with <ulink
-			 url="http://www.w3.org/TR/xslt">XSLT</ulink>.</listitem> 
-		</varlistentry> 
-		<varlistentry> 
-		  <term>Templates</term> 
-		  <listitem>Another form of "transformation instructions." In the TrAX
-			 interface, this term is used to describe processed or compiled transformation
-			 instructions. The Source flows through a Templates object to be formed into the
-			 Result.</listitem> 
-		</varlistentry> 
-		<varlistentry> 
-		  <term>Processor</term> 
-		  <listitem>A general term for the thing that may both process the
-			 transformation instructions, and perform the transformation.</listitem> 
-		</varlistentry> 
-		<varlistentry> 
-		  <term>DOM</term> 
-		  <listitem>Document Object Model, specifically referring to the
-			 <termref link-url="http://www.w3.org/TR/DOM-Level-2 ">Document Object Model
-			 (DOM) Level 2 Specification</termref>.</listitem> 
-		</varlistentry> 
-		<varlistentry> 
-		  <term>SAX</term> 
-		  <listitem>Simple API for XML, specifically referring to the
-			 <termref link-url="http://www.megginson.com/SAX/SAX2">SAX 2.0
-			 release</termref>.</listitem> 
-		</varlistentry> 
-	 </variablelist> 
-  </sect2></introduction><requirements> 
-  <title>Requirements</title> 
-  <para>The following requirements have been determined from broad experience
-	 with XML projects from the various members participating on the JCP.</para> 
-  <orderedlist> 
-	 <listitem id="requirement-simple">TrAX must provide a clean, simple
-		interface for simple uses.</listitem> 
-	 <listitem id="requirement-general">TrAX must be powerful enough to be
-		applied to a wide range of uses, such as, e-commerce, content management,
-		server content delivery, and client applications.</listitem> 
-	 <listitem id="requirement-optimizeable">A processor that implements a TrAX
-		interface must be optimizeable. Performance is a critical issue for most
-		transformation use cases.</listitem> 
-	 <listitem id="requirement-compiled-model">As a specialization of the above
-		requirement, a TrAX processor must be able to support a compiled model, so that
-		a single set of transformation instructions can be compiled, optimized, and
-		applied to a large set of input sources.</listitem> 
-	 <listitem id="requirement-independence">TrAX must not be dependent an any
-		given type of transformation instructions. For instance, it must remain
-		independent of <ulink url="http://www.w3.org/TR/xslt">XSLT</ulink>.</listitem> 
-	 <listitem id="requirement-from-dom">TrAX must be able to allow processors
-		to transform DOM trees.</listitem> 
-	 <listitem id="requirement-to-dom">TrAX must be able to allow processors to
-		produce DOM trees.</listitem> 
-	 <listitem id="requirement-from-sax">TrAX must allow processors to transform
-		SAX events.</listitem> 
-	 <listitem id="requirement-to-sax">TrAX must allow processors to produce SAX
-		events.</listitem> 
-	 <listitem id="requirement-from-stream">TrAX must allow processors to
-		transform streams of XML.</listitem> 
-	 <listitem id="requirement-to-stream">TrAX must allow processors to produce
-		XML, HTML, and other types of streams.</listitem> 
-	 <listitem id="requirement-combo-input-output">TrAX must allow processors to
-		implement the various combinations of inputs and outputs within a single
-		processor.</listitem> 
-	 <listitem id="requirement-limited-input-output">TrAX must allow processors
-		to implement only a limited set of inputs. For instance, it should be possible
-		to write a processor that implements the TrAX interfaces and that only
-		processes DOM trees, not streams or SAX events.</listitem> 
-	 <listitem id="requirement-proprietary-data-structures">TrAX should allow a
-		processor to implement transformations of proprietary data structures. For
-		instance, it should be possible to implement a processor that provides TrAX
-		interfaces that performs transformation of JDOM trees.</listitem> 
-	 <listitem id="requirement-serialization-props">TrAX must allow the setting
-		of serialization properties, without constraint as to what the details of those
-		properties are.</listitem> 
-	 <listitem id="requirement-setting-parameters">TrAX must allow the setting
-		of parameters to the transformation instructions.</listitem> 
-	 <listitem id="requirement-namespaced-properties">TrAX must support the
-		setting of parameters and properties as XML Namespaced items (i.e., qualified
-		names).</listitem> 
-	 <listitem id="requirement-relative-url-resolution">TrAX must support URL
-		resolution from within the transformation, and have it return the needed data
-		structure.</listitem> 
-	 <listitem id="requirement-error-reporting">TrAX must have a mechanism for
-		reporting errors and warnings to the calling application.</listitem> 
-  </orderedlist> </requirements> <model> 
-  <title>Model</title> 
-  <para>The section defines the abstract model for TrAX, apart from the details
-	 of the interfaces.</para> 
-  <para>A TRaX <termref
-	 link-url="pattern-TransformerFactory">TransformerFactory</termref> is an object
-	 that processes transformation instructions, and produces
-	 <termref link-url="pattern-Templates">Templates</termref> (in the technical
-	 terminology). A <termref link-url="pattern-Templates">Templates</termref>
-	 object provides a <termref
-	 link-url="pattern-Transformer">Transformer</termref>, which transforms one or
-	 more <termref link-url="pattern-Source">Source</termref>s into one or more
-	 <termref link-url="pattern-Result">Result</termref>s.</para> 
-  <para>To use the TRaX interface, you create a
-	 <termref link-url="pattern-TransformerFactory">TransformerFactory</termref>,
-	 which may directly provide a <termref
-	 link-url="pattern-Transformers">Transformers</termref>, or which can provide
-	 <termref link-url="pattern-Templates">Templates</termref> from a variety of
-	 <termref link-url="pattern-Source">Source</termref>s. The
-	 <termref link-url="pattern-Templates">Templates</termref> object is a processed
-	 or compiled representation of the transformation instructions, and provides a
-	 <termref link-url="pattern-Transformer">Transformer</termref>. The
-	 <termref link-url="pattern-Transformer">Transformer</termref> processes a
-	 <termref link-url="pattern-Transformer">Source</termref> according to the
-	 instructions found in the <termref
-	 link-url="pattern-Templates">Templates</termref>, and produces a
-	 <termref link-url="pattern-Result">Result</termref>.</para> 
-  <para>The process of transformation from a tree, either in the form of an
-	 object model, or in the form of parse events, into a stream, is known as
-	 <termref>serialization</termref>. We believe this is the most suitable term for
-	 this process, despite the overlap with Java object serialization.</para> 
-  <patterns module="TRaX"> <pattern><pattern-name
-  id="pattern-Processor">Processor</pattern-name><intent>Generic concept for the
-  set of objects that implement the TrAX interfaces.</intent>
-  <responsibilities>Create compiled transformation instructions, transform
-  sources, and manage transformation parameters and
-  properties.</responsibilities><thread-safety>Only the Templates object can be
-  used concurrently in multiple threads. The rest of the processor does not do
-  synchronized blocking, and so may not be used to perform multiple concurrent
-  operations.</thread-safety></pattern><pattern> 
-  <pattern-name id="pattern-TransformerFactory">TransformerFactory</pattern-name>
-  <intent>Serve as a vendor-neutral Processor interface for
-  <ulink url="http://www.w3.org/TR/xslt">XSLT</ulink> and similar
-  processors.</intent> <responsibilities>Serve as a factory for a concrete
-  implementation of an TransformerFactory, serve as a direct factory for
-  Transformer objects, serve as a factory for Templates objects, and manage
-  processor specific features.</responsibilities> <thread-safety>A
-  TransformerFactory may not perform mulitple concurrent
-  operations.</thread-safety> </pattern> <pattern> 
-  <pattern-name id="pattern-Templates">Templates</pattern-name> <intent>The
-  runtime representation of the transformation instructions.</intent> 
-  <responsibilities>A data bag for transformation instructions; act as a factory
-  for Transformers.</responsibilities> <thread-safety>Threadsafe for concurrent
-  usage over multiple threads once construction is complete.</thread-safety>
-  </pattern> <pattern> <pattern-name
-  id="pattern-Transformer">Transformer</pattern-name> <intent>Act as a per-thread
-  execution context for transformations, act as an interface for performing the
-  transformation.</intent><responsibilities>Perform the
-  transformation.</responsibilities> <thread-safety>Only one instance per thread
-  is safe.</thread-safety> <notes>The Transformer is bound to the Templates
-  object that created it.</notes> </pattern> <pattern> 
-  <pattern-name id="pattern-Source">Source</pattern-name> <intent>Serve as a
-  single vendor-neutral object for multiple types of input.</intent> 
-  <responsibilities>Act as simple data holder for System IDs, DOM nodes, streams,
-  etc.</responsibilities> <thread-safety>Threadsafe concurrently over multiple
-  threads for read-only operations; must be synchronized for edit
-  operations.</thread-safety> </pattern><pattern> 
-  <pattern-name id="pattern-Result">Result</pattern-name> 
-  <potential-alternate-name>ResultTarget</potential-alternate-name> <intent>Serve
-  as a single object for multiple types of output, so there can be simple process
-  method signatures.</intent> <responsibilities>Act as simple data holder for
-  output stream, DOM node, ContentHandler, etc.</responsibilities> 
-  <thread-safety>Threadsafe concurrently over multiple threads for read-only,
-  must be synchronized for edit.</thread-safety> </pattern> </patterns></model> 
-  <sect1 id="package"> 
-	 <title>javax.xml.transform</title> 
-	 <para>This package defines the generic <ulink url="trax.html">TrAX</ulink> APIs for processing transformation
-		instructions, and performing a transformation from source to result. These
-		interfaces have no dependencies on SAX or the DOM standard, and try to make as
-		few assumptions as possible about the details of the source and result of a
-		transformation. It achieves this by defining 
-		<plink>javax.xml.transform.Source</plink> and 
-		<plink>javax.xml.transform.Result</plink> interfaces.</para> 
-	 <para>To define concrete classes for the user, TrAX defines specializations
-		of the interfaces found at the TrAX root level. These interfaces are found in 
-		<plink>javax.xml.transform.sax</plink>, <plink>javax.xml.transform.dom</plink>,
-		and <plink>javax.xml.transform.stream</plink>.</para> 
-	 <para>The following illustrates a simple transformation from input URI to
-		result stream.</para> 
-	 <programlisting>    // Create a transform factory instance.
-    TransformerFactory tfactory = TransformerFactory.newInstance();
-    
-    // Create a transformer for the stylesheet.
-    Transformer transformer 
-      = tfactory.newTransformer(new StreamSource(xslID));
-    
-    // Transform the source XML to System.out.
-    transformer.transform( new StreamSource(sourceID),
-                           new StreamResult(System.out));
-</programlisting> 
-	 <sect2> 
-		<title>Creating Objects</title> 
-		<para>TrAX allows a concrete 
-		  <plink>javax.xml.transform.TransformerFactory</plink> object to be created from
-		  the static function 
-		  <plink>javax.xml.transform.TransformerFactory#newInstance</plink>. The
-		  "javax.xml.transform.TransformerFactory" system property determines which
-		  factory implementation to instantiate. This property names a concrete subclass
-		  of the TransformerFactory abstract class. If this system property is not
-		  defined, a platform default is used.</para> 
-	 </sect2> 
-	 <sect2> 
-		<title>Specification of Inputs and Outputs</title> 
-		<para>TrAX defines two interface objects called 
-		  <plink>javax.xml.transform.Source</plink> and 
-		  <plink>javax.xml.transform.Result</plink>. In order to pass Source and Result
-		  objects to the TrAX interfaces, concrete classes must be used. TrAX defines
-		  three concrete representations for each of these objects: 
-		  <plink>javax.xml.transform.stream.StreamSource</plink> and 
-		  <plink>javax.xml.transform.stream.StreamResult</plink>,
-		  <plink>javax.xml.transform.sax.SAXSource</plink> and 
-		  <plink>javax.xml.transform.sax.SAXResult</plink>, and 
-		  <plink>javax.xml.transform.dom.DOMSource</plink> and 
-		  <plink>javax.xml.transform.dom.DOMResult</plink>. Each of these objects defines
-		  a FEATURE string (which is i the form of a URL), which can be passed into 
-		  <plink>javax.xml.transform.TransformerFactory#getFeature</plink> to see if the
-		  given type of Source or Result object is supported. For instance, to test if a
-		  DOMSource and a StreamResult is supported, you can apply the following
-		  test.</para> 
-		<programlisting>    TransformerFactory tfactory = TransformerFactory.newInstance();
-
-    if (tfactory.getFeature(DOMSource.FEATURE) &amp;&amp; tfactory.getFeature(StreamResult.FEATURE))
-    {
-       ...
-    }</programlisting>
-  </sect2> 
-  <sect2> 
-	 <title id="qname-delimiter">Qualified Name representation</title> 
-	 <para><ulink url="http://www.w3.org/TR/REC-xml-names">Namespaces</ulink>
-		present something of a problem area when dealing with XML objects. Qualified
-		Names appear in XML markup as prefixed names. But the prefixes themselves do
-		not hold identity. Rather, it is the URIs that they contextually map to that
-		hold the identity. Therefore, when passing a Qualified Name like "xyz:foo"
-		among Java programs, one must provide a means to map "xyz" to a namespace.
-		</para> 
-	 <para>One solution has been to create a "QName" object that holds the
-		namespace URI, as well as the prefix and local name, but this is not always an
-		optimal solution, as when, for example, you want to use unique strings as keys
-		in a dictionary object. Not having a string representation also makes it
-		difficult to specify a namespaced identity outside the context of an XML
-		document.</para> 
-	 <para>In order to pass namespaced values to transformations, for instance
-		as a set of properties to the Serializer, this specification defines that a
-		String "qname" object parameter be passed as two-part string, the namespace URI
-		enclosed in curly braces ({}), followed by the local name. If the qname has a
-		null URI, then the String object only contains the local name. An application
-		can safely check for a non-null URI by testing to see if the first character of
-		the name is a '{' character.</para> 
-	 <para>For example, if a URI and local name were obtained from an element
-		defined with &lt;xyz:foo xmlns:xyz="http://xyz.foo.com/yada/baz.html"/&gt;,
-		then the TrAX Qualified Name would be "{http://xyz.foo.com/yada/baz.html}foo".
-		Note that the prefix is lost.</para> 
-  </sect2> 
-  <sect2> 
-	 <title>Result Tree Serialization</title> 
-	 <para>Serialization of the result tree to a stream can be controlled with
-		the <plink>javax.xml.transform.Transformer#setOutputProperties</plink> and the 
-		<plink>javax.xml.transform.Transformer#setOutputProperty</plink> methods.
-		Strings that match the <ulink url="http://www.w3.org/TR/xslt#output">XSLT
-		specification for xsl:output attributes</ulink> can be referenced from the 
-		<plink>javax.xml.transform.OutputKeys</plink> class. Other strings can be
-		specified as well. If the transformer does not recognize an output key, a 
-		<plink>java.lang.IllegalArgumentException</plink> is thrown, unless the 
-		<emphasis>unless</emphasis> the key name is <link
-		linkend="qname-delimiter">namespace qualified</link>. Output key names that are
-		qualified by a namespace are ignored or passed on to the serializer
-		mechanism.</para> 
-	 <para>If all that is desired is the simple identity transformation of a
-		source to a result, then <plink>javax.xml.transform.TransformerFactory</plink>
-		provides a
-		<plink>javax.xml.transform.TransformerFactory#newTransformer()</plink> method
-		with no arguments. This method creates a Transformer that effectively copies
-		the source to the result. This method may be used to create a DOM from SAX
-		events or to create an XML or HTML stream from a DOM or SAX events. The
-		following example illustrates the serialization of a DOM node to an XML
-		stream.</para> 
-	 <programlisting>    TransformerFactory tfactory = TransformerFactory.newInstance();    
-    Transformer serializer = tfactory.newTransformer();
-    Properties oprops = new Properties();
-    oprops.put("method", "html");
-    oprops.put("indent-amount", "2");
-    serializer.setOutputProperties(oprops);
-    serializer.transform(new DOMSource(doc), 
-                         new StreamResult(System.out));</programlisting> 
-</sect2> 
-<sect2> 
-  <title>Exceptions and Error Reporting</title> 
-  <para>The TrAX APIs throw three types of specialized exceptions. A
-	 <plink>javax.xml.transform.TFactoryConfigurationError</plink> is parallel to
-	 the <plink>javax.xml.parsers.FactoryConfigurationError</plink>, and is thrown
-	 when a configuration problem with the TransformerFactory exists. This error
-	 will typically be thrown when the transformation factory class specified with
-	 the "javax.xml.transform.TransformerFactory" system property cannot be found or
-	 instantiated.</para> 
-  <para>A <plink>javax.xml.transform.TransformerConfigurationException</plink>
-	 may be thrown if for any reason a Transformer can not be created. A
-	 TransformerConfigurationException may be thrown if there is a syntax error in
-	 the transformation instructions, for example when
-	 <plink>javax.xml.transform.TransformerFactory#newTransformer</plink> is
-	 called.</para> 
-  <para><plink>javax.xml.transform.TransformerException</plink> is a general
-	 exception that occurs during the course of a transformation. A transformer
-	 exception may wrap another exception, and if any of the
-	 <plink>javax.xml.transform.TransformerException#printStackTrace()</plink>
-	 methods are called on it, it will produce a list of stack dumps, starting from
-	 the most recent. The transformer exception also provides a
-	 <plink>javax.xml.transform.SourceLocator</plink> object which indicates where
-	 in the source tree or transformation instructions the error occurred.
-	 <plink>javax.xml.transform.TransformerException#getMessageAndLocation()</plink>
-	 may be called to get an error message with location info, and
-	 <plink>javax.xml.transform.TransformerException#getLocationAsString()</plink>
-	 may be called to get just the location string.</para> 
-  <para>Transformation warnings and errors are normally first sent to a
-	 <plink>javax.xml.transform.ErrorListener</plink>, at which point the
-	 implementor may decide to report the error or warning, and may decide to throw
-	 an exception for a non-fatal error. The error listener may be set via
-	 <plink>javax.xml.transform.TransformerFactory#setErrorListener</plink> for
-	 reporting errors that have to do with syntax errors in the transformation
-	 instructions, or via
-	 <plink>javax.xml.transform.Transformer#setErrorListener</plink> to report
-	 errors that occur during the transformation. The error listener on both objects
-	 should always be valid and non-null, whether set by the user or a default
-	 implementation provided by the processor.</para> 
-</sect2> 
-<sect2> 
-  <title>Resolution of URIs within a transformation</title> 
-  <para>TrAX provides a way for URIs referenced from within the stylesheet
-	 instructions or within the transformation to be resolved by the calling
-	 application. This can be done by creating a class that implements the
-	 URIResolver interface, with its one method,
-	 <plink>javax.xml.transform.URIResolver#resolve</plink>, and use this class to
-	 set the URI resolution for the transformation instructions or transformation
-	 with <plink>javax.xml.transform.TransformerFactory#setURIResolver</plink> or
-	 <plink>javax.xml.transform.Transformer#setURIResolver</plink>. The
-	 URIResolver.resolve method takes two String arguments, the URI found in the
-	 stylesheet instructions or built as part of the transformation process, and the
-	 base URI in effect when the URI passed as the first argument was encountered.
-	 The returned <plink>javax.xml.transform.Source</plink> object must be usable by
-	 the transformer, as specified in its implemented features.</para> 
-  <para>The following example illustrates the use of the URI resolver to
-	 resolve URIs to DOM nodes, in a transformation whose input is totally DOM
-	 based.</para> 
-  <programlisting>    TransformerFactory tfactory = TransformerFactory.newInstance();
-
-    if (tfactory.getFeature(DOMSource.FEATURE) &amp;&amp; tfactory.getFeature(StreamResult.FEATURE))
-    {
-      DocumentBuilderFactory dfactory =
-                                       DocumentBuilderFactory.newInstance();
-      dfactory.setNamespaceAware(true); // Always, required for XSLT
-      DocumentBuilder docBuilder = dfactory.newDocumentBuilder();
-      
-      // Set up to resolve URLs that correspond to our inc1.xsl, 
-      // to a DOM node. Use an anonymous class for the URI resolver.
-      final Node xslInc1 = docBuilder.parse("xsl/inc1/inc1.xsl");
-      final Node xslInc2 = docBuilder.parse("xsl/inc2/inc2.xsl");
-      tfactory.setURIResolver(new URIResolver() { 
-        public Source resolve(String href, String base) 
-        throws TransformerException
-        {
-        // ignore base because we're lazy, or we don't care.
-        return (href.equals("inc1/inc1.xsl"))  
-        ? new DOMSource(xslInc1) : 
-          (href.equals("inc2/inc2.xsl")) 
-          ? new DOMSource(xslInc2) : null;
-        }});
-
-      // The TransformerFactory will call the anonymous URI 
-      // resolver set above when it encounters 
-      // &lt;xsl:include href="inc1/inc1.xsl"/&gt;
-      Templates templates 
-        = tfactory.newTemplates(new DOMSource(docBuilder.parse(xslID), xslID));
-
-      // Get a transformer from the templates.
-      Transformer transformer = templates.newTransformer();
-      
-      // Set up to resolve URLs that correspond to our foo2.xml, to 
-      // a DOM node.  Use an anonymous class for the URI resolver.
-      // Be sure to return the same DOM tree every time for the 
-      // given URI.
-      final Node xmlSubdir1Foo2Node = docBuilder.parse("xml/subdir1/foo2.xml");
-      transformer.setURIResolver(new URIResolver() { 
-        public Source resolve(String href, String base) 
-        throws TransformerException
-        {
-        // ignore base because we're lazy, or we don't care.
-        return (href.equals("subdir1/foo2.xml"))  
-        ? new DOMSource(xmlSubdir1Foo2Node) : null;
-        }});
-
-      // Now the transformer will call our anonymous URI resolver 
-      // when it encounters the document('subdir1/foo2.xml') invocation.
-      transformer.transform(new DOMSource(docBuilder.parse(sourceID), sourceID), 
-                            new StreamResult(System.out));
-    }
-</programlisting>
-</sect2> 
-<sect2 id="specialized-packages"> 
-<title>Specialized Packages</title> 
-<sect3> 
-  <title>javax.xml.transform.stream</title> 
-  <para>This package implements stream- and URI- specific transformation APIs.
-	 </para> 
-  <para>The <plink>javax.xml.transform.stream.StreamSource</plink> class
-	 provides methods for specifying <plink>java.io.InputStream</plink> input,
-	 <plink>java.io.Reader</plink> input, and URL input in the form of strings. Even
-	 if an input stream or reader is specified as the source,
-	 <plink>javax.xml.transform.stream.StreamSource#setSystemId</plink> should still
-	 be called, so that the transformer can know from where it should resolve
-	 relative URIs. The public identifier is always optional: if the application
-	 writer includes one, it will be provided as part of the
-	 <plink>javax.xml.transform.SourceLocator</plink> information.</para> 
-  <para>The <plink>javax.xml.transform.stream.StreamResult</plink> class
-	 provides methods for specifying <plink>java.io.OutputStream</plink>,
-	 <plink>java.io.Writer</plink>, or an output system ID, as the output of the
-	 transformation result.</para> 
-  <para>Normally streams should be used rather than readers or writers, for
-	 both the Source and Result, since readers and writers already have the encoding
-	 established to and from the internal Unicode format. However, there are times
-	 when it is useful to write to a character stream, such as when using a
-	 StringWriter in order to write to a String, or in the case of reading source
-	 XML from a StringReader.</para> 
-  <para>The following code fragment illustrates the use of the stream Source
-	 and Result objects.</para> 
-  <programlisting>    // Create a TransformerFactory instance.
-    TransformerFactory tfactory = TransformerFactory.newInstance();
-
-    InputStream xslIS = new BufferedInputStream(new FileInputStream(xslID));
-    StreamSource xslSource = new StreamSource(xslIS);
-    // Note that if we don't do this, relative URLs cannot be resolved correctly!
-    xslSource.setSystemId(xslID);
-
-    // Create a transformer for the stylesheet.
-    Transformer transformer = tfactory.newTransformer(xslSource);
-    
-    InputStream xmlIS = new BufferedInputStream(new FileInputStream(sourceID));
-    StreamSource xmlSource = new StreamSource(xmlIS);
-    // Note that if we don't do this, relative URLs cannot be resolved correctly!
-    xmlSource.setSystemId(sourceID);
-    
-    // Transform the source XML to System.out.
-    transformer.transform( xmlSource, new StreamResult(System.out));
-</programlisting>
-</sect3> 
-<sect3> 
-<title>javax.xml.transform.sax</title> 
-<para>This package implements SAX2-specific transformation APIs. It provides
-  classes which allow input from <plink>org.xml.sax.ContentHandler</plink>
-  events, and also classes that produce org.xml.sax.ContentHandler events. It
-  also provides methods to set the input source as an
-  <plink>org.xml.sax.XMLReader</plink>, or to use a
-  <plink>org.xml.sax.InputSource</plink> as the source. It also allows the
-  creation of a <plink>org.xml.sax.XMLFilter</plink>, which enables
-  transformations to "pull" from other transformations, and lets the transformer
-  to be used polymorphically as an <plink>org.xml.sax.XMLReader</plink>.</para> 
-<para>The <plink>javax.xml.transform.sax.SAXSource</plink> class allows the
-  setting of an <plink>org.xml.sax.XMLReader</plink> to be used for "pulling"
-  parse events, and an <plink>org.xml.sax.InputSource</plink> that may be used to
-  specify the SAX source.</para> 
-<para>The <plink>javax.xml.transform.sax.SAXResult</plink> class allows the
-  setting of a <plink>org.xml.sax.ContentHandler</plink> to be the receiver of
-  SAX2 events from the transformation. The following code fragment illustrates
-  the use of the SAXSource and SAXResult objects.</para> 
-<programlisting>    TransformerFactory tfactory = TransformerFactory.newInstance();
-
-    // Does this factory support SAX features?
-    if (tfactory.getFeature(SAXSource.FEATURE) &amp;&amp; tfactory.getFeature(SAXResult.FEATURE))
-    {      
-      // Get a transformer.
-      Transformer transformer 
-        = tfactory.newTransformer(new StreamSource(xslID));
-      
-      // Create an reader for reading.
-      XMLReader reader = XMLReaderFactory.createXMLReader();
-
-      transformer.transform(new SAXSource(reader, new InputSource(sourceID)),
-                            new SAXResult(new ExampleContentHandler()));
-    }
-</programlisting> 
-<para>The <plink>javax.xml.transform.sax.SAXTransformerFactory</plink> extends
-  <plink>javax.xml.transform.TransformerFactory</plink> to provide factory
-  methods for creating <plink>javax.xml.transform.sax.TemplatesHandler</plink>,
-  <plink>javax.xml.transform.sax.TransformerHandler</plink>, and
-  <plink>org.xml.sax.XMLReader</plink> instances.</para> 
-<para>To obtain a <plink>javax.xml.transform.sax.SAXTransformerFactory</plink>,
-  the caller must cast the <plink>javax.xml.transform.TransformerFactory</plink>
-  instance returned from
-  <plink>javax.xml.transform.TransformerFactory#newInstance</plink>. For
-  example:</para> 
-<programlisting>    TransformerFactory tfactory = TransformerFactory.newInstance();
-
-    // Does this factory support the SAXTransformerFactory feature?
-    if (tfactory.getFeature(SAXTransformerFactory.FEATURE))
-    {
-      // If so, we can safely cast.
-      SAXTransformerFactory stfactory = ((SAXTransformerFactory) tfactory);
-      
-      // A TransformerHandler is a ContentHandler that will listen for 
-      // SAX events, and transform them to the result.
-      TransformerHandler handler 
-        = stfactory.newTransformerHandler(new StreamSource(xslID));
-      // ...
-    }
-</programlisting> 
-<para>The <plink>javax.xml.transform.sax.TransformerHandler</plink> interface
-  allows a transformation to be created from SAX2 parse events, which is a "push"
-  model rather than the "pull" model that normally occurs for a transformation.
-  Normal parse events are received through the
-  <plink>org.xml.sax.ContentHandler</plink> interface, lexical events such as
-  startCDATA and endCDATA are received through the
-  <plink>org.xml.sax.ext.LexicalHandler</plink> interface, and events that signal
-  the start or end of disabling output escaping are received via
-  <plink>org.xml.sax.ContentHandler#processingInstruction</plink>, with the
-  target parameter being
-  <plink>javax.xml.transform.Result#PI_DISABLE_OUTPUT_ESCAPING</plink> and
-  <plink>javax.xml.transform.Result#PI_ENABLE_OUTPUT_ESCAPING</plink>. If
-  parameters, output properties, or other features need to be set on the
-  Transformer handler, a <plink>javax.xml.transform.Transformer</plink> reference
-  will need to be obtained from
-  <plink>javax.xml.transform.sax.TransformerHandler#getTransformer</plink>, and
-  the methods invoked from that reference. The following illustrates the feeding
-  of SAX events from an <plink>org.xml.sax.XMLReader</plink> to a
-  Transformer.</para> 
-<programlisting>    TransformerFactory tfactory = TransformerFactory.newInstance();
-
-    // Does this factory support SAX features?
-    if (tfactory.getFeature(SAXTransformerFactory.FEATURE))
-    {
-      // If so, we can safely cast.
-      SAXTransformerFactory stfactory = ((SAXTransformerFactory) tfactory);
-      
-      // A TransformerHandler is a ContentHandler that will listen for 
-      // SAX events, and transform them to the result.
-      TransformerHandler handler 
-        = stfactory.newTransformerHandler(new StreamSource(xslID));
-
-      // Set the result handling to be a serialization to System.out.
-      handler.setResult(new StreamResult(System.out));
-      
-      handler.getTransformer().setParameter("a-param",
-                                            "hello to you!");
-      
-      // Create a reader, and set it's content handler to be the TransformerHandler.
-      XMLReader reader = XMLReaderFactory.createXMLReader();
-      reader.setContentHandler(handler);
-      
-      // It's a good idea for the parser to send lexical events.
-      // The TransformerHandler is also a LexicalHandler.
-      reader.setProperty("http://xml.org/sax/properties/lexical-handler", handler);
-      
-      // Parse the source XML, and send the parse events to the TransformerHandler.
-      reader.parse(sourceID);
-    }
-</programlisting> 
-<para>The <plink>javax.xml.transform.sax.TemplatesHandler</plink> interface
-  allows the creation of <plink>javax.xml.transform.Templates</plink> objects
-  from SAX2 parse events. Once the <plink>org.xml.sax.ContentHandler</plink>
-  events are complete, the Templates object may be obtained from
-  <plink>javax.xml.transform.sax.TemplatesHandler#getTemplates</plink>. Note that 
-  <plink>javax.xml.transform.sax.TemplatesHandler#setSystemId</plink> should
-  normally be called in order to establish a base system ID from which relative
-  URLs may be resolved. The following code fragment illustrates the creation of a
-  Templates object from SAX2 events sent from an XMLReader.</para> 
-<programlisting>    TransformerFactory tfactory = TransformerFactory.newInstance();
-
-    // Does this factory support SAX features?
-    if (tfactory.getFeature(SAXTransformerFactory.FEATURE))
-    {
-      // If so, we can safely cast.
-      SAXTransformerFactory stfactory = ((SAXTransformerFactory) tfactory);
-      
-      // Have the factory create a special ContentHandler that will 
-      // create a Templates object.
-      TemplatesHandler handler = stfactory.newTemplatesHandler();
-      
-      // If you don't do this, the TemplatesHandler won't know how to 
-      // resolve relative URLs.
-      handler.setSystemId(xslID);
-      
-      // Create a reader, and set it's content handler to be the TemplatesHandler.
-      XMLReader reader = XMLReaderFactory.createXMLReader();
-      reader.setContentHandler(handler);
-      
-      // Parse the source XML, and send the parse events to the TemplatesHandler.
-      reader.parse(xslID);
-      
-      // Get the Templates reference from the handler.
-      Templates templates = handler.getTemplates();
-      
-      // Ready to transform.
-      Transformer transformer = templates.newTransformer();
-      transformer.transform(new StreamSource(sourceID), new StreamResult(System.out));
-    }
-</programlisting> 
-<para>The
-  <plink>javax.xml.transform.sax.SAXTransformerFactory#newXMLFilter</plink>
-  method allows the creation of a <plink>org.xml.sax.XMLFilter</plink>, which
-  encapsulates the SAX2 notion of a "pull" transformation. The following
-  illustrates several transformations chained together. Each filter points to a
-  parent <plink>org.xml.sax.XMLReader</plink>, and the final transformation is
-  caused by invoking <plink>org.xml.sax.XMLReader#parse</plink> on the final
-  reader in the chain.</para> 
-<programlisting>    TransformerFactory tfactory = TransformerFactory.newInstance();
-    
-    // Does this factory support SAX features?
-    if (tfactory.getFeature(SAXTransformerFactory.FEATURE))
-    {
-      Templates stylesheet1 = tfactory.newTemplates(new StreamSource(xslID_1));
-      Transformer transformer1 = stylesheet1.newTransformer();
-      
-      SAXTransformerFactory stf = (SAXTransformerFactory)tfactory;
-      XMLReader reader = XMLReaderFactory.createXMLReader();
-
-      XMLFilter filter1 = stf.newXMLFilter(new StreamSource(xslID_1));
-      XMLFilter filter2 = stf.newXMLFilter(new StreamSource(xslID_2));
-      XMLFilter filter3 = stf.newXMLFilter(new StreamSource(xslID_3));
-
-      // transformer1 will use a SAX parser as it's reader.    
-      filter1.setParent(reader);
-
-      // transformer2 will use transformer1 as it's reader.
-      filter2.setParent(filter1);
-
-      // transform3 will use transform2 as it's reader.
-      filter3.setParent(filter2);
-
-      filter3.setContentHandler(new ExampleContentHandler());
-      // filter3.setContentHandler(new org.xml.sax.helpers.DefaultHandler());
-
-      // Now, when you call transformer3 to parse, it will set  
-      // itself as the ContentHandler for transform2, and 
-      // call transform2.parse, which will set itself as the 
-      // content handler for transform1, and call transform1.parse, 
-      // which will set itself as the content listener for the 
-      // SAX parser, and call parser.parse(new InputSource("xml/foo.xml")).
-      filter3.parse(new InputSource(sourceID));
-    }</programlisting>
-</sect3> 
-<sect3> 
-<title>javax.xml.transform.dom</title> 
-<para>This package implements DOM-specific transformation APIs.</para> 
-<para>The <plink>javax.xml.transform.dom.DOMSource</plink> class allows the
-client of the TrAX implementation to specify a DOM
-<plink>org.w3c.dom.Node</plink> as the source of the input tree. The model of
-how the Transformer deals with the DOM tree in terms of mismatches with the
-<ulink url="http://www.w3.org/TR/xslt#data-model">XSLT data model</ulink> or
-other data models is beyond the scope of this document. Any of the nodes
-derived from <plink>org.w3c.dom.Node</plink> are legal input.</para>
-<para>The <plink>javax.xml.transform.dom.DOMResult</plink> class allows a
-<plink>org.w3c.dom.Node</plink> to be specified to which result DOM nodes will
-be appended. If an output node is not specified, the transformer will use 
-<plink>javax.xml.parsers.DocumentBuilder#newDocument</plink> to create an
-output <plink>org.w3c.dom.Document</plink> node. If a node is specified, it
-should be one of the following: <plink>org.w3c.dom.Document</plink>, 
-<plink>org.w3c.dom.Element</plink>, or 
-<plink>org.w3c.dom.DocumentFragment</plink>. Specification of any other node
-type is implementation dependent and undefined by this API. If the result is a 
-<plink>org.w3c.dom.Document</plink>, the output of the transformation must have
-a single element root to set as the document element.</para>
-<para>The <plink>javax.xml.transform.dom.DOMLocator</plink> node may be passed
-to <plink>javax.xml.transform.TransformerException</plink> objects, and
-retrieved by trying to cast the result of
-the <plink>javax.xml.transform.TransformerException#getLocator()</plink> method.
-The implementation has no responsibility to use a DOMLocator instead of
-a <plink>javax.xml.transform.SourceLocator</plink> (though line numbers and the
-like do not make much sense for a DOM), so the result of getLocator must always
-be tested with an instanceof. </para>
-<para>The following example performs a transformation using DOM nodes as input
-for the TransformerFactory, as input for the Transformer, and as the output of
-the transformation.</para>
-<programlisting>    TransformerFactory tfactory = TransformerFactory.newInstance();
-
-    // Make sure the TransformerFactory supports the DOM feature.
-    if (tfactory.getFeature(DOMSource.FEATURE) &amp;&amp; tfactory.getFeature(DOMResult.FEATURE))
-    {
-      // Use javax.xml.parsers to create our DOMs.
-      DocumentBuilderFactory dfactory = DocumentBuilderFactory.newInstance();
-      dfactory.setNamespaceAware(true); // do this always for XSLT
-      DocumentBuilder docBuilder = dfactory.newDocumentBuilder();
-      
-      // Create the Templates from a DOM.
-      Node xslDOM = docBuilder.parse(xslID);
-      DOMSource dsource = new DOMSource(xslDOM, xslID);
-      Templates templates = tfactory.newTemplates(dsource);
-
-      // Create the source tree in the form of a DOM.
-      Node sourceNode = docBuilder.parse(sourceID);
-      
-      // Create a DOMResult that the transformation will fill in.
-      DOMResult dresult = new DOMResult();
-      
-      // And transform from the source DOM tree to a result DOM tree.
-      Transformer transformer = templates.newTransformer();
-      transformer.transform(new DOMSource(sourceNode, sourceID), dresult);
-      
-      // The root of the result tree may now be obtained from 
-      // the DOMResult object.
-      Node out = dresult.getNode();
-      
-      // Serialize it to System.out for diagnostics.
-      Transformer serializer = tfactory.newTransformer();
-      serializer.transform(new DOMSource(out), new StreamResult(System.out));
-    }</programlisting>
-</sect3> 
-</sect2>
-</sect1>
-</spec>
\ No newline at end of file
diff --git a/xdocs/style/dtd/spec.dtd b/xdocs/style/dtd/spec.dtd
deleted file mode 100644
index 8720289..0000000
--- a/xdocs/style/dtd/spec.dtd
+++ /dev/null
@@ -1,578 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- ============================================================= -->
-<!--  MODULE:    spec DTD                                          -->
-<!--  VERSION:   1.0                                               -->
-<!--  DATE:      October 18, 2000                                  -->
-
-
-<!-- ============================================================= -->
-<!--                   ISO STANDARD SPECIAL CHARACTER SETS         -->
-<!-- ============================================================= -->
-<!--
-<!ENTITY % isolat1      PUBLIC
-"ISO 8879-1986//ENTITIES Added Latin 1//EN"
-"entities/ISOlat1.pen"
-                                                                    >
-
-<!ENTITY % isonum       PUBLIC
-"ISO 8879-1986//ENTITIES Numeric and Special Graphic//EN"
-"entities/ISOnum.pen"
-                                                                    >
-
-<!ENTITY % isopub       PUBLIC
-"ISO 8879-1986//ENTITIES Publishing//EN"
-"entities/ISOpub.pen"
-                                                                    >
-
-<!ENTITY % isotech      PUBLIC
-"ISO 8879-1986//ENTITIES General Technical//EN"
-"entities/ISOtech.pen"
-                                                                    >
-
-%isolat1; %isonum; %isopub; %isotech;
--->
-
-<!-- ============================================================= -->
-<!--                    parameter entities for content models      -->
-<!-- ============================================================= -->
-
-
-<!--                    list elements                              -->
-<!ENTITY % lists       "itemizedlist | orderedlist | variablelist"   >
-
-
-<!--                    linespecific elements                      -->
-<!--                    elements where line endings and whitespace
-                        are significant                            -->
-<!ENTITY % linespecific
-                       "literallayout | programlisting"              >
-
-
-<!--                    phrase-level elements                      -->
-<!--                    elements allowed at the same level as text -->
-<!ENTITY % phraselevel "citation | emphasis | inlinegraphic | link | plink |
-                        subscript | superscript | ulink | termref"   >
-
-
-<!--                    paragraph-level elements                   -->
-<!--                    elements (including paragraphs) allowed at
-                        the level of paragraphs                    -->
-<!ENTITY % paralevel   "%linespecific; | %lists; | note | para | issue |
-                        table | figure | graphic"                    >
-
-
-<!-- ============================================================= -->
-<!--                    parameter entities for attributes          -->
-<!-- ============================================================= -->
-
-
-<!--                    common attributes                          -->
-<!ENTITY % common.atts
-             "id         ID                                 #IMPLIED
-              link-url   CDATA                              #IMPLIED" >
-
-<!--                    graphic-related attributes                 -->
-<!ENTITY % graphic.atts
-            "fileref    CDATA                              #IMPLIED
-             alt        CDATA                              #IMPLIED
-             srccredit  CDATA                              #IMPLIED
-             width      NMTOKEN                            #IMPLIED
-             depth      NMTOKEN                            #IMPLIED
-             scale      NMTOKEN                            #IMPLIED
-             scalefit   NMTOKEN                            #IMPLIED" >
-
-<!-- ============================================================= -->
-<!--                    external modules                           -->
-<!-- ============================================================= -->
-
-<!--
-<!ENTITY % table.ent SYSTEM "table.ent"                              >
-%table.ent;
--->
-
-<!-- ============================================================= -->
-<!--                    element definitions                        -->
-<!-- ============================================================= -->
-
-
-<!--                    specification                              -->
-<!ELEMENT  spec         (title, frontmatter, introduction, requirements, model, sect1+,
-                         appendix*, bibliography?)                   >
-
-<!ATTLIST  spec
-            %common.atts;                                            >
-
-<!ELEMENT  frontmatter   (pubdate, copyright, author*, abstract?)    >
-
-<!--                    title                                      -->
-<!ELEMENT  title        (#PCDATA | %phraselevel;)*                   >
-<!ATTLIST  title
-            %common.atts;                                            >
-
-
-<!--                    issue                                      -->
-<!ELEMENT  issue        (#PCDATA | %phraselevel;)*                   >
-<!ATTLIST  issue
-            %common.atts;                                            >
-
-
-<!--                    publication date                           -->
-<!--                    publication date and, possibly, time       -->
-<!ELEMENT  pubdate      (#PCDATA)                                    >
-<!ATTLIST  pubdate
-            %common.atts;                                            >
-
-
-<!--                    copyright statement                        -->
-<!ELEMENT  copyright    (#PCDATA)                                    >
-<!--         id         unique identifier                          -->
-<!ATTLIST  copyright
-            %common.atts;                                            >
-
-
-<!--                    author                                     -->
-<!ELEMENT  author       (firstname, surname, jobtitle?, orgname?,
-                         address?)                                   >
-<!--         id         unique identifier                          -->
-<!ATTLIST  author
-            %common.atts;                                            >
-
-
-<!--                    abstract                                   -->
-<!ELEMENT  abstract     (para+)                                      >
-<!--         id         unique identifier                          -->
-<!ATTLIST  abstract
-            %common.atts;                                            >
-
-<!ELEMENT  introduction        (title, (((%paralevel;)+, sect2*) | sect2+)) >
-<!--         id         unique identifier                          -->
-<!ATTLIST  introduction
-            %common.atts;                                            >
-
-<!ELEMENT  requirements        (title, (((%paralevel;)+, sect2*) | sect2+)) >
-<!--         id         unique identifier                          -->
-<!ATTLIST  requirements
-            %common.atts; >    
-
-<!ELEMENT  model        (title, (((%paralevel;)+, patterns) | sect2+)) >
-<!--         id         unique identifier                          -->
-<!ATTLIST  model
-            %common.atts;                                            >
-
-<!ELEMENT  patterns        (pattern+) >
-<!--         id         unique identifier                          -->
-<!ATTLIST  patterns
-            %common.atts; 
-			module  CDATA                              #IMPLIED
-            > 
-                        
-<!ELEMENT  pattern        (pattern-name, potential-alternate-name?, intent, responsibilities, thread-safety, notes?) >
-<!--         id         unique identifier                          -->
-<!ATTLIST  pattern
-            %common.atts;  
-                                                      >
-<!ELEMENT  pattern-name        (#PCDATA | %phraselevel;)* >
-<!--         id         unique identifier                          -->
-<!ATTLIST  pattern-name
-            %common.atts; >
-            
-<!ELEMENT  potential-alternate-name        (#PCDATA | %phraselevel;)* >
-<!--         id         unique identifier                          -->
-<!ATTLIST  potential-alternate-name
-            %common.atts; >  
-
-<!ELEMENT  intent        (#PCDATA | %phraselevel;)* >
-<!--         id         unique identifier                          -->
-<!ATTLIST  intent
-            %common.atts; >  
-
-<!ELEMENT  responsibilities        (#PCDATA | %phraselevel;)* >
-<!--         id         unique identifier                          -->
-<!ATTLIST  responsibilities
-            %common.atts; >  
-
-<!ELEMENT  thread-safety        (#PCDATA | %phraselevel;)* >
-<!--         id         unique identifier                          -->
-<!ATTLIST  thread-safety
-            %common.atts; >
-
-<!ELEMENT  notes         (#PCDATA | %phraselevel;)*                   >
-<!--         id         unique identifier                          -->
-<!ATTLIST  notes
-            %common.atts;                                            >
-
-<!--         id         unique identifier                          -->
-<!ATTLIST  sect1
-            %common.atts;                                            >
-
-<!--                    section 1                                  -->
-<!ELEMENT  sect1        (title, (((%paralevel;)+, sect2*) | sect2+)) >						   
-<!--                    section 2                                  -->
-<!ELEMENT  sect2        (title, (((%paralevel;)+, sect3*) | sect3+)) >
-<!--         id         unique identifier                          -->
-<!ATTLIST  sect2
-            %common.atts;                                            >
-
-
-<!--                    section 3                                  -->
-<!ELEMENT  sect3        (title, (((%paralevel;)+, sect4*) | sect4+)) >
-<!--         id         unique identifier                          -->
-<!ATTLIST  sect3
-            %common.atts;                                            >
-
-
-<!--                    section 4                                  -->
-<!ELEMENT  sect4        (title, (%paralevel;)+)                      >
-<!--         id         unique identifier                          -->
-<!ATTLIST  sect4
-            %common.atts;                                            >
-
-
-<!--                    appendix                                   -->
-<!ELEMENT  appendix     (title, (((%paralevel;)+, sect1*) | sect1+)) >
-<!--         id         unique identifier                          -->
-<!ATTLIST  appendix
-            %common.atts;                                            >
-
-
-<!--                    bibliography                               -->
-<!ELEMENT  bibliography (title, biblioitem+)                         >
-<!--         id         unique identifier                          -->
-<!ATTLIST  bibliography
-            %common.atts;                                            >
-
-
-<!--                    bibliography item                          -->
-<!ELEMENT  biblioitem   (designator, biblioentry)                    >
-<!--         id         unique identifier                          -->
-<!ATTLIST  biblioitem
-            %common.atts;                                            >
-
-
-<!--                    bibliography item designator               -->
-<!--                    designator contains whatever designator the
-                        author uses to identify publications listed in
-                        the bibliography (e.g., [lab 87]).  the
-                        stylesheet generates the square "[]" brackets
-                        fore & aft.                                -->
-<!ELEMENT  designator   (#PCDATA)                                    >
-<!--         id         unique identifier                          -->
-<!ATTLIST  designator
-            %common.atts;                                            >
-
-
-<!--                    bibliography entry                         -->
-<!ELEMENT  biblioentry  (#PCDATA | %phraselevel;)*                   >
-<!--         id         unique identifier                          -->
-<!ATTLIST  biblioentry
-            %common.atts;                                            >
-
-
-<!-- ============================================================= -->
-<!--                    author-related elements                    -->
-<!-- ============================================================= -->
-
-
-<!--                    first name                                 -->
-<!ELEMENT  firstname    (#PCDATA)                                    >
-<!--         id         unique identifier                          -->
-<!ATTLIST  firstname
-            %common.atts;                                            >
-
-
-<!--                    surname                                    -->
-<!ELEMENT  surname      (#PCDATA)                                    >
-<!--         id         unique identifier                          -->
-<!ATTLIST  surname
-            %common.atts;                                            >
-
-
-<!--                    job title                                  -->
-<!ELEMENT  jobtitle     (#PCDATA)                                    >
-<!--         id         unique identifier                          -->
-<!ATTLIST  jobtitle
-            %common.atts;                                            >
-
-
-<!--                    organization name                          -->
-<!ELEMENT  orgname      (#PCDATA)                                    >
-<!--         id         unique identifier                          -->
-<!ATTLIST  orgname
-            %common.atts;                                            >
-
-
-<!--                    address                                    -->
-<!ELEMENT  address      (street?, pob?, city?, state?, postcode?, 
-                         country?, phone?, fax?, email?)             >
-<!--         id         unique identifier                          -->
-<!ATTLIST  address
-            %common.atts;                                            >
-
-
-<!-- ============================================================= -->
-<!--                    address elements                           -->
-<!-- ============================================================= -->
-
-
-<!--                    street address                             -->
-<!ELEMENT  street       (#PCDATA)                                    >
-<!--         id         unique identifier                          -->
-<!ATTLIST  street
-            %common.atts;                                            >
-
-
-<!--                    post office box                            -->
-<!ELEMENT  pob          (#PCDATA)                                    >
-<!--         id         unique identifier                          -->
-<!ATTLIST  pob
-            %common.atts;                                            >
-
-
-<!--                    postcode                                   -->
-<!ELEMENT  postcode     (#PCDATA)                                    >
-<!--         id         unique identifier                          -->
-<!ATTLIST  postcode
-            %common.atts;                                            >
-
-
-<!--                    city                                       -->
-<!ELEMENT  city         (#PCDATA)                                    >
-<!--         id         unique identifier                          -->
-<!ATTLIST  city
-            %common.atts;                                            >
-
-
-<!--                    state                                      -->
-<!ELEMENT  state        (#PCDATA)                                    >
-<!--         id         unique identifier                          -->
-<!ATTLIST  state
-            %common.atts;                                            >
-
-
-<!--                    country                                    -->
-<!ELEMENT  country      (#PCDATA)                                    >
-<!--         id         unique identifier                          -->
-<!ATTLIST  country
-            %common.atts;                                            >
-
-
-<!--                    phone number                               -->
-<!ELEMENT  phone        (#PCDATA)                                    >
-<!--         id         unique identifier                          -->
-<!ATTLIST  phone
-            %common.atts;                                            >
-
-
-<!--                    fax number                                 -->
-<!ELEMENT  fax          (#PCDATA)                                    >
-<!--         id         unique identifier                          -->
-<!ATTLIST  fax
-            %common.atts;                                            >
-
-
-<!--                    email address                              -->
-<!ELEMENT  email        (#PCDATA)                                    >
-<!--         id         unique identifier                          -->
-<!ATTLIST  email
-            %common.atts;                                            >
-
-
-<!-- ============================================================= -->
-<!--                    paragraph-level elements                   -->
-<!-- ============================================================= -->
-
-
-<!--                    paragraph                                  -->
-<!ELEMENT  para         (#PCDATA | %phraselevel;)*                   >
-<!--         id         unique identifier                          -->
-<!ATTLIST  para
-            %common.atts;                                            >
-
-
-<!--                    note                                       -->
-<!ELEMENT  note         (%paralevel;)+                               >
-<!--         id         unique identifier                          -->
-<!ATTLIST  note
-            %common.atts;                                            >
-
-
-<!--                    itemized list                              -->
-<!ELEMENT  itemizedlist (listitem+)                                  >
-<!--         id         unique identifier                          -->
-<!ATTLIST  itemizedlist
-            %common.atts;                                            >
-
-
-<!--                    ordered list                               -->
-<!ELEMENT  orderedlist  (listitem+)                                  >
-<!--         id         unique identifier                          -->
-<!ATTLIST  orderedlist
-            %common.atts;                                            >
-
-
-<!--                    variable list                              -->
-<!ELEMENT  variablelist (varlistentry+)                              >
-<!--         id         unique identifier                          -->
-<!ATTLIST  variablelist
-            %common.atts;                                            >
-
-
-<!--                    list item                                  -->
-<!ELEMENT  listitem     (#PCDATA | %phraselevel; | %paralevel;)*     >
-<!--         id         unique identifier                          -->
-<!ATTLIST  listitem
-            %common.atts;                                            >
-
-
-<!--                    variable list entry                        -->
-<!ELEMENT  varlistentry (term+, listitem)                            >
-<!--         id         unique identifier                          -->
-<!ATTLIST  varlistentry
-            %common.atts;                                            >
-
-
-<!--                    term                                       -->
-<!ELEMENT  term         (#PCDATA | %phraselevel;)*                   >
-<!--         id         unique identifier                          -->
-<!ATTLIST  term
-            %common.atts;                                            >
-
-<!--                    termref                                       -->
-<!ELEMENT  termref         (#PCDATA | %phraselevel;)*                   >
-<!--         id         unique identifier                          -->
-<!ATTLIST  termref
-            %common.atts;	   >
-
-<!--                    literal layout                             -->
-<!ELEMENT  literallayout
-                        (#PCDATA | %phraselevel;)*                   >
-<!--         xml:space  whitespace handling
-             id         unique identifier                          -->
-<!ATTLIST  literallayout
-            %common.atts;                                            >
-
-
-<!--                    program listing                            -->
-<!ELEMENT  programlisting
-                        (#PCDATA | %phraselevel;)*                   >
-<!--         xml:space  whitespace handling
-             id         unique identifier                          -->
-<!ATTLIST  programlisting
-            %common.atts;                                            >
-
-
-<!--                    figure                                     -->
-<!ELEMENT  figure       (title, graphic)                             >
-<!--         id         unique identifier                          -->
-<!ATTLIST  figure
-            %common.atts;                                            >
-
-
-<!--                    graphic                                    -->
-<!ELEMENT  graphic      EMPTY                                        >
-<!--         align      alignment of graphic image.  values are:
-                          left          left aligned
-                          right         right aligned
-                          center        centered
-             fileref    path to external file
-             alt        alternate text
-             srccredit  source of graphic
-             width      width of area in which to fit graphic
-             depth      depth of area in which to fit graphic
-             scale      percentage scaling factor
-             scalefit   scale to fit width and/or depth
-             id         unique identifier                          -->
-<!ATTLIST  graphic
-             align      (left |right |center)              #IMPLIED
-            %graphic.atts;
-            %common.atts;                                            >
-
-<!--                    inline graphic                             -->
-<!ELEMENT  inlinegraphic
-                        EMPTY                                        >
-<!--         fileref    path to external file
-             alt        alternate text
-             srccredit  source of graphic
-             width      width of area in which to fit graphic
-             depth      depth of area in which to fit graphic
-             scale      percentage scaling factor
-             scalefit   scale to fit width and/or depth
-             id         unique identifier                          -->
-<!ATTLIST  inlinegraphic
-            %graphic.atts;
-            %common.atts;                                            >
-
-<!-- ============================================================= -->
-<!--                    text-level elements                        -->
-<!-- ============================================================= -->
-
-
-<!--                    bibliographic citation                     -->
-<!--                    a <citation> appears in the body of the
-                        article, and it refers through its
-                        "linkend" attribute to the id of the
-                        relevant bibliography item.
-                          the <citation> receives the same
-                        formatting as the <designator> element
-                        within the <biblioitem> being referenced.
-                        for example, when for the bibitem
-                        <biblioitem id="bib1"><designator>lab
-                        87</designator>...</biblioitem> is
-                        formatted as "[lab 87]", the bibliographic
-                        citation <citation linkend="bib1">lab
-                        87</citation> also formats as "[lab 87]".  -->
-<!ELEMENT  citation     (#PCDATA | emphasis | inlinegraphic |
-                         subscript | superscript)*                   >
-<!--         linkend    id of referenced bibliography entry
-             id         unique identifier                          -->
-<!ATTLIST  citation
-             linkend    IDREF                              #REQUIRED
-            %common.atts;                                            >
-
-
-<!--                    emphasis                                   -->
-<!ELEMENT  emphasis     (#PCDATA | %phraselevel;)*                   >
-<!--         id         unique identifier                          -->
-<!ATTLIST  emphasis
-            %common.atts;                                            >
-
-
-<!--                    subscript                                  -->
-<!ELEMENT  subscript    (#PCDATA | emphasis | subscript |
-                         superscript)*                               >
-<!--         id         unique identifier                          -->
-<!ATTLIST  subscript
-            %common.atts;                                            >
-
-
-<!--                    superscript                                -->
-<!ELEMENT  superscript  (#PCDATA | emphasis | subscript |
-                         superscript)*                               >
-<!--         id         unique identifier                          -->
-<!ATTLIST  superscript
-            %common.atts;                                            >
-
-
-<!--                    link                                       -->
-<!ELEMENT  link         (#PCDATA)                                    >
-<!--         linkend    id of referenced element
-             id         unique identifier                          -->
-<!ATTLIST  link
-             linkend    IDREF                              #REQUIRED
-            %common.atts;                                            >
-
-<!--  package link (for {@link org.xml.trax.Processor} type links, for javadocs.                              -->
-<!ELEMENT  plink         (#PCDATA)                                   >
-<!ATTLIST  plink
-            %common.atts;                                            >
-
-<!--                    ulink (external link)                      -->
-<!ELEMENT  ulink        (#PCDATA)                                    >
-<!--         url        uniform resource locator; the target of the
-                        ulink
-             id         unique identifier                          -->
-<!ATTLIST  ulink
-             url        CDATA                              #REQUIRED
-            %common.atts;                                            >
-
-
diff --git a/xdocs/style/stylesheets/spec.xsl b/xdocs/style/stylesheets/spec.xsl
deleted file mode 100644
index 26d73bd..0000000
--- a/xdocs/style/stylesheets/spec.xsl
+++ /dev/null
@@ -1,220 +0,0 @@
-<?xml version="1.0" encoding="ISO-8859-1" ?>
-
-<!DOCTYPE xsl:stylesheet [
-<!ENTITY copy   "&#169;">
-<!ENTITY nbsp   "&#160;">
-]>
-
-<!-- XSL Style sheet, DTD omitted -->
-
-<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
-                xmlns:redirect="org.apache.xalan.lib.Redirect"
-                extension-element-prefixes="redirect">
-  <xsl:output method="html" doctype-public="-//W3C//DTD HTML 4.0 Transitional//EN"/>
-  
-  <xsl:param name="package-root" select="'../../../src/'"/>  <!-- root of destination for package.html files -->
-
-  <xsl:template match="spec">
-    <html>
-      <head>
-        <title>
-          <xsl:value-of select="header/title"/>
-        </title>
-      </head>
-      <body>
-        <xsl:apply-templates/>
-      </body>
-    </html>
-  </xsl:template>
-  
-  <xsl:template match="spec/title[1]">
-    <h1><xsl:apply-templates/></h1>
-  </xsl:template>
-
-  <xsl:template match="frontmatter/pubdate">
-    <p><b>Edit Date: </b><xsl:apply-templates/></p>
-  </xsl:template>
-
-  <xsl:template match="frontmatter/copyright">
-    <!-- p>&copy;<xsl:apply-templates/></p -->
-  </xsl:template>
-
-  <xsl:template match="frontmatter/author">
-  </xsl:template>
-  
-  <xsl:template match="spec/title">
-    <h2>
-      <xsl:choose>
-        <xsl:when test="@id">
-          <a name="@id">
-            <xsl:apply-templates/>
-          </a>
-        </xsl:when>
-        <xsl:otherwise>
-          <xsl:apply-templates/>
-        </xsl:otherwise>
-      </xsl:choose>
-    </h2>
-  </xsl:template>
-  
-  <xsl:template name="apply-id-templates">
-    <xsl:choose>
-      <xsl:when test="@id">
-        <a name="{@id}">
-          <xsl:apply-templates/>
-        </a>
-      </xsl:when>
-      <xsl:otherwise>
-        <xsl:apply-templates/>
-      </xsl:otherwise>
-    </xsl:choose>
-  </xsl:template>
-  
-  <xsl:template match="sect2/title | spec/*/title">
-    <h3>
-      <xsl:call-template name="apply-id-templates"/>
-    </h3>
-  </xsl:template>
-  
-  <xsl:template match="sect3/title">
-    <h4>
-      <xsl:call-template name="apply-id-templates"/>
-    </h4>
-  </xsl:template>
-
-  <xsl:template match="sect4/title">
-    <h5>
-      <xsl:call-template name="apply-id-templates"/>
-    </h5>
-  </xsl:template>
-  
-  <xsl:template match="para">
-    <p><xsl:apply-templates/></p>
-  </xsl:template>
-
-  <xsl:template match="variablelist">
-    <ul>
-    <xsl:for-each select="varlistentry">
-      <li>
-        <p><b><xsl:apply-templates select="term"/></b><br/>
-        <xsl:apply-templates select="listitem"/></p>
-      </li>
-    </xsl:for-each>
-    </ul>
-  </xsl:template>
-
-  <xsl:template match="orderedlist">
-    <ol>
-    <xsl:for-each select="listitem">
-      <li><xsl:apply-templates/></li>
-    </xsl:for-each>
-    </ol>
-  </xsl:template>
-
-  <xsl:template match="patterns">
-    <H3><xsl:value-of select="@module"/><xsl:text> </xsl:text>Patterns</H3>
-    <ul>
-      <xsl:for-each select="pattern">
-        <p>
-          <b>
-            <xsl:for-each select="pattern-name">
-              <xsl:call-template name="apply-id-templates"/>
-            </xsl:for-each>
-          </b>
-          <br/>
-        <xsl:apply-templates select="*[name() != 'pattern-name']"/></p>
-      </xsl:for-each>
-    </ul>
-  </xsl:template>
-  
-  <xsl:template match="pattern/intent">
-    <br/><i>Intent: </i><xsl:apply-templates/>
-  </xsl:template>
-  
-  <xsl:template match="pattern/responsibilities">
-    <br/><i>Responsibilities: </i><xsl:apply-templates/>
-  </xsl:template>
-
-  <xsl:template match="pattern/potential-alternate-name">
-    <br/><i>Potential alternate name: </i><xsl:apply-templates/>
-  </xsl:template>
-  
-  <xsl:template match="pattern/thread-safety">
-    <br/><i>Thread safety: </i><xsl:apply-templates/>
-  </xsl:template>
-
-  <xsl:template match="pattern/notes">
-    <br/><i>Notes: </i><xsl:apply-templates/>
-  </xsl:template>
-
-  <xsl:template match="programlisting">
-    <code>
-    <pre>
-      <xsl:apply-templates/>
-    </pre>
-    </code>
-  </xsl:template>
-  
-  <xsl:template match="link">
-    <A href="#{@linkend}">
-      <xsl:apply-templates/>
-    </A>
-  </xsl:template>
-  <xsl:template match="ulink">
-    <A href="{@url}">
-      <xsl:apply-templates/>
-    </A>
-  </xsl:template>
-
-  <xsl:template match="termref">
-    <xsl:choose>
-      <xsl:when test="@link-url">
-        <A href="#{@link-url}">
-          <xsl:value-of select="."/>
-        </A>
-      </xsl:when>
-      <xsl:otherwise>
-        <U><xsl:value-of select="."/></U>
-      </xsl:otherwise>
-    </xsl:choose>
-  </xsl:template>
-  
-  <xsl:template match="plink">
-    <xsl:text>{@link </xsl:text>
-      <xsl:value-of select="."/>
-    <xsl:text>}</xsl:text>
-  </xsl:template>
-  
-  <xsl:template match="sect1[@id='package']">
-    <xsl:variable name="filename" select="concat($package-root,translate(title,'.', '/'),'/package.html')"/>
-    <redirect:write file="{$filename}">
-      <xsl:call-template name="sub-package"/>
-    </redirect:write>
-  </xsl:template>
-  
-  <xsl:template match="sect2[@id='specialized-packages']">
-    <xsl:message>Found specialized-packages</xsl:message>
-    <xsl:for-each select="sect3">
-	  <xsl:variable name="filename" select="concat($package-root,translate(title,'.', '/'),'/package.html')"/>
-      <redirect:write file="{$filename}">
-        <xsl:call-template name="sub-package"/>
-      </redirect:write>
-    </xsl:for-each>
-  </xsl:template>
-  
-  <xsl:template name="sub-package">
-    <html>
-       <head>
-         <title>
-           <xsl:value-of select="title"/>
-         </title>
-       </head>
-       <body>
-         <xsl:apply-templates select="*[not (name()='title')]"/>
-       </body>
-     </html>
-  </xsl:template>
-
-
-</xsl:stylesheet>
-


---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@xalan.apache.org
For additional commands, e-mail: dev-help@xalan.apache.org