SAXON: Change History

For changes up to version 5.0, see history.html

Changes in version 5.3.2 (2000-05-12)

This is an error-clearance release: it clears defects found in version 5.3.1

Other changes:

• Changed the collating sequence for type=number so that NaN (not-a-number) always collates last. Previously the position was undefined, so NaN values could appear anywhere in the sequence. Note this does not affect the results of direct numeric comparisons using the "<" and ">" operators in XPath: in these cases, the result of a comparison with NaN is always false.

• External functions whose arguments or result are of types short, int, long, and float (or their object wrapper equivalents) may now be called in the same way as those whose arguments/results are of type double.

• Initial XHTML support: on xsl:output and saxon:output, you can now set method="saxon:xhtml" (in fact you can use any non-null namespace, so long as the local name is "xhtml"). This follows the same rules as method="xml", except that it follows the guidelines for making the XML acceptable to legacy HTML browsers. Specifically (a) empty elements such as <br/> are output as <br/>, and (b) empty elements such as <p/> are output as <p></p>. The indent attribute defaults to "yes", and HTML indenting rules are used. (There are many other things that could be done to offer more complete XHTML support, e.g. using the HTML rules for escaping URLs, using CDATA sections for <script> elements, etc)

• Rebuilt using the final SAX2 distribution (but the LexicalHandler interface, which Saxon uses, is still at beta status).

Defects in version 5.3.1

Changes in version 5.3.1 (2000-04-20)

This is an error-clearance release: it clears defects found in version 5.3 (see below), also 5.2/021

Other changes:

• Removed the warning issued when a SAX1 parser is used.

• The -t option on the command line now causes the class name of the XML parser to be output (but for a SAX1 parser this is always org.xml.sax.helpers.ParserAdapter)

• Java API: The endPrefixMapping() method in the Emitter interface is removed. It is now the responsibility of the Emitter to track namespace declarations. This change is made as a result of the fix to defect 5.3/008.

• Added saxon:disable-output-escaping attribute to xsl:attribute. This allows output of query strings such as <a href="servlet?x=2&y=3">, and also prevents substitution of special characters by %xx in HTML URL attributes.

• Rebuilt using the latest SAX2 prerelease from David Megginson. The helper classes in this distribution were incomplete so I rebuilt them from the source distributed with the previous beta, making the necessary changes - renaming getRawName() to getQName() in the Attributes interface.

Defects in version 5.3

Changes in version 5.3 (2000-04-14)

The SaxonServlet sample servlet code has been changed so that the source=x and style=y parameters in the URL request are now interpreted relative to the servlet context. This means that specifying say "style=/styles/styleone.xsl" in the URL will locate the stylesheet in this file relative to the root directory for the web server.

The command-line interface (com.icl.saxon.StyleSheet) can now process an entire directory. Simply specify a directory name as the source file, and another directory as the output destination, for example: java com.icl.saxon.StyleSheet -o outdir sourcedir style.xsl . All the files are processed using the same stylesheet, unless the -a option is used, in which case each one is processed using the stylesheet identified in its own xml-stylesheet processing instruction.

xsl:call-template is extended so the name attribute can be an attribute value template, allowing the name of the called template to be decided at run-time. To activate this extension, the xsl:call-template element must have the extra attribute saxon:allow-avt="yes".

Unary minus in XPath expressions now changes the sign of the number rather than subtracting it from zero. This means that "-0" is now negative zero rather than positive zero. The specification does not actually define this, it says only that "-" is a subtraction operator, but James Clark has stated that this is what the spec should have said: it is intuitive, and consistent with Java and Javascript. The change is very unlikely to affect real applications.

The namespace for extension functions can now consist simply of the fully-qualified Java class name; there is no need for a leading "/". E.g. xmlns:math="java.lang.Math"

The type pseudo-attribute of the <?xml-stylesheet?> processing instruction may now take the value "text/xsl", for compatibility with Microsoft. The official values "text/xml" and "application/xml" are also supported (these do not currently work with Microsoft MSXML).

