Using Standalone XSLT Processors

Using Standalone XSLT Processors

One of the most common ways of making XSLT transformations happen is to use standalone XSLT processors. There are plenty of such processors around, although not all can handle all possible XSLT stylesheets. To use an XSLT processor, you just run it from the command line (which means in a DOS window in Windows), giving it the name of the XML source document, the XSLT stylesheet to use, and the name of the document you want to create.

Heres a starter list of some of the available standalone XSLT processors available online, in alphabetical ordermost (but not all) are free:

  • 4XSLT A Python XSLT processor.

  • EZ/X A Java package for both XML parsing and XSLT processing.

  • iXSLT A command-line XSLT processor.

  • Koala XSL Engine A Java XSLT processor using the Simple API for XML (SAX 1.0) and the Document Object Model (DOM 1.0) API.

  • LotusXSL IBMs LotusXSL implements an XSLT processor in Java, and can interface to APIs that conform to the Document Object Model (DOM) Level 1 Specification. A famous XSLT processor, but it now appears to be superceded by Xalan 2.0.

  • MDC-XSL http://mdc-xsl. sourceforge .net. An XSLT processor in C++ that can be used as a standalone program.

  • Microsoft XML Parser This is the Microsoft XML parser, a high-performance parser that is available as a COM component, and can be used to implement XSLT support in applications.

  • Sablotron Sablotron is a fast, compact and portable XSLT processor. Currently supports a subset of the XSLT recommendation. You can use it with C or Perl.

  • SAXON An XSLT processor that fully implements XSLT 1.0 and XPath 1.0, as well as a number of extensions to these specifications. Note that this release has some support for the XSLT 1.1 working draft as well.

  • Transformiix Transformiix is Mozillas XSLT component, now implemented to some extent in Netscape 6.0.

  • Unicorn XSLT processor (UXT) http://www.unicorn- enterprises .com. This XSLT processor supports XSLT Transformations, and is written in C++.

  • Xalan C++ xalan-c /index.html. Implementation of the W3C Recommendations for XSLT and the XML Path Language (XPath). The C++ version of the famous Apache Xalan processor.

  • Xalan Java Java Implementation of the W3C Recommendations for XSLT and the XML Path Language (XPath). The Java version of the famous Apache Xalan processor. Also includes extension functions for SQL access to databases via JDBC, and much more.

  • xesalt This XSLT processor is available as a Web server module (for both Apache and IIS Web servers), Netscape 4.x plug-in, and command line processor.

  • XML parser for C Oracles XSLT processor. Supports the XSLT 1.0 Recommendation, created for use with C.

  • XML parser for Java Oracles XSLT processor. Supports the XSLT 1.0 Recommendation, created for use with Java.

  • XML parser for PL/SQL Oracles XSLT processor. Supports the XSLT 1.0 Recommendation, created for use with PL/SQL.

  • XML::XSLT This is an XSLT parser written in Perl. It implements parts of the XSLT Recommendation.

  • Xport An XSLT transformation processor, available as a COM object.

  • XSL:P An up-to-date XSLT processor.

  • XT XT is a well-known implementation in Java of the XSLT Recommendation.

The following sections examine four of these XSLT processors in more detail: XT, Saxon, Oracles XSLT processor, and Xalan. All these programs are available for free online, and can implement the XSLT examples shown in this book. If you want to follow the examples in this book, it will be useful to pick up one or more of these standalone XSLT processors (probably the best known and most widely used is Xalan). To make XSLT transformations happen, Ill use these XSLT processors throughout the book.

These processors are all Java-based, so youll need Java installed on your system. If you dont already have Java, you can get it for free at Suns Java site. The most recent edition, Java 2 version 1.3, is available at, as of this writing. All you have to do is download Java for your operating system and follow the installation instructions on the download pages.

Although you need Java to run these XSLT processors, dont panic if youre not a programmerno programming is required. Although Chapter 10 does go into some Java programming to show you how to create XSLT transformations in code, all these processorsXT, Saxon, Oracles XSLT processor, and Xalancan be run from the command line.

If you are running Windows, theres an even easier way to use XT and Saxonthey both come packaged as an .exe file (xt.exe and saxon.exe) that you can run directly in Windows, and you wont need Java at all. This way of doing things is covered as well.

Using a Java XSLT Processor

To use a Java-based XSLT processor, you download it and unzip it, and its ready to go. You should read the posted directions, of course, but typically there are just two steps to take.

