dleslie 00/02/11 15:19:02
Modified: xdocs/sources/xalan samples.xml overview.xml getstarted.xml
api.xml
Log:
Updates around new "Getting Started"
Revision Changes Path
1.2 +69 -46 xml-xalan/xdocs/sources/xalan/samples.xml
Index: samples.xml
===================================================================
RCS file: /home/cvs/xml-xalan/xdocs/sources/xalan/samples.xml,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- samples.xml 2000/02/04 14:39:50 1.1
+++ samples.xml 2000/02/11 23:18:58 1.2
@@ -7,69 +7,90 @@
<!DOCTYPE s1 SYSTEM "sbk:/style/dtd/document.dtd">
<s1 title="Samples">
-
+<ul>
+<li><link anchor="simpletransform">SimpleTransform</link></li>
+<li><link anchor="transformtodom">TransformToDom</link></li>
+<li><link anchor="usestylesheetparam">UseStylesheetParam</link></li>
+<li><link anchor="validatexpath">ValidateXPath</link></li>
+<li><link anchor="pipe">Pipe (SAX)</link></li>
+<li><link anchor="extensions">Extensions</link></li>
+<li><link anchor="applet">Applet</link></li>
+<li><link anchor="servlet">Servlet</link></li>
+</ul>
<s2 title="Samples to help you get started">
- <p>Each of the subdirectories in the &xslt4j; samples directory contains
one or more sample applications that
- you can run, examine, modify, and rebuild.</p>
- <p>You can use the make file to build the samples. To build all the
samples at once, run the make file from the samples
- directory:</p>
- <p><code>make -samples</code></p>
- <p>To build and/or run one of the samples, run the make file in the
pertinent subdirectory:</p>
- <p><code>make -test</code></p>
- <p>For more information about running the make files, see the
instructions for <link idref="ltsinstall"
- anchor="rebuilding&xslt4j;">rebuilding &xslt4j;</link>.</p>
- <p>The make file sets the classpath and uses javac to compile the java
files. In place of the make files, you can
- set the classpath yourself and run javac: be sure to include
&xslt4j;.jar (or xalan.jar), xerces.jar, and the samples
- subdirectory in the classpath. No build is required for the sample
applet.</p>
- <p>The make file in each sample subdirectory (except applet and server,
servlet) also runs the sample application.
- You can run most of these samples with</p>
- <p><code>java <ref>classname</ref></code></p>
- <p>where <ref>classname</ref> is the classname. The samples in params
and ValidateXPath take an argument in addition to classname. The samples in
extensions use the <link idref="commandline">command-line utility</link>, so
they take arguments for the XML source file and the XSL stylesheet.</p>
- </s2>
- <s2 title="simple">
+ <p>Each of the subdirectories in the &xslt4j; samples directory contains
the source files for one or more
+ sample applications. The class files for all the samples are in
xalansamples.jar, so to run the samples,
+ you should place xalansamples.jar on the system class path.</p>
+ <p>With most of the samples, you can use the following procedure:</p>
+ <ol>
+ <li>Be sure xalan.jar, xalansamples.jar, and xerces.jar are on the
system class path. For the extension
+ examples, bsf.jar, bsfengines.jar, and (for the JavaScript extensions)
js.jar must also be on the class
+ path.</li>
+ <li>Be sure java.exe is on your path.</li>
+ <li>Go to the samples subdirectory containing the sample (use the DOS
shell if you are running Windows).</li>
+ <li>Run the sample from the command line (as indicated below)</li>
+ <li>Examine the application source files. You may also want to modify
the source files. Remember that if you
+ modify a java file, you must recompile the class and place it on the
class path before you can run the
+ modified application.</li>
+ </ol>
+ <p>The basic command line for running most of the samples is </p>
+ <p><code>java <ref>classname args</ref></code></p>
+ <p>where <ref>classname</ref> is the classname and <ref>args</ref> are
the arguments, if any. As described in
+ the
+ following sections, some samples take no arguments. The samples in
params and ValidateXPath take an argument
+ in addition to classname. The samples in extensions use the &xslt4j;
<link idref="commandline">command-line
+ utility</link>, so they take arguments for the XML source file and the
XSL stylesheet.</p>
+ </s2><anchor name="simpletransform"/>
+ <s2 title="SimpleTransform">
<p>What it does: The SimpleTransform class uses the foo.xsl stylesheet
to transform foo.xml, and prints the
output to System.out.</p>
- <p>You can run it from the command line with</p>
+ <p>You can run it from the SimpleTransform subdirectory with</p>
<p><code>java SimpleTransform</code></p>
- </s2>
- <s2 title="dom1">
+ </s2><anchor name="transformtodom"/>
+ <s2 title="TransformToDom">
<p>What it does: The TransformToDom class uses the foo.xsl stylesheet to
transform foo.xml, produces an output
- DOM, and traverses the DOM, printing the traversal to System.out. In
contrast to "simple," "dom1" illustrates
- the procedure gor creating an output DOM which is then available for
further processing.</p>
- <p>You can run it from the command line with</p>
- <p><code>java SimpleTransform</code></p>
- </s2>
- <s2 title="params">
+ DOM, and traverses the DOM, printing the traversal to System.out. In
contrast to SimpleTransform,
+ TransformToDom illustrates the procedure for creating an output DOM
that is available for further
+ processing.</p>
+ <p>You can run it from the TransformToDom subdirectory with</p>
+ <p><code>java TransformToDom</code></p>
+ </s2><anchor name="usestylesheetparam"/>
+ <s2 title="UseStylesheetParam">
<p>What it does: The UseStyleSheetParam class uses foo.xsl and a
stylesheet parameter to transform foo.xml,
and prints the output to System.out. The stylesheet parameter appears
as a text node in the output.</p>
- <p>Run this sample from the command line with</p>
+ <p>Run this sample from the UseStylesheetParam subdirectory with</p>
<p><code>java UseStylesheetParam <ref>param</ref></code></p>
<p>where <ref>param</ref> is the stylesheet parameter.</p>
- </s2>
+ </s2><anchor name="validatexpath"/>
<s2 title="ValidateXPath">
<p>What it does: The ValidateXPath class validates and displays a
textual diagram of an XPath expression.</p>
- <p>Run this sample from the command line with</p>
+ <p>Run this sample from the ValidateXPath subdirectory with</p>
<p><code>java ValidateXPath <ref>XPathExpression</ref></code></p>
<p>where <ref>XPathExpression</ref> is an XPath expression, such as
"aa/bb//xx".</p>
- </s2>
- <s2 title="pipe">
+ </s2><anchor name="pipe"/>
+ <s2 title="Pipe">
<p>What it does: The Pipe class uses the output of the first
transformation as input to a second
transformation.</p>
- <p>Run it from the command line with</p>
+ <p>The first transformation produces a sequence of SAX events which the
second transformation processes with
+ its own stylesheet. The consumer of SAX output can respond to these
events as they occur, rather than waiting
+ for the entire result tree to be constructed (as the DOM consumer
must do).</p>
+ <p>Run this sample from the Pipe subdirectory with</p>
<p><code>java Pipe</code></p>
- </s2>
- <s2 title="extensions".
+ <p>For other examples using the SAX document handler, see <link
idref="getstarted" anchor="sax">Generating and
+ responding to SAX events</link>.</p>
+ </s2><anchor name="extensions"/>
+ <s2 title="Extensions">
<p>The extensions subdirectory contains four samples with &xslt4j;
extensions. Two of the samples use
extensions implemented in JavaScript, and two of the samples use
extensions implemented in Java. All of
- the samples are documented at length in <link
idref="extensions">Extensions</link>.</p>
- <p>To run these examples, you must place bsf.jar, bsfengines.jar
(distributed with &xslt4j;, and js.jar
- (availabe from http://www.mozilla.org/rhino) on the class path. You do
not need js.jar
+ the samples are documented in <link
idref="extensions">Extensions</link>.</p>
+ <p>To run these examples, you must place bsf.jar and bsfengines.jar
(distributed with &xslt4j;), and js.jar
+ (availablee from http://www.mozilla.org/rhino) on the class path. You
do not need js.jar
on the class path for the samples that use Java extensions. </p>
- <p>You can use java.org.apache.xalan.xslt.Process, the &xsl4j;
command-line utility, to run these samples from
+ <p>Use java.org.apache.xalan.xslt.Process, the &xslt4j; command-line
utility, to run these samples from
the command line. The command line must include an -in argument with
the XML source and an -xsl argument with
the XSL stylesheet. If you want the output to be printed to a file,
rather than to the screen, add an -out
argument for the output file.</p>
- <p>Run these samples from the command line with</p>
+ <p>Run these samples from the extensions directory as follows:</p>
<p><code>java org.apache.xslt.xalan.Process -in 1basicJscript</code>
<br/> <code>-xsl 1basicJscript</code></p>
@@ -79,13 +100,15 @@
<br/> <code>-xsl 3numlistJava.xsl</code></p>
<p><code> java org.apache.xslt.xalan.Process -in 4numlistJcript.xml
</code>
<br/> <code>-xsl 4numlistJscript.xsl</code></p>
- </s2>
- <s2 title="applet">
+ </s2><anchor name="applet"/>
+ <s2 title="Applet">
<p>The applet uses a stylesheet to transform an XML document into HTML.
It displays the XML document, the
stylesheet, and the HTML output.</p>
- <p>How to run it: See <jump href="samples/applet/readme.html">sample
applet readme</jump>.</p>
- </s2>
- <s2 title="server and servlet">
+ <p>How to run it: See <jump href="samples/applet/readme.html">sample
applet readme</jump>.</p>
+ <p>For a brief introduction to using applets to perform transformations,
see <link idref="getstarted"
+ anchor="applet">Using the &xslt4j; applet wrapper</link></p>
+ </s2><anchor name="servlet"/>
+ <s2 title="Servlet">
<p>What it does: The client (which you must set up) specifies an XML
document and a stylesheet. The servlet
performs the transformation and returns the output to the client. You
can use media.properties to specify
which stylesheet is to be used depending on the client
browser/device.</p>
1.2 +32 -1 xml-xalan/xdocs/sources/xalan/overview.xml
Index: overview.xml
===================================================================
RCS file: /home/cvs/xml-xalan/xdocs/sources/xalan/overview.xml,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- overview.xml 2000/02/04 14:39:50 1.1
+++ overview.xml 2000/02/11 23:18:58 1.2
@@ -128,10 +128,41 @@
and XPath</jump><br/><br/></li>
<li>The Mulberry <jump
href="http://www.mulberrytech.com/xsl/xsl-list/";>XSL-List -- Open Forum on
XSL</jump>
(of interest to XSL users at all levels)<br/><br/></li>
- <li>Dave Pawson's <jump href="http://www.dpawson.co.uk/";>XSL Frequently
Asked Questions</jump><br/><br/></li>
+ <li>Dave Pawson's <jump
href="http://freespace.virgin.net/b.pawson/xsl/index.html#top";>XSL Frequently
Asked Questions</jump><br/><br/></li>
<li>Objects by Design's <jump
href="http://www.objectsbydesign.com/projects/xmi_to_html.html";>Transforming
XMI to HTML</jump><br/><br/></li>
+<li>Nic Miloslav's <jump
href="http://zvon.vscht.cz/HTMLonly/XSLTutorial/Books/Book1/index.html";>XSL
Tutorial</jump>
+<br/><br/></li>
</ul>
<p>This is a very preliminary list. If you have come across other useful
introductionary or background materials,
please email <human-resource-ref idref="dleslie"/>, so he can add them
to this list.</p>
</s2>
+ <s2 title="Glossary">
+ <gloss>
+ <label>XSL Instruction</label>
+ <item>Any tag with an XSL namespace prefix.<br/><br/></item>
+
+ <label>XSL Template Instruction</label>
+ <item>Any tag with an XSL namespace prefix
+ that occurs inside an xsl:template element.<br/><br/></item>
+
+ <label>Template Child</label>
+ <item>Any node that is a child of an xsl:template
element.<br/><br/></item>
+
+ <label>Source Tree</label>
+ <item>The tree input to the XSL process.<br/><br/></item>
+
+ <label>Result Tree</label>
+ <item>The tree that is output by the XSL process.<br/><br/></item>
+
+ <label>Stylesheet Tree</label>
+ <item>The stylesheet tree produced from the XSL
file.<br/><br/></item>
+
+ <label>Pattern List</label>
+ <item>A parsed query or match pattern.<br/><br/></item>
+ </gloss>
+ <p>For more definitions of XSLT terminology, see Dave Lawson's
+ <jump
href="http://freespace.virgin.net/b.pawson/xsl/xslvocab.html#top";>XSLT
Terminology
+ Clarification</jump>.</p>
+ </s2>
+
</s1>
1.2 +227 -41 xml-xalan/xdocs/sources/xalan/getstarted.xml
Index: getstarted.xml
===================================================================
RCS file: /home/cvs/xml-xalan/xdocs/sources/xalan/getstarted.xml,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- getstarted.xml 2000/02/04 14:39:50 1.1
+++ getstarted.xml 2000/02/11 23:18:59 1.2
@@ -19,78 +19,264 @@
<li>xerces.jar</li>
</ul>
<p>You can get the Sun JDK or JRE from <jump
href="http://www.java.sun.com";>java.sun.com</jump>. Download the latest release
of Xalan and Xerces-java from <jump
href="http://xml.apache.org/dist/";>xml.apache.org</jump>. Check the <link
idref="readme" anchor="status">version release notes</link> to verify that you
are using the correct version of Xerces. <em>Important</em> You may experience
unpredicable difficulties and anomalies if your Xalan and Xerces builds are not
in synch.</p>
-<note>You may also download the latest releases of LotusXSL and the XML
Parser for Java from <jump
href="http://www.alphaworks.ibm.com/tech/LotusXSL";>alphaWorks</jump>. LotusXSL
and the XML Parser for Java are Xalan and Xerces-java respectively, along with
additional features and continued support for the core API that was in place on
alphaWorks before the first releases of Xalan and Xerces-java on xml.apache.org
in November 1999.</note>
+<note>You may also download the latest releases of LotusXSL and the XML
Parser for Java from <jump
href="http://www.alphaworks.ibm.com/tech/LotusXSL";>alphaWorks</jump>. LotusXSL
and the XML Parser for Java are Xalan and Xerces-java respectively, along with
additional features and wrappers to support the core API that was in place on
alphaWorks before the first releases of Xalan and Xerces-java on xml.apache.org
in November 1999.</note>
<p>If you plan to run <link idref="extensions">XSLT extensions</link>. you
need bsf.jar and bsfengines.jar, both of which are included in the Xalan
distribution. If you plan to run XSLT extensions implemented in JavaScript or
another scripting language, you will need one or more additional files as
indicated in <link idref="extensions" anchor="supported-lang">extensions
language requirements</link>.</p>
</s2><anchor name="classpath"/>
<s2 title="Setting up the system class path">
-<p>At the very minimum, you must include xalan.jar and xerces.jar on the
system class path. To run the examples, include xalansamples.jar To run
extensions, include bsf.jar and bsfengines.jar. For extensions implemented in
JavaScript or another scripting language, see <link idref="extensions"
anchor="supported-lang">extensions language requirements</link> about the
additional JAR files you must place on the class path.</p>
-<p>If you are using JDK or JRE 1.x (at least 1.7, please), also include
classes.zip on the class path.</p>
+<p>At the very minimum, you must include xalan.jar and xerces.jar on the
system class path. To run the examples, include xalansamples.jar To run
extensions, include bsf.jar and bsfengines.jar. All these JAR files are
distributed with &xslt4j;. For extensions implemented in JavaScript or another
scripting language, see <link idref="extensions"
anchor="supported-lang">extensions language requirements</link> to identify any
additional JAR files you must place on the class path and where you can get
them.</p>
+<p>If you are using JDK or JRE 1.1.x (at least 1.1.7, please), also include
classes.zip on the class path.</p>
</s2><anchor name="samples"/>
<s2 title="Trying out the samples">
-<p>The Xalan distribution includes a number of basic samples. These examples
are easy to run, and you can review the brief source files to see just how they
work.</p>
-<p>To run most of the samples, do the following:</p>
+<p>The Xalan distribution includes a number of basic samples. These examples
are easy to run, and you can review the source files -- all of which are brief
-- to see just how they work.</p>
+<p>To run the samples, do the following:</p>
<ol>
<li>Set up your class path (see above), including xalansamples.jar.</li>
<li>Be sure java.exe is on your path.</li>
-<li>(Using the DOS shell in Windows) Go to the samples subdirectory
containing the sample.</li>
+<li>Go to the samples subdirectory containing the sample (use the DOS shell
if you are running Windows).</li>
<li>Run the sample from the command line.</li>
<li>Examine the application source files.</li>
</ol>
-<p>For example, to run SimpleTransformation, go to the simple subdirectory
and issue the following command:</p>
+<p>For example, go to the SimpleTransformation subdirectory and issue the
following command:</p>
<p><code>java SimpleTransformation</code></p>
-<p>The sample displays its output on the screen. Then examine the source
files: foo.xml, foo.xsl, and SimpleTransformation.java.</p>
-<p>The procedure for running two of the samples is a little different: You
run the applet sample from an HTML browser, and the servlet example from a web
server with servlet support (such as Apache with WebSphere or Jserv).</p>
-<p>For information about the samples, see <link idref="samples">&xslt4j;
Samples</link>.</p>
-
+<p>The sample displays the transformation result on the screen. To see how
the example works, examine the source files: foo.xml, foo.xsl, and
SimpleTransformation.java.</p>
+<p>The extensions examples require additional JAR files on the class path,
and the procedure for running the sample applet and sample servlet is
different. For information about the samples, see <link
idref="samples">&xslt4j; Samples</link>.</p>
</s2><anchor name="commandline"/>
<s2 title="Performing your own transformations from the command line">
<p>java.org.apache.xalan.xslt.Process provides a basic utility for
performing transformations from the command line. You use this utility, for
example, to run the extensions samples. The command-line for the most standard
of
transformations is as follows:</p>
<p><code>java org.apache.xalan.xslt.Process -in
<ref>xmlSource</ref></code><br/>
-<code>-xsl <ref>stylesheet</ref> -out <ref>outputfile</ref></code></p>
+<code> -xsl <ref>stylesheet</ref> -out
<ref>outputfile</ref></code></p>
+<p>where <ref>xmlSource</ref> is the XML source file name,
<ref>stylesheet</ref> is the XSL stylesheet file name, and
<ref>outputfile</ref> is the output file name.</p>
<p>If you want the output to be displayed on the screen, simply omit the
-out argument.</p>
+<p>You can use this utility to try out XSL stylesheets you have written, to
make sure they do what you expect with the XML source files they are designed
to transform. The utility provides useful messages if the source file or
stylesheet is not well-formed. If you include a DOCTYPE statement in your XML
source files and the -validate flag on the command line, the utility will also
let you know whether the XML document adheres to that DOCTYPE. For more
information, see <link idref="commandline">Command-Line Utility</link>.</p>
</s2><anchor name="java-apps"/>
<s2 title="Setting up your own Java applications">
-<p>Modify the samples. Set up an XSLTProcessor with the right liaison,
XSLTInput objects for the XML source and the stylesheet, an XSLTResultTarget
object for the output. Then call the XSLTProcessor process method.</p>
+<p>You can start by using your own XML source files and XSL stylesheets with
the sample applications, which illustrate a number of the <link
anchor="usage-patterns">basic usage patterns</link>.</p>
+<p>If you modify a java source file, be sure to compile the class and place
it on the system class path. Here are some basic points to keep in mind as you
are setting up transformations:</p>
+<ul>
+<li>Use one of the <resource-ref idref="XSLTProcessorFactoryDoc"/> static
getProcessor methods to set up an <resource-ref idref="XSLTProcessorDoc"/>.
<br/><br/>By default, the XSLTProcessor uses the <resource-ref
idref="DTMLiaison"/> and the high-performance <link idref="dtm">Document Table
Model (DTM)</link>"pseudo" DOM parser to process the input. If your input is a
DOM node (rather than a file, character stream, byte stream, or SAX input
stream), you must use a "standard" DOM liaison and parser, such as the
<resource-ref idref="XercesLiaisonDoc"/> and the Xerces DOM parser. For an
example, see <link anchor="dom-in">Processing DOM input</link>.<br/><br/></li>
+<li>Set up <resource-ref idref="XSLTInputSourceDoc"/> objects for the XML
input and XSL stylesheet. You can use a file name or URL, character streams,
byte streams, or SAX input stream to instantiate an XSLTInputSource
object.<br/><br/>
+If the XML document contains a stylesheet Processing Instruction (PI), you
do not need to create a separate
+XSLTInputSource object for an XSL stylesheet.<br/><br/></li>
+<li>For improved performance with a series of transformations, use the
XSLTProcessor processStylesheet method to compile the XSL stylesheet.<br/><br/>
+This is also useful when you need to get information from the stylesheet
before the tranformation occurs, for
+instance, when you need to find out the output encoding in order to
construct the right kind of Writer.
+You must also compile the stylesheet if you are using the XSLTProcessor as a
SAX document handler.<br/><br/></li>
+<li>Set up an <resource-ref idref="XSLTResultTargetDoc"/> for the
transformation output. You can use a file name or URL, character stream, byte
stream, or SAX document handler to instantiate an XSLTOutputTarget
object.<br/><br/></li>
+<li>Use the XSLTProcessor (or, in some cases, the <link
idref="StylesheetRootDoc"/>) process method to perform the
transformation.<br/><br/>
+&xslt4j; is thread-safe for one instance per thread. If you are using the
same instance of XSLTProcessor to perform
+more than one transformation, call the reset method between
transformations.</li>
+</ul>
+<p>For more information on setting up transformations, see the following
section:</p>
</s2><anchor name="usage-patterns"/>
<s2 title="Basic usage patterns">
<ul>
-<li><link anchor="files">Use a stylesheet file to transform an XML source
file into an output file</link></li>
-<li><link anchor="params">Send stylesheet parameters</link></li>
-<li><link anchor="compiled">For performance, use compiled
stylesheets</link></li>
-<li><link anchor="pipe">Pipe the output from one transformation to another
transformation</link></li>
-<li><link anchor="dom-in">Accept DOM input</link></li>
-<li><link anchor="dom-out">Produce DOM output</link></li>
-<li><link anchor="sax">Generate and respond to SAX events</link></li>
-<li><link anchor="xpath">Work with XPath expressions</link></li>
-<li><link anchor="extensions">Create and use extensions</link></li>
+<li><link anchor="files">Using a stylesheet file to transform an XML source
file into an output file</link></li>
+<li><link anchor="streams">Using data streams in place of files</link></li>
+<li><link anchor="params">Setting stylesheet parameters</link></li>
+<li><link anchor="compiled">Compiling stylesheets</link></li>
+<li><link anchor="dom-in">Processing DOM input</link></li>
+<li><link anchor="dom-out">Producing DOM output</link></li>
+<li><link anchor="sax">Generating and responding to SAX events</link></li>
+<li><link anchor="xpath">Working with XPath expressions</link></li>
+<li><link anchor="applet">Using the &xslt4j; applet wrapper</link></li>
+<li><link anchor="servlet">Using &xslt4j; in a servlet</link></li>
+<li><link anchor="extensions">Creating and using extensions</link></li>
</ul><anchor name="files"/>
-<s3 title="Use XML source, XSL stylesheet, and output files">
-<p>Use an XML file and an XSL file to instantiate XSLTInput objects, create
a processor with the default DTM liaison, and send the transformation output to
an output file. For an example, see "Simple."</p>
+<s3 title="Using XML source, XSL stylesheet, and output files">
+<p>Use an XML file and an XSL file to instantiate XSLTInput objects, create
a processor with the default DTM liaison, and send the transformation output to
an output file. For example:</p>
+<source>public static void transform(String xmlSourceURL, String xslURL,
String outputURL)
+ throws java.io.IOException,
+ java.net.MalformedURLException,
+ org.xml.sax.SAXException
+{
+ // Instantiate an XSLTProcessor.
+ org.apache.xalan.xslt.XSLTProcessor processor =
+ org.apache.xalan.xslt.XSLTProcessorFactory.getProcessor();
+
+ // Create the 3 objects the XSLTProcessor needs to perform the
transformation.
+ org.apache.xalan.xslt.XSLTInputSource xmlSource =
+ new org.apache.xalan.xslt.XSLTInputSource
("foo.xml");
+ org.apache.xalan.xslt.XSLTInputSource xslSheet =
+ new org.apache.xalan.xslt.XSLTInputSource ("foo.xsl");
+ org.apache.xalan.xslt.XSLTResultTarget xmlResult =
+ new org.apache.xalan.xslt.XSLTResultTarget
("foo.out");
+
+ // Perform the transformation.
+ processor.process(xmlSource, xslSheet, xmlResult);
+ }</source>
+<p>For an online example, see <link idref="samples"
anchor="simpletransform">SimpleTransform</link>.</p>
+<p>You can perform this same operation from the <link
idref="commandline">command line</link>. For example:</p>
+<p><code>java org.apache.xalan.xslt.Process -in foo.xml -xsl foo.xsl -out
output.xml</code></p>
+</s3><anchor name="streams"/>
+<s3 title="Using data streams in place of files">
+<p>The context in which you perform a transformation may call for input in
the form of a character stream, byte stream, or SAX input stream, and output in
the form of a character stream, byte stream, or SAX document handler. Suppose,
for example, you want to output a stream of bytes for further processing:</p>
+<source>import org.apache.xalan.xslt.*;
+...
+java.io.OutputStream byteStream = new java.io.OutputStream();
+XSLTRegultTarget out = new XSLTResultTarget(byteStream)
+// Do the transformation...
+// Work with the OutputStream...</source>
+
</s3><anchor name="params"/>
-<s3 title="Send stylesheet parameters">
-<p>When we generate the HTML documents that make up the Xalan doc set, for
example, we send the stylesheet an id parameter along with each XML source
document. The id identifies that document and enables the stylesheet to
integrate it into the overall doc set.</p>
+<s3 title="Setting stylesheet parameters">
+<p>An XSL stylesheet can include parameters that get set at run time when a
transformation takes place. When we generate the HTML documents that make up
the Xalan doc set, for example, we send the stylesheet an id parameter along
with each XML source document. The id identifies that document and enables the
stylesheet to integrate it into the overall doc set.</p>
+<p>To set a stylesheet parameter, use the XSLTProcessor
setStylesheetParam(String paramName, String paramExpr) method. paramExpr is an
XPath expression, so if the parameter is a String, enclose it in single quotes
to make it a String expression.</p>
+<p>You can also use setStylesheetParam(String key, XObject value). This
option is useful when you are working with the XPath API. For example, you
could use the XObject returned by an Xpath function to set a parameter.</p>
+<p>From the <link idref="commandline">command line</link>, include a -param
argument. For example:</p>
+<p><code>java org.apache.xalan.xsltProcess -in foo.xml -xsl foo.xsl -param
'boo'</code></p>
</s3><anchor name="compiled"/>
-<s3 title="Compile your stylesheets">
-<p></p>
-</s3><anchor name="pipe"/>
-<s3 title="Perform multi-staged transformations">
-<p></p>
+<s3 title="Compiling stylesheets">
+<p>A <resource-ref idref="StylesheetRootDoc"/> object is a binary
representation of a stylesheet that adds efficiency to the performance of
repeated transformations and supports threadsafe concurrent access by multiple
clients. If, for example, you are setting up a servlet to perform
transformations, you can improve performance by compiling any stylesheets the
servlet repeatedly uses.</p>
+<p>To compile a stylesheet, use one of the the <resource-ref
idref="XSLTProcessorDoc"/> processStylesheet methods. This operation also sets
the XSLTProcessor Stylesheet property. In the interest of clarity, you may want
to explicitly set that property. When you call the process method, include a
null for the "uncompiled" stylesheet parameter so XLTProcessor uses the
compiled stylesheet. For example:</p>
+<source>import org.apache.xalan.xslt.*;
+...
+XSLTProcessor processor = XSLTProcessorFactory.getProcessor();
+StylesheetRoot style = processor.processStylesheet(new
XSLTInputSource("foo.xsl"));
+processor.setStylesheet(style); // Good form!
+...
+processor.process(new XSLTInputSource("foo.xml"),
+ null, // Use the Stylesheet property setting.
+ new XSLTOutputTarget("foo.out"));</source>
+<p>Alternative: For convenience, StylesheetRoot has its own process method,
so another way to do the preceding is as follows:</p>
+<source>import org.apache.xalan.xslt.*;
+..
+XSLTProcessor processor = XSLTProcessorFactory.getProcessor();
+StylesheetRoot style = processor.processStylesheet(new
XSLTInputSource("foo.xsl"));
+...
+style.process(new XSLTInputSource("foo.xml"), new
XSLTOutputTarget("foo.out"));</source>
+<p>If you want to use the XSLTProcessor as a SAX document handler, you must
provide the processor a compiled stylesheet. See <link anchor="sax">Generating
and Responding to SAX events</link>.</p>
</s3><anchor name="dom-in"/>
-<s3 title="Accept DOM input">
-<p></p>
+<s3 title="Processing DOM input">
+<p>The XML source and XSL stylesheet for a transformation may appear in the
form of a DOM Node. To perform transformations with DOM input, you cannot use
the default high-performance DTM liaison and parser. <link idref="dtm">DTM
(Document Table model)</link> uses a table of integers to represent a DOM, thus
avoiding much of the overhead of creating and manipulating actual DOM nodes,
which often involve a large number of Java objects. If you are processing DOM
input, you must use a DOM parser, such as the Xerces DOM parser. When you
create the XSLTProcessor for the transformation, you must specify that it is to
use the Liaison for such a DOM parser.</p>
+<p>The following code fragments illustrate the procedure for working with
DOM input:</p>
+<source>import org.apache.xerces.parsers.DOMParser;
+import org.w3c.dom.Document;
+import org.apache.xalan.xpath.xdom.XercesLiaison;
+import org.apache.xalan.xslt.*;
+...
+// Just in case you want to produce your own DOM input...
+DOMParser parser = new DOMParser();
+parser.parse("foo.xml");
+Document in = parser.getDocument();
+XSLTInputSource xmlID = new XSLTInputSource(in);
+
+// Set up the XSLTProcessor to use XercesLiaison.
+XSLTProcessor xsltProc = XSLTProcessorFactory.getProcessor
+ (new org.apache.xalan.xpath.xdom.XercesLiaison())
+// or you can use XSLTProcessorFactory.getProcessorUsingLiaisonName
+// ("org.apache.xalan.xpath.xdom.XercesLiaison")
+...
+// Perform the transformation.</source>
</s3><anchor name="dom-out"/>
-<s3 title="Produce DOM output">
-<p></p>
+<s3 title="Producing DOM output">
+<p>To produce a DOM Node as your transformation output, use a new Node to
create the XSLTResultTarget for the transformation. Then when you perform the
transformation, the result is output as a DOM Node. For example:</p>
+<source>import org.w3.dom.Document;
+import org.apache.xalan.xslt.*;
+...
+XSLTProcessor xsltProc = XSLTProcessorFactory.getProcessor();
+org.w3c.dom.Document out = new org.apache.xerces.dom.DocumentImpl();
+XSLTResultTarget resultTarget = new XSLTResultTarget(out);
+processor.process(new XSLTInputSource("foo.xml"),
+ new XSLTInputSource("foo.xsl"),
+ resultTarget);</source>
+<p>The XSLTResultTarget object (resultTarget) now contains a Node. For a
working example, see <link idref="samples"
anchor="transformtodom">TransformToDom</link>.</p>
</s3><anchor name="sax"/>
-<s3 title="Generate and respond to SAX events">
-<p></p>
+<s3 title="Generating and responding to SAX events">
+<p>To set up a transformation to generate SAX events, set the
DocumentHandler property of the XSLTResultTarget object. The transformation
consumer can then respond to these events as they occur, rather than waiting
(as the consumer of a DOM must) for the complete result tree.</p>
+<p>This example sends the output to System.out.</p>
+<source>import org.apache.xalan.xslt.XSLTProcessor;
+import org.apache.xalan.xslt.XSLTInputSource;
+import org.apache.xalan.xslt.XSLTResultTarget;
+import org.apache.xalan.xslt.XSLTProcessorFactory;
+import org.apache.xalan.xslt.StylesheetRoot;
+
+public class TransformToSax
+{
+ public static void main(String[] args)
+ throws java.io.IOException,
+ java.net.MalformedURLException,
+ org.xml.sax.SAXException
+ {
+ XSLTProcessor processor = XSLTProcessorFactory.getProcessor();
+
+ // Set the processor to use a compiled stylesheet.
+ // The stylesheet provides access to a SAX DocumentHandler,
+ // passing it the stylesheet xsl:output settings.
+ StylesheetRoot stylesheet = processor.processStylesheet("foo.xsl");
+ // This property was just set implicitly, but for good form...
+ processor.setStylesheet(stylesheet);
+ // In this case, send the output to System.out.
+ org.xml.sax.DocumentHandler dh = stylesheet.getSAXSerializer(System.out);
+
+ // Use the DocumentHandler to construct an XSLTResultTarget object.
+ XSLTResultTarget saxResult = new XSLTResultTarget(dh);
+
+ // Perform the transformation. The stylesheet parameter is null, so
+ // the processor uses the compiled stylesheet identified by its
+ // Stylesheet property setting.
+ processor.process(new XSLTInputSource("foo.xml"), null, saxResult);
+ }
+}</source>
+<p>XSLTProcessor also has a DocumentHandler property (in fact, XSLTProcessor
extends DocumentHandler). By setting this property, you instruct the processor
to process a sequence of SAX events. The processor needs a compiled stylesheet
to perform this transformation.</p>
+<p>The following example uses the output of one transformation as the input
for a second transformation. It does this by using two SAX DocumentHandlers to
pipe SAX events from the first transformation to the second.</p>
+<source>import org.apache.xalan.xslt.*;
+
+public class ChainTransforms
+{
+ public static void main(String[] args)
+ throws java.io.IOException,
+ java.net.MalformedURLException,
+ org.xml.sax.SAXException
+ {
+ // Create processor for 1st transform.
+ XSLTProcessor processor1 = XSLTProcessorFactory.getProcessor();
+
+ // Create processor for 2nd transform. Set Stylesheet and
+ // DocumentHandler properties so this processor uses the
+ // 2nd stylesheet and processes SAX events (output from the
+ // 1st transform), sending the final result to System.out.
+ XSLTProcessor processor2 = XSLTProcessorFactory.getProcessor();
+ StylesheetRoot stylesheet2 = processor2.processStylesheet("foo2.xsl");
+ processor2.setStylesheet(stylesheet2);
+ org.xml.sax.DocumentHandler dh =
stylesheet2.getSAXSerializer(System.out);
+ processor2.setDocumentHandler(dh);
+
+ // Set up the 1st transform to produce a series of SAX events, and
+ // to pass these events to the processor for the 2nd transform.
+ // To accomplish this, create an XSLTResultTarget object for the
+ // 1st transform, and use the processor for the 2nd transform to set
+ // the XSLTResultTarget DocumentHandler property.
+ XSLTResultTarget intermedResult = new XSLTResultTarget();
+ intermedResult.setDocumentHandler(processor2);
+
+ // Perform the 1st transform, which produces a series of
+ // SAX events that are in turn processed by the processor2
DocumentHandler
+ // in conjunction with stylesheet2, sending the output to System.out.
+ processor1.process(new XSLTInputSource("foo.xml"),
+ new XSLTInputSource("foo.xsl"),
+ intermedResult);
+ }
+}</source>
+<p>For a more compact (and elegant) form of this example, see the <link
idref="samples" anchor="pipe">Pipe</link>.</p>
</s3><anchor name="xpath"/>
-<s3 title="Work with XPath expressions">
-<p></p>
+<s3 title="Working with XPath expressions">
+<p>XSL stylesheets use XPath expressions to select nodes, specify
conditions, and generate text for the result tree. XPath provides an API that
you can call directly. For example, you may want to select nodes
programatically and do your own processing without a stylesheet. For a
preliminary example that verifies the syntax of inidvidual XPath expressions,
see <link idref="samples" anchor="validatexpath">ValidateXPath</link>.</p>
+</s3><anchor name="applet"/>
+<s3 title="Using the &xslt4j; applet wrapper">
+<ol>
+<li>Include <resource-ref idref="XSLTProcessorAppletDoc"/> in an HTML
client.<br/><br/></li>
+<li>Specify the XML source document and XSL stylesheet.<br/><br/>
+You can use the DocumentURL and StyleURL PARAM tags or the <resource-ref
idref="XSLTProcessorAppletsetDocumentURLDoc"/> and <resource-ref
idref="XSLTProcessorAppletsetStyleURLDoc"/>. If the XML document contains a
stylesheet Processing Instruction (PI), you do not need to specify an XSL
stylesheet.<br/><br/></li>
+<li>Call the <resource-ref
idref="XSLTProcessorApplettransformtoHTMLstringstringDoc"/> which performs the
transformation and returns the new document as a String.</li></ol>
+<p>For an example, see the <jump href="samples/applet/readme.html">sample
applet readme</jump>.</p>
+</s3><anchor name="servlet"/>
+<s3 title="Using &xslt4j; in a servlet">
+<p>You can set up a servlet to use &xslt4j; to respond to requests for XML
documents by transforming those documents into HTML and serving them to
clients. For a sample of how this might be done, see <link idref="samples"
anchor="servlet">sample servlet</link>.</p>
</s3><anchor name="extensions"/>
-<s3 title="Create and use extensions">
-<p></p></s3>
+<s3 title="Creating and using extensions">
+<p>For those cases where you want to be able to call procedural code from
within a stylesheet, the &xslt4j; Extensions facility supports the creation of
extension elements and extension functions. See <link
idref="extensions">Extensions</link> and <link idref="samples"
anchor="extensions">Extensions samples</link>.</p>
+</s3>
</s2>
</s1>
1.2 +60 -123 xml-xalan/xdocs/sources/xalan/api.xml
Index: api.xml
===================================================================
RCS file: /home/cvs/xml-xalan/xdocs/sources/xalan/api.xml,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- api.xml 2000/02/04 14:39:50 1.1
+++ api.xml 2000/02/11 23:18:59 1.2
@@ -67,111 +67,39 @@
concerning the current release, see <link idref="readme">Release
Notes</link>.</p>
<p>&xslt4j; takes as primary input an XML source document and an XSL
stylesheet. The XML document and the XSL stylesheet
- may be a URL or file, a character stream, an input stream, or a DOM
tree. The stylesheet may also take the form of a
+ may be a URL or file, a character stream, an byte stream, a DOM tree, or
a SAX input source. The stylesheet may also take the form of a
compiled stylesheet. If the XML document contains a stylesheet
Processing Instruction (PI), a separate stylesheet is not
required.</p>
- <p>&xslt4j; uses an implementation of the <resource-ref
idref="XMLParserLiaisonDoc"/> to interact with &xml4j; (or another
- XML parser) and sends output events to an extension of
+ <p>&xslt4j; uses an implementation of the <resource-ref
idref="XMLParserLiaisonDoc"/> to interact with an
+ XML parser) and sends output events to <resource-ref
idref="XSLTResultTargetDoc"/>, an extension of
<resource-ref idref="SAX"/> <resource-ref
idref="SAXDocumentHandler"/>.</p>
- <p>The XSLT and XPath engines are independent from any given DOM or XML
implementation. All parser-dependent calls are
- funneled through the XMLParserLiaison.</p>
+ <p>The XSLT and XPath engines are independent from any given DOM or XML
implementation. All parser-dependent
+ calls are funneled through the XMLParserLiaison.</p>
</s2>
<s2 title="Performing XSL Transformations">
- <p>This release of &xslt4j; supports three mechanisms for transforming
an xml document.</p>
+ <p>This release of &xslt4j; directly supports three mechanisms for
transforming an XML document.</p>
<ul>
- <li>Calling the &xslt4j; processor from the command-line</li>
- <li>Calling the &xslt4j; API from another java class</li>
- <li>Using the &xslt4j; applet wrapper</li>
+ <li>Calling the &xslt4j; processor from the <link
idref="commandline">command line</link></li>
+ <li><link idref="getstarted" anchor="java-apps">Calling the &xslt4j;
API from another java class</link></li>
+ <li><link idref="getstarted" anchor="applet">Using the &xslt4j; applet
wrapper</link></li>
</ul>
- <p>For information about performing transformation from the command-line
or a script, see <jump
- href="CommandLineUtility"/>.</p>
- <s3 title="Calling the &xslt4j; API from a java class">
- <p>In the java class where you want to perform an XSL transformation, do
the following:</p>
- <ol>
- <li>Call one of the <resource-ref idref="XSLTProcessorFactoryDoc"/>
static getProcessor() methods to
- instantiate an implementation of the <resource-ref
idref="XSLTProcessorDoc"/>.<br/><br/>
- XSLTProcessorFactory uses XSLTEngineImpl, an implementation of the
XSLTProcessor interface that you never need
- to call directly.<br/><br/></li>
- <li>Create <resource-ref idref="XSLTInputSourceDoc"/> objects for the
XML source document and the XSL stylesheet,
- and an <resource-ref idref="XSLTResultTargetDoc"/> object for the
output.<br/><br/>
- If the XML document contains a stylesheet Processing Instruction (PI),
you do not need to create
- a separate XSLTInputSource object for an XSL
stylesheet.<br/><br/></li>
- <li>Call the <resource-ref
idref="XSLTProcessorProcessDoc"/>.<br/><br/></li></ol>
- <p>In your application, for example, you could include the following
transform method(), then call this method with file
- names or URLs for the source XML document, the XSL stylesheet and the
new document to be produced.</p><source>
-public static void transform(String xmlSourceURL, String xslURL, String
outputURL)
- throws java.io.IOException,
- java.net.MalformedURLException,
- org.xml.sax.SAXException
-{
- // Instantiate an XSLTProcessor.
- org.apache.xalan.xslt.XSLTProcessor processor =
- org.apache.xalan.xslt.XSLTProcessorFactory.getProcessor();
-
- // Create the 3 objects the XSLTProcessor needs to perform the
transformation.
- org.apache.xalan.xslt.XSLTInputSource xmlSource =
- new org.apache.xalan.xslt.XSLTInputSource
(xmlSourceURL);
- org.apache.xalan.xslt.XSLTInputSource xslSheet =
- new org.apache.xalan.xslt.XSLTInputSource (xslURL);
- org.apache.xalan.xslt.XSLTResultTarget xmlResult =
- new org.apache.xalan.xslt.XSLTResultTarget
(outputURL);
+ <p>You can also use &xslt4j; to perform transformations in a servlet.
For an example, see <link
+ idref="samples" anchor="servlet">sample servlet</link>.</p>
+<anchor name="applet"/>
- // Perform the transformation.
- processor.process(xmlSource, xslSheet, xmlResult);
- }</source>
- <p>The XSLTProcessor "compiles" the input XSL stylesheet into an
internal representation,
- the <resource-ref idref="StylesheetDoc"/>. You can compile the
stylesheet separately,
- before the transformation is complete, via the <resource-ref
idref="XSLTProcessorProcessStylesheetDoc"/>. This is
- especially useful when you need to get information from the stylesheet
before the tranformation occurs,
- for instance, when you need to find out the output encoding in order to
construct the right kind of Writer.</p>
- <p>Stylesheet parameters can be set via the <resource-ref
idref="XSLTProcessorSetStylesheetParamDoc"/>.
- This method takes as input an <resource-ref idref="XObjectDoc"/> or
derivative. The
- XObject class itself can hold any kind of Java object, if you need to
pass it
- to an extension. Each XObject type has a convenience function on the
XSLTProcessor class to make it easy
- to create:</p>
- <ul>
- <li><resource-ref idref="XObjectDoc"/>, <resource-ref
idref="XSLTProcessorCreateXObject"/></li>
- <li><resource-ref idref="XNodeSetDoc"/>, <resource-ref
idref="XSLTProcessorCreateXNodeSet"/> or
- <resource-ref idref="XSLTProcessorCreateXNodeSet2"/></li>
- <li><resource-ref idref="XBooleanDoc"/>, <resource-ref
idref="XSLTProcessorCreateXBoolean"/></li>
- <li><resource-ref idref="XNumberDoc"/>, <resource-ref
idref="XSLTProcessorCreateXNumber"/></li>
- <li><resource-ref idref="XNullDoc"/>, <resource-ref
idref="XSLTProcessorCreateXNull"/></li>
- <li><resource-ref idref="XStringDoc"/>, <resource-ref
idref="XSLTProcessorCreateXString"/></li>
- </ul>
- <p>&xslt4j; is thread-safe for one instance per thread. <em>However,
- if you reuse the processor instance, you should call reset() between
calls.</em></p>
- <p>The XPath engine has pluggable backend drivers called <resource-ref
idref="XLocatorDoc"/>s.
- The default implementation of the XLocator is the <resource-ref
idref="SimpleNodeLocatorDoc"/>.
- Though users of the API can implement their own XLocators for custom
data access,
- it is not for the faint of heart.</p>
-</s3>
-
-<s3 title="Using the &xslt4j; applet">
-<ol>
-<li>Include <resource-ref idref="XSLTProcessorAppletDoc"/> in an HTML
client.<br/><br/></li>
-<li>Specify the XML source document and XSL stylesheet.<br/><br/>
-You can use the DocumentURL and StyleURL PARAM tags or the <resource-ref
idref="XSLTProcessorAppletsetDocumentURLDoc"/> and <resource-ref
idref="XSLTProcessorAppletsetStyleURLDoc"/>. If the XML document contains a
stylesheet Processing Instruction (PI), you do not need to specify an XSL
stylesheet.<br/><br/></li>
-<li>Call the <resource-ref
idref="XSLTProcessorApplettransformtoHTMLstringstringDoc"/> which performs the
transformation and returns the new document as a String.</li></ol>
-</s3>
<anchor name="debugger-interface"/>
</s2>
<s2 title="Debugger Interface">
- <p>&xslt4j; contains a debugger interface in the
org.apache.xalan.xslt.trace package. This
- should be looked upon as a work in progress, possibly to be
replaced by a more
- standard interface in the future. The source code
information given is
- somewhat limited by what the SAX interface provides... the
line and column numbers
- at the *end* of the event. I'll have to work on obtaining
the character selection
- of the executing event. Also, at this time there is no
source tree line information
- available. Again, I'll be working on this. The interfaces
are:</p>
+ <p>&xslt4j; contains a debugger interface in the
org.apache.xalan.xslt.trace package:</p>
<ul>
<li>The <resource-ref idref="TraceListenerDoc"/> is an
interface that debuggers
can implement. The interface can be set on the
<resource-ref idref="XSLTProcessorDoc"/> by calling the
addTraceListener() function.<br/><br/></li>
<li>The <resource-ref idref="PrintTraceListenerDoc"/> is an
implementation of
- the TraceListener interface that is used by &xslt4j; for the
-TT, TG, and -TTC
- switches. It's code is a good example to look at when
figuring out how to
- use the trace functionality.<br/><br/></li>
+ the TraceListener interface that is used by the <link
idref="commandline">command-line utility</link>
+ for the -TT, TG, and -TTC. You can examine the utility code
(org.apache.xalan.xslt.Process.java)
+ for examples of how you might use the trace
functionality.<br/><br/></li>
<li>The <resource-ref idref="TracerEventDoc"/> is an event
that is
passed to the TraceListener.trace() function. It is called
before a node is 'executed'
in the stylesheet.<br/><br/></li>
@@ -179,41 +107,50 @@
passed to the TraceListener.generated() function. It is
called after an event
occurs to create something in the result tree.<br/><br/></li>
</ul>
- </s2>
+ <p>Example:</p>
+ <source>
+import org.apache.xalan.xslt.XSLTProcessor;
+import org.apache.xalan.xslt.trace.PrintTraceListener;
+...
+// Set up a PrintTraceListener object to print to a file.
+java.io.FileWriter fw = new java.io.FileWriter("events.log");
+java.io.PrintWriter pw = new java.io.PrintWriter(fw);
+PrintTraceListener ptl = new PrintTraceListener(pw);
+
+// Print information as each node is 'executed' in the stylesheet.
+ptl.m_traceElements = true;
+// Print information after each result-tree generation event.
+ptl.m_traceGeneration = true;
+// Print information after each selection event.
+ptl.m_traceSelection = true;
+// Print information whenever a template is invoked.
+ptl.m_traceTemplates = true;
+
+// Register the PrintTraceListener with the XSLTProcessor.
+XSLTProcessor processor = XSLTProcessorFactory.getProcessor();
+processor.addTraceListener(ptl);
+
+...
+// Perform the transformation -- printing information to
+// events.log during the process.
+processor.process(new XSLTInputSource("foo.xml"),
+ new XSLTInputSource("foo.xsl"),
+ new XSLTResultTarget("foo.out"));
+...
+// Close the PrintWriter and FileWriter.
+pw.close();
+fw.close();
+</source>
+</s2>
- <s2 title="Source Code">
- <p>The source code is in the <resource-ref
idref="SourceCodeDir"/>.</p>
- <p>The <resource-ref idref="XSLTEngineImplJava"/> class is
where the main
- stuff is going on. This is a big file, so I highly recommend
using an IDE.</p>
- <p> The XPaths are parsed in the
- <resource-ref idref="XPathProcessorImplDoc"/>, the result
XPath object is
- performed in the <resource-ref idref="XPathDoc"/>, and the
query and pattern
- match is performed in the <resource-ref
idref="SimpleNodeLocatorDoc"/>>.</p>
+ <s2 title="Notes on the source code">
+ <ul>
+ <li>The &xslt4j; source code tree is in the src
directory.<br/><br/></li>
+ <li>Much of the work involved in a transformation is performed
by <resource-ref
+ idref="XSLTEngineImplDoc"/>.<br/><br/></li>
+ <li>XPath expressions are parsed in the <resource-ref
idref="XPathProcessorImplDoc"/>.
+ The <resource-ref idref="XPathDoc"/> represents the resulting XPath
object. The
+ <resource-ref idref="SimpleNodeLocatorDoc"/> performs queries and
pattern matching.<br/><br/></li>
+</ul>
</s2>
- <s2 title="Glossary">
- <gloss>
- <label>XSL Instruction</label>
- <item>Any tag with an XSL namespace prefix.<br/><br/></item>
-
- <label>XSL Template Instruction</label>
- <item>Any tag with an XSL namespace prefix
- that occurs inside an xsl:template element.<br/><br/></item>
-
- <label>Template Child</label>
- <item>Any node that is a child of an xsl:template
element.<br/><br/></item>
-
- <label>Source Tree</label>
- <item>The tree input to the XSL process.<br/><br/></item>
-
- <label>Result Tree</label>
- <item>The tree that is output by the XSL process.<br/><br/></item>
-
- <label>Stylesheet Tree</label>
- <item>The stylesheet tree produced from the XSL
file.<br/><br/></item>
-
- <label>Pattern List</label>
- <item>A parsed query or match pattern.<br/><br/></item>
- </gloss>
- </s2>
-
</s1>