Added URIResolver class. You can create a subclass of URIResolver, and register it using PreparedStyleSheet.setURIResolver(), to handle URI formats other than standard URLs, including private conventions to get data from sources such as databases. The URIResolver is called to handle URIs appearing xsl:include, in xsl:import, and in the document() function. For a given URI, it returns an InputSource. If it returns an ExtendedInputSource, it can also dictate which XML parser should be used for this specific URI.

Changed ParserManager so that if ParserManager.properties cannot be found, it displays a message on System.err, and then continues using the built-in Ælfred parser.

The architecture is now based on SAX2 rather than SAX1. Where possible, SAX1 interfaces have been retained, for example it is still possible to specify a SAX1 parser for input and a DocumentHandler for output. However, some lesser-used interfaces have been deprecated and some removed altogether. The Builder now acts as a SAX2 ContentHandler, no longer as a SAX1 DocumentHandler. Recompiling any Java application will reveal any calls that are affected. Where a SAX1 parser is supplied, it is now used via the SAX2 ParserAdapter class.

The version of Ælfred supplied with the product is now based on David Brownell's version, which includes a number of bug fixes and performance improvements relative to the original Microstar parser.

There have been many internal changes to achieve improved performance. These should have no impact on existing stylesheets, and in most cases they should have no impact on Java applications. There are some changes to the classes NodeSetValue and FragmentValue, which may be used by extension functions, but the principal methods are unchanged. For performance, it is best to retrieve the nodes in a node-set as an array or as a NodeEnumeration rather than as a Vector. NodeSetValue is now an abstract class: any code that constructs a node-set should now use NodeSetExtent instead.

Here is a summmary of the main internal performance changes:

• Node-sets, and many other internal data structures, are held as arrays rather than Vectors.
• Evaluation of node-sets is more likely to be done as a pipeline, for example the node-set is no longer fully expanded when it is assigned to a variable. This makes it more likely that an expression such as "preceding-sibling::*[1]" will avoid retrieving unwanted nodes.
• Stripping of whitespace nodes is now generally done before nodes are added to the tree, by means of a SAX filter. Nodes are removed from the tree only in the case where the stylesheet is embedded in the source document.
• A result tree fragment is no longer held as a tree, but as a sequence of output instructions. The tree is built (using these output instructions) only when xsl:copy-of or saxon:nodeset() is called. The string value of the result tree fragment is constructed eagerly, as text nodes are added: this is on the assumption that most result-tree-fragments are used simply as strings.
• Tail recursion has been implemented where a named template calls itself as the last thing it does. This doesn't improve speed, but it does reduce memory usage for a heavily-recursive stylesheet.
• The management of internal data structures such as the document tree, the variable stack, and the name pool, has been improved to minimize the number of objects allocated.
• Successive calls of format-number() using the same second and third arguments now reuse the underlying Java objects rather than creating them afresh each time. This makes a dramatic difference with the Microsoft Java VM, less so with the Sun Java VM which appears already to perform a similar optimisation.
• A simple call of <xsl:number/> now retains memory of the previous numbered node, so numbering a sequence of sibling nodes now has linear execution time. Note this does not apply if the xsl:number element has any attributes (other than the default level="single").
• A path expression of the form "//ITEM", if it contains no predicates, is now treated as "/descendant::ITEM" rather than "/descendant-or-self::node()/child::ITEM". The two are equivalent, but the former is faster, as it retrieves the nodes in document order and therefore requires no sort.
• Axes that are in reverse document order are now recognized as a special case when sorting into document order. Previously a full sort took place. Various unnecessary sorts have also been eliminated, for example on the expressions attribute::* and following::*
• Nodes in the tree now carry a sequence number, to speed up the process of sorting into document order.
• Mode names are resolved at stylesheet preparation time rather than at execution time.

The overall performance improvement is in most cases around a factor of two.

Defects in version 5.2

Changes in version 5.2 (2000-02-12)

Extension functions