First, you must let Java know how to find the XSLT processor, which is stored in a Java Archive, or JAR, file. To tell Java to search the JAR file, you set the classpath environment variable to the path of the JAR file. For example, in any version of Windows, you start by opening a DOS window. Then you can execute a line such as the following, which sets the classpath variable to the Oracle XSLT processors JAR file, xmlparserv2.jar, which in this case is stored in the directory c:\oraclexml\lib:

 C:\>set classpath=c:\oraclexml\lib\xmlparserv2.jar 

Now youre ready to take the second step, which is to run the XSLT processor. This involves executing the Java class that supports the XSLT processor. For the Oracle XSLT processor, this is oracle.xml.parser.v2.oraxsl. In Windows, for example, you could change to the directory that held the planets.xml and planets.xsl files, and execute oracle.xml.parser.v2.oraxsl using Java this way:

 C:\planets>java oracle.xml.parser.v2.oraxsl planets.xml planets.xsl planets.html 

This will transform planets.xml to planets.html using planets.xsl. Note that this example assumes that java.exe, which is what runs Java, is in your Windows path. If java.exe is not in your path, you can specifically give its location, which is the Java bin directory, such as c:\jdk1.3\bin (JDK stands for Java Development Kit, and Java 2 version 1.3 installs itself in the c:\jdk1.3 directory by default) as follows :

 C:\planets>c:\jdk1.3\bin\java oracle.xml.parser.v2.oraxsl planets.xml planets.xsl graphics/ccc.gif planets.html 

In fact, you can combine the two steps (setting the classpath and running the XSLT processor) into one if you use -cp with Java to indicate what classpath to use:

 C:\planets>c:\jdk1.3\bin\java -cp c:\oraclexml\lib\xmlparserv2.jar graphics/ccc.gif oracle.xml.parser.v2.oraxsl planets.xml planets.xsl planets.html 

These are all fairly long command lines, and at first you might feel that this is a complex way of doing things. However, theres a reason that most XSLT processors are written in Java: Java is supported on many platforms, from the Macintosh to UNIX, which means that the XSLT processor can run on all those platforms as well.

Of course, this is all a lot easier if youre running Windows and use the precompiled version of either XT (which is xt.exe) or Saxon (saxon.exe). For example, heres how to use xt.exe in Windows to perform the same transformation (this example assumes that xt.exe is in your path):

 C:\planets>xt planets.xml planets.xsl planets.html 

Thats the process in overview; now Ill take a look at each of the four XSLT processors (XT, Saxon, Oracles XSLT processor, and Xalan) in depth, showing exactly how to use each one. First, note two things: XML and XSL software changes very quickly, so by the time you read this, some of it might already be out of date; and although all these XSLT processors are supposed to support all standard XSLT, they give different results on some occasions.

James Clarks XT

You can get James Clarks XT at Besides XT itself, youll also need an XML parser , which XT will use to read your XML document. The XT download also comes with sax.jar, which holds James Clarks XML parser, or you can use James Clarks XP parser, which you can get at, for this purpose.

