I've been reading the XML litterature. It's great. Just a few
comments:
Welcome on board. It's refreshing to get thoughtful
comments from someone
who's new to the game.
XSL - XML Stylesheets is divided into two parts, XSL-T and
XSL-FO.
The T part deals with templates and translation. Since HTML is valid
XML, I guess I can parse my HTML using XSL-T to produce XML and vice
versa. I don't understand why XSL-T refers to "nodes in an output
tree". This suggests some kind of internal representation, but XML is
perfectly good representation language. Don't <templates> merely
write XML text to stdout?
No, the result tree is completely abstract, there is no
suggestion of an internal representation. In fact, for many XSLT processors,
the "result tree" is represented internally as a stream of events, not
as a linked collection of objects in memory. This concept of writing a tree,
rather than writing text, however is extremely important. Firstly,
it defines a separation of the information content of an XML document
from the accidental aspects of its lexical representation - something that
is sadly missing from the XML spec itself. In turn, this gives you a
basis for defining a concise set of operators that are in some sense
complete, composable and exhibit closure. In practical terms, it gives you
the ability to write a series of transformations - a pipeline - in which the
expensive steps of serializing and parsing intermediate results can be
eliminated.
Roughly, the process seems to work like this: the T processor
does a recursive descent of the source XML. At each node it evaluates the
set of templates. Those templates which match the name of the "current" tag
are processed, in some order. The template writes text, that's why it's
called a "template. The recursive descent is continued with an
<apply-templates> tag inside the template. This allows you to balance
output.
It
doesn't have to do a recursive descent of the source XML: that's up to the
application, though a recursive descent is the most common design
pattern. And it definitely doesn't write text: people who create a mental
model of writing text eventually get a rude awakening, usually when they
first try to tackle grouping problems.
If no matches are found, the T processor continues the descent.
There is a <template> tag (I forget what) which will select
arbitrary paths in the souce tree, and there are tags
which iterate through the result.
Again, it's best to think of the stylesheet as containing nodes
(representing instructions) rather than tags. Consider
<xsl:element name="x"><xsl:value-of
select="."/></xsl:element>
There are three tags there, but four nodes, and only two
instructions. The semantics of the language are described in terms of the
two instructions, not the three tags.
This will allow me to build
up a result "tree" which is not a mirror image of the source, something I
need to do if I'm rearranging sections of the input document. Rather than
buffering intermediate structures, the T processor does multiple passes
based on these tags, and creates the output on-the-fly. Cool.
... .
I assume there is nothing stopping me from using XSL-T to transform my
HTML to PDF, but it seems best to output XSL-FO then create a PDF
using some kind of tool. What is that tool?
It's an XSL-FO processor. Examples are FOP, RenderX, Antenna
House.
Are there FO plug-ins available for my browsers?
No, people are by-and-large using (X)HTML/CSS for the browser,
XSL-FO/PDF for the printed page.
Does this technology work?
Absolutely yes.
Michael Kay