The mechanism for calling extension functions has changed, to improve compatibility with xt and Xalan. Static methods are unaffected. Methods with no state that are NOT declared static should either be declared static, or the class must now be explicitly instantiated using the function new(). Instance-level (non-static) methods are now called by supplying the instance as an extra first argument. See extensibility.html for more details. As a result of these changes, the following stylesheet provided as an example in the xt documentation now works unchanged with SAXON:

<xsl:stylesheet
  version="1.0"
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  xmlns:date="http://www.jclark.com/xt/java/java.util.Date">

<xsl:template match="/">
  <html>
    <xsl:if test="function-available('date:to-string') and function-available('date:new')">
      <p><xsl:value-of select="date:to-string(date:new())"/></p>
    </xsl:if>
  </html>
</xsl:template>

</xsl:stylesheet>

SAXON-supplied extension functions can now be called using the standard SAXON namespace URI, "http://icl.com/saxon", instead of using "/com.icl.saxon.functions.Extensions". This means the same namespace can be used for SAXON extension elements and extension functions. The old URI will continue to work.

Several new extension functions are available, described in detail in extensions.html:

• saxon:distinct() takes a node-set and eliminates nodes with duplicate string-values.
• saxon:evaluate() evaluates an XPath expression constructed at run-time, as a string.
• saxon:range() creates a node-set containing a list of numbers, allowing xsl:for-each to be used as a traditional for-loop.
• saxon:tokenize() tokenizes a string value and creates a node-set containing one node for each token value in the string.

Output formatting

The XML output method now uses abbreviated syntax for empty element tags (e.g. <EMPTY A="a"/>)

The XML and HTML output methods avoid outputting unnecessary character references, e.g. for quotes occurring in character data.

The HTML output method now uses entity references for characters in the range 160-255, even when the character is available in the selected encoding. Characters above this range are output as native UTF-8 characters if the encoding is UTF-8, or as character references otherwise. This approach is a compromise and I recognise that it will not please everyone. The idea behind it is to try and avoid using UTF-8 characters for English and Western European languages, where many users will have keyboards and editors that cannot handle them, but to use them for non-European languages, as users working in those languages are more likely to be able to cope with UTF-8.

The indentation algorithms have changed, for both XML and HTML: the result is more careful about where it adds whitespace, though it is not necessarily more attractive. On saxon:output you can also now specify the amount of indentation, e.g. indent="2" indents by two spaces. The default is three.

The HTML output method now escapes non-ASCII characters in URI attributes using the %HH escape convention.

XSLT conformance

For conformance reasons, the method attribute of xsl:output may no longer take the values "fop" or a Java class name. Instead, these values must be qualified by a namespace prefix. It does not matter what the namespace URI is, so long as it exists. For example, change method="fop" to method="saxon:fop", and method="com.me.MyEmitter" to method="saxon:com.me.myEmitter".

For conformance reasons, the ability to specify the attributes version, extension-element-prefixes, and exclude-result-prefixes on the xsl:template element is withdrawn. These attributes are only allowed on literal result elements and extension elements.

Embedded stylesheets are now supported via the new EmbeddedStylesheet class.

The <?xml-stylesheet?> processing instruction is now supported, via a new method getAssociatedStylesheet() on the DocumentInfo class.

Command line (com.icl.saxon.Stylesheet)

Options may now be specified in any order.

The new -a option will process a specified source document using the stylesheet identified in its <?xml-stylesheet?> processing instruction. No stylesheet should be specified on the command line. The href pseudo-attribute of the xml-stylesheet processing instruction must either be the URL of a freestanding stylesheet in an external document, or a fragment identifier matching the id attribute of an embedded stylesheet within the same document. The type pseudo-attribute should be "text/xml"

The -t option on the command line now outputs product and version identification as well as timing information.

The command line may include the options "-x parser" to specify the parser for source files, and "-y parser" to specify the parser for stylesheet modules. In both cases the parser is the fully qualified class name of a class that implements the SAX org.xml.sax.Parser interface.

Java API

The ExtendedInputSource class is extended to allow a DOM Document to be identified as the input source (for either the source document or the stylesheet).

ExtendedInputSource now has a setParser() interface defining which SAX Parser is to be used to process this input source. This is now the preferred way of specifying a non-default parser; previous methods are deprecated.

Saxon and Instant Saxon now include a bundled version of the AElfred XML parser, modified to notify comments to the application in the same way that James Clark's xp does, i.e. as Processing Instructions with a null target. The ParserManager.properties file has been changed so this is now the default parser.

Defects in version 5.1

Bug 5.0/015 (see below) is fixed in version 5.2. This has required some changes in internal data structures: included and imported stylesheets are no longer grafted into the tree for the principal stylesheet, but are now linked to it using a separate data structure.

Changes in version 5.1 (1999-12-17)

XSL changes

There are no XSL changes in this version other than the bug fixes listed below.

API changes

• The two classes Controller and Stylesheet have once again been subject to a major reorganisation. This is in the interests of making stylesheets, once prepared, reusable and thread-safe. The StyleSheet class is now used only for the command-line interface; underneath it are two new classes: PreparedStyleSheet, which represents a validated and precompiled stylesheet that is ready to run as many times as required, and StyleSheetInstance, which represents a single activation of a PreparedStyleSheet to process a single source document.

  In support of this the Controller class has also been split up, separating those components that depend only on the stylesheet (the RuleManager, the KeyManager, the DecimalFormatManager), and those that depend on the source document (the Builder and the residual Controller).

  The Controller changes make life a bit more difficult for the Java-only user, as the application now has to manage the RuleManager and the Builder as separate objects from the Controller.

• A new class SaxonServlet has been introduced. This is not in any package, as it is intended to be copied into the servlet directory of your web server. This class, once installed, allows Saxon stylesheet processing to be invoked using a URL of the form:

  http://server.com/servlets/SaxonServlet?source=doc.xml&style=sheet.xsl

  The source and style parameters identify the source document and stylesheet by URL. Security is your responsibility: there are no restrictions on the use of file URLs, for example. The stylesheet is prepared the first time it is used, and held in memory in a cache. The cache may be cleared (for example, if a stylesheet has been changed) using a URL such as:

  http://server.com/servlets/SaxonServlet?clear-stylesheet-cache=yes

Saxon extensions

• The integration with James Tauber's FOP processor now works with FOP 0_12_0 or later. This is controlled by setting method="fop" in the xsl:output or saxon:output element.

• The file attribute in saxon:output is no longer mandatory, since with a user-specified Emitter there may be no need to write to a file. There is a new attribute on saxon:output, user-data. It is an attribute value template. The value is available to a user-specified Emitter via the getUserData() method of the OutputDetails object.

• The internal implementation of result tree fragments has changed, to remove the artificial outermost element (named RESULT-TREE-FRAGMENT) that was previously added below the root node. This change is only visible to extension functions that use result tree fragments, or to users of the extension function sxf:nodeset(). This function now returns a root node which immediately contains the text nodes, element nodes, etc that were written to the result tree fragment.

• When a DocumentHandler is supplied in the method attribute to xsl:output or saxon:output, the events passed to the DocumentHandler will now correspond to a well-formed XML document, provided that there is at least one element node in the result tree. (Remember that in general, the result tree can be any external general parsed entity.) This is done by suppressing any text nodes before the first start tag, and suppressing all elements and text nodes after the end tag of the first top-level element. However, if there are no elements at the top level, the events passed to the DocumentHandler will not include a top-level element. If you want to process the full result tree and are prepared for it not to be a well-formed document, write an Emitter rather than a DocumentHandler.

Internal changes

• Implemented name pools, and other minor changes, to reduce the memory occupancy of the tree.

Defects in version 5.0

About a dozen of the defects listed below were found by using the LotusXSL test suite, available from www.alphaworks.ibm.com, and comparing SAXON's results with the published LotusXSL results. I am grateful to IBM for making this test suite available.

Michael H. Kay
12 May 2000