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