My own preference is to use the Apache Projects Xerces XML parser, which is available at (As of this writing, the current version, Xerces 1.3.0, is available at in zipped format for UNIX as Xerces-J-bin.1.3.0.tar.gz and Windows as Xerces-J

XT itself is a Java application, and included in the XT download is the JAR file youll need, xt.jar. To use xerces.jar and xt.jar, you must include them both in your classpath, as shown in the following example for Windows (modify the locations of these files as needed):

 C:\>set classpath=C:\xerces-1_3_0\xerces.jar;C:\xt\xt.jar 

Then you can use the XT transformation class, com.jclark.xsl.sax.Driver. class. You supply the name of the parser you want to use, which in this case is org.apache.xerces.parsers.SAXParser in xerces.jar, by setting the com.jclark. xsl.sax.parser variable to that name on the command line. For example, heres how I use XT to transform planets.xml, using planets.xsl, into planets.html in Windows ( assuming that c:\planets is the directory that holds planets.xml and planets.xsl, and that java.exe is in your path):

 C:\planets>java -Dcom.jclark.xsl.sax.parser=org.apache.xerces.parsers.SAXParser graphics/ccc.gif com.jclark.xsl.sax.Driver planets.xml planets.xsl planets.html 

That line is quite a mouthful, so it might provide some relief to know that XT is also packaged as a Win32 executable program, xt.exe. To use xt.exe, however, you need the Microsoft Java Virtual Machine (VM) installed (which is included with the Internet Explorer). Heres an example in Windows that performs the same transformation as the preceding command, assuming xt.exe is in your path:

 C:\planets>xt planets.xml planets.xsl planets.html 

If xt.exe is not in your path, you can specify its location directly, like this if xt.exe is in c:\xt:

 C:\planets>c:\xt\xt planets.xml planets.xsl planets.html 


Saxon by Michael Kay is one of the earliest XSLT processors, and you can get it for free at All you have to do is download and unzip it, which creates the Java JAR file you need, saxon.jar.

To perform XSLT transformations, you first make sure that saxon.jar is in your classpath . For example, in Windows, assuming that saxon.jar is in c:\saxon, you can set the classpath variable this way:

 C:\>set classpath=c:\saxon\saxon.jar 

Now you can use com.icl.saxon.StyleSheet.class, the Saxon XSLT class, like this to perform an XSLT transformation:

 C:\planets>java com.icl.saxon.StyleSheet planets.xml planets.xsl 

By default, Saxon sends the resulting output to the screen, which is not what you want if you want to create the file planets.html. To create planets.html, you can use the UNIX or DOS > pipe symbol like this, which sends Saxons output to that file:

 C:\planets>java com.icl.saxon.StyleSheet planets.xml planets.xsl > planets.html 

If youre running Windows, you can also use instant Saxon, which is a Win32 executable program named saxon.exe. You can download saxon.exe from, and run it in Windows like this (the -o planets.html part specifies the name of the output file here):

 C:\planets>saxon -o planets.html planets.xml planets.xsl 

Oracle XSLT

Oracle corporation also has a free XSLT processor, which you can get from You have to go through a lengthy registration process to get it, though. As of this writing, you click the XDK for Java link at to get the XSLT processor.

When you unzip the download from Oracle, the JAR file you need (as of this writing) is named xmlparserv2.jar. You can put it in your classpath in Windows as follows:

 C:\>set classpath=c:\oraclexml\lib\xmlparserv2.jar 

The actual Java class you need is oracle.xml.parser.v2.oraxsl, and you can use it like this to transform planets.xml into planets.html using planets.xsl:

 C:\planets>java oracle.xml.parser.v2.oraxsl planets.xml planets.xsl planets.html 


Probably the most widely used standalone XSLT processor is Xalan, from the Apache Project (Apache is a type of Web server in widespread use). You can get the Java version of Xalan at Just click the zipped file you want, currently for Windows or xalan-j_2_0_0.tar.gz for UNIX.

When you unzip the downloaded file, you get both xalan.jar, the XSLT processor, and xerces.jar, the XML parser you need. You can include both these JAR files in your classpath like this in Windows (modify the paths here as appropriate for your system):

 C:\>set classpath=c:\xalan-j_2_0_0\bin\xalan.jar;c:\xalan-j_2_0_0\bin\xerces.jar 

To then use planets.xsl to transform planets.xml into planets.html, execute the Java class you need, org.apache.xalan.xslt.Process, as follows:

 C:\planets>java org.apache.xalan.xslt.Process -IN planets.xml -XSL planets.xsl -OUT graphics/ccc.gif planets.html 

Note that you use -IN to specify the name of the input file, -OUT to specify the name of the output file, and -XSL to specify the name of the XSLT stylesheet. Xalan is the XSLT processor well use most frequently, so here are some more details. The following list includes all the tokens you can use with the org.apache.xalan.xslt.Process class, as printed out by Xalan itself:

  • -CR (Use carriage returns only on outputdefault is CR/LF)

  • -DIAG (Output timing diagnostics)

  • -EDUMP [optional]FileName (Do stackdump on error)

  • -HTML (Use HTML formatter)

  • -IN inputXMLURL

  • -INDENT (Number of spaces to indent each level in output treedefault is 0)

  • -LF (Use linefeeds only on outputdefault is CR/LF)

  • -OUT outputFileName

  • -PARAM name value (Set a stylesheet parameter)

  • -Q (Quiet mode)

  • -QC (Quiet Pattern Conflicts Warnings)

  • -TEXT (Use simple text formatter)

  • -TG (Trace each result tree generation event)

  • -TS (Trace each selection event)

  • -TT (Trace the templates as they are being called)

  • -TTC (Trace the template children as they are being processed )

  • -V (Version info )

  • -VALIDATE (Validate the XML and XSL inputvalidation is off by default)

  • -XML (Use XML formatter and add XML header)

  • -XSL XSLTransformationURL

Youll see all these processors in this book, but as mentioned, probably the one Ill use most is Xalan. (The reason I use Xalan most often is because it has become the most popular XSTL processor and is the most widespread use). Of course, you can use any XSLT processor, as long as it conforms to the W3C XSLT specification.

That completes your look at standalone XSLT processors. Theres another way to transform XML documents without a standalone programyou can use a client program, such as a browser, to transform documents.

Inside XSLT
Inside Xslt
ISBN: B0031W8M4K
Year: 2005
Pages: 196 © 2008-2017.
If you may any questions please contact us: