SAXON: Change History

This file describes changes for versions 7.0 and later. For changes prior to version 7.0, see http://saxon.sf.net/saxon6.5/changes.html.

Changes in version 7.0 (2001-12-20)

This version introduces initial support of features defined in working drafts of XSLT 2.0 and XPath 2.0.

Version 7.0 should be regarded as an experimental alpha release. For production use, please continue to use Saxon 6.5

The Saxon package name has changed from com.icl.saxon to net.sf.saxon. Any applications that use Saxon java classes directly (rather than relying on the JAXP interface) will need to be modified. Note that this also affects the settings of the system properties javax.xml.parsers.SAXParserFactory and javax.xml.transform.TransformerFactory.

The entry point from the command line has changed from com.icl.saxon.StyleSheet to net.sf.saxon.Transform.

The namespace URI for saxon extensions has changed from http://icl.com/saxon to http://saxon.sf.net/. Note that many extensions have been withdrawn, as they are superseded by facilities in XPath 2.0 and/or XSLT 2.0.

To allow coexistence, the name of the JAR file for this release has changed to saxon7.jar. The SQL extensions are now in a separate JAR file, saxon7-sql.jar. A transformation can now be executed directly from the JAR file using the command java -jar saxon7.jar in place of java net.sf.saxon.Transform.

Saxon now requires JDK 1.2 or later to run. In consequence, Saxon will no longer work with the Microsoft Java VM, and the Instant Saxon version of the product is therefore no longer available.

Because Saxon no longer runs with the Java VM, it can now be run as an applet within Internet Explorer only if the Sun Java plug-in is installed. You can get this from http://java.sun.com/getjava. This may require some configuration changes because of the differences in security policy.

The following sections summarize the main new features. These assume familiarity with the XPath 2.0 and XSLT 2.0 specifications; however, summaries of the new syntax for expressions and XSLT elements are included in this package.

XPath 2.0 Data Model and Language

• Sequences of nodes or simple values are supported, including the sequence constructor expression ($a, $b, $c). Path expressions now return a sequence of nodes containing no duplicates, in document order.
• The new if expressions, for expressions, some and every expressions are supported.
• New operators are implemented: except, intersect and union for combining sequences (implemented only for sequences of nodes at this release); also ==, !== for comparing node identity, and << and >> for comparing relative position of nodes in document order. These return () when an operand is (), and fail when an operand contains more than one node.
• Any expression may now appear on the right-hand side of the "/" operator (a run-time error is reported if it doesn't evaluate to a sequence of nodes). Examples: a/(b|c)/d, or document('x')/key('a','b')
• Added range expressions. For example 1 to 10 evaluates to the sequence ( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 )
• The new numeric data types integer, decimal, and float are implemented. XPath literals, and string-to-number conversion, now allow "e" in a numeric literal. A literal containing an "e" is interpreted as a double, any other literal containing a "." is interpreted as a decimal, and any other numeric literal as an integer. Integers are limited to 64-bit quantities, but decimals are of unlimited size. Arithmetic is now done using the XPath 2.0 type promotion rules, except that "div" and "mod" always convert both arguments to double. For the time being, I have retained the XPath 1.0 rule that the string representation of a number never ends in ".0"; I found that changing it to use the canonical representation defined in XML Schema (as required by XPath 2.0) meant rewriting too many of my tests. However, negative zero now converts to the string "-0" (it was "0" at XPath 1.0).
• The code for equals, not-equals, etc, has been generalized to work on any sequence in the same way as for a node-set. This retains the "existential" semantics of XPath 1.0. It still does a comparison of the string-value of each item, not the typed value.
• Filter expressions now work on any sequence (including a singleton sequence, so 2[1] is allowed)
• 3-valued logic has been implemented for AND and OR. (This doesn't reflect the XPath 2.0 working draft as published: a late change was made).
• The syntax *:localname (like prefix:*) is allowed in path expressions, and also in patterns and in xsl:strip-space and xsl:preserve-space. It matches any node with the given local name, regardless of namespace.
• The Context object has been changed so that there is a context item rather than a context node. The context item is either a simple value or a node. The expression "." returns the value of the context item. If the context item is not a node, then relative path expression (including self::node()) return an empty node-set. Absolute path expressions (starting with "/"), and key() and id(), now apply to the document containing the current node, as distinct from the context node. Note: the implementation of context document doesn't accurately reflect the concept of the context document in the XPath 2.0 working draft as published.
• The rules for string-to-boolean conversion have changed so that "", "0" and "false" now return false, all other strings return true.

XSLT 2.0 features

• The xsl:value-of element has a new separator attribute, so it can be used to output a sequence.
• The xsl:for-each element supports arbitrary sequences.
• The extension elements saxon:group and saxon:item are withdrawn.
• The new xsl:for-each-group instruction, and the associated current-group() function, are implemented.
• The xsl:function and xsl:result elements are implemented; these replace saxon:function and exslt:function. Note that the XSLT 2.0 specification is more restrictive as to what can appear in a function body: it has to be zero or more xsl:param elements, followed by zero or more xsl:variable elements, followed by an xsl:result element. However, this is not a serious restriction in practice, because most computations can now be carried out within a single XPath expression.
• The new xsl:namespace instruction is implemented (it writes a namespace node to the result tree)
The xsl:copy-of can now handle sequences containing simple-values (the simple value is converted to a string and written to the result tree). However, the separator attribute is not yet implemented.
• The xsl:document element (and its synonym saxon:output) are replaced by xsl:result-document. This no longer includes the serialization attributes directly, instead it refers by name to an xsl:output declaration, or can use the unnamed xsl:output declaration by default.
• The xsl:output element now supports method="xhtml", replacing method="saxon:xhtml". The precise details of the output may not be fully conformant with the specification.
• The xsl:destination element is provided, however, since the href attribute is currently ignored, it is not very useful at this stage.
• The saxon:handler element is no longer supported.
• The xsl:script element is no longer supported - however, the synonym saxon:script remains available
• A collation attribute has been added to xsl:sort, and the implementation of sorting now uses JDK 1.2 collators. The collation attribute must match the name attribute of a saxon:collation element. If none is specified, the lang attribute is now used to select a collator, or if the lang attribute is omitted, a collator is obtained for the default locale.
• Named sort keys are available, via the xsl:sort-key element. A named sort key may be used to perform a sort from within an XPath expression, using the new XSLT-defined sort() function.

Function Library

I have made the following changes to the function library:

• The saxon:distinct() extension function now works on any sequence.
• The count() and sum() functions now ork on any sequence, and new functions avg(), min(), and max() are provided.
• Added ends-with()
• Added upper-case() and lower-case(). These use the rules defined by the Java default locale
• Added properties "product-name" and "product-version" to system-property()
• Removed the saxon:range() extension function (it can now be done using the syntax "a to b")
• Changed saxon:tokenize() to return a sequence of strings instead of a node-set
• Changed key() so that the second argument can be any sequence; each member of the sequence is converted to a string and treated as a potential key value
• Changed document() so that the first argument can be any sequence; each member of the sequence can be a URI of a document to be loaded.
• Removed the saxon:node-set() extension function, which is now obsolete.
• Removed the saxon:if() extension function, which is superseded by XPath 2.0 conditional expressions.
• The saxon:closure() function is temporarily withdrawn, because it relies on non-standard use of the current() function.
• The node-set() function in the EXSLT common module is now a no-op; the object-type() function returns one of "sequence", "boolean", "number", "string", or "external".
• Changed highest() and lowest() in the EXSLT math module to work on arbitrary sequences.
• Added exists() and empty(), insert() and remove(), index-of() and sublist().
• Added not3() (three-valued not() function)
• Added string-pad() function
• Removed saxon:exists() and saxon:for-all(): these are superseded by the some and every constructs in XPath 2.0
• Added the compare() function: the third argument (collation) is initially mandatory, and must be a QName matching a saxon:collation element
• Added base-uri() function replacing the undocumented saxon:base-uri() extension function
• Added constructor functions as described in the XPath Functions and Operators specification: some of them don't do much yet, but float() is the only way of creating a single-precision floating point number.

Significant Omissions

In general, features of XSLT 2.0 and XPath 2.0 not listed above have not been implemented. In particular, these include:

• Backwards compatibility mode in XSLT
• The type attribute of xsl:variable, etc.
• Uniform handling of the empty sequence by functions and operators in XPath expressions
• XPath constructs related to types, for example instance of and cast as.

Internal changes

As might be expected, the Saxon code has undergone major change internally, which will affect any application making significant use of internal interfaces. Here are some of the highlights:

• The NodeEnumeration class is replaced with SequenceIterator. This is modelled on the JDK 1.2 Iterator interface, and can return any sequence of Items. An Item is either a SimpleValue or a NodeInfo.
• Added the getAnother() method to the SequenceIterator interface. This means all SequenceIterators can clone themselves to produce another SequenceIterator of the same nodes. (But it's not a pure Java clone, because the new iterator is positioned at the start of the sequence.) The implementation of last() has changed: if the SequenceIterator doesn't know how many nodes there are in the sequence, the iterator is cloned and the items are counted, without being saved in memory as previously. This should only happen once for any given iterator, so in general calling last() causes a node-set to be scanned twice.
• The Step class has been removed. A step that is a simple unfiltered axis expression is now represented by an AxisExpression; a step with filters is represented by a FilterExpression, and any other kind of expression may also now be used in a PathExpression.
• An important new internal class is the MappingIterator. This maps one sequence to another sequence by invoking a MapppingFunction on each member of the first sequence. This capability is now used to implement both path expressions and for expressions. It is also used in various other contexts, e.g. in the implementation of the document(), key() and id() functions.
• The asString method on Value is renamed getStringValue, this allows both SimpleValues and Nodes to implement the new Item interface, which represents a member of a sequence.
• Internal changes in support of datatypes: I removed evaluateAsDouble(), etc, and replaced them with a generic method evaluate(context, requiredType), which always returns a Value. A new package, net.sf.saxon.value, now contains all the data-type related classes.
• The functions key(), id(), and document() are now fully pipelined, that is, they deliver an iterator over the result nodes.
• The classes that handle sorting have been totally rewritten, partly to handle general sequences, and partly to use collations.
• The Context class has changed. There are now two separate classes, XSLTContext and XPathContext. There is only one XSLTContext object used during a transformation (the information could have been held in the Controller itself). Stacking of values in the XSLT context uses the Java program execution stack, in the sense that any routine that sets a new value has to remember the old value and reset it on completion. The XPath context, by contrast, still creates a new instance every time a new value is stacked. This essentially just wraps the SequenceIterator that represents the context node list. The SequenceIterator itself is responsible for returning current item and current position.

I have removed documentation of the saxon:trace extension attribute; it seems this hasn't been working for some time.

API changes

• The Context class no longer implements the XSLT 1.1 WD interface org.w3c.xsl.XSLTContext.
• Dropped the classes in com.icl.saxon.handlers (ElementHandler etc). It is still possible for a Java application to register a NodeHandler to receive events; this must now be written as an implementation of the net.sf.saxon.NodeHandler interface. See the ShowBooks.java sample application to see how.
• It is no longer possible to specify a user-defined collation using the data-type or lang attribute of xsl:sort; instead, it must be specified using the collation attribute, with a saxon:collation element that maps the named collation to a Java class that implements the JDK java.util.Comparator interface.

SQL extension elements

A new sql:query instruction has been added, to accompany the existing sql:connect, sql:insert, etc.

Attributes:

The xsl:query instruction writes zero or more row elements to the current result tree, each containing zero or more column elements, which contain the data values.

Thanks to Claudio Thomas [claudio.thomas@web.de] who supplied the original version of this code.

The SQL extensions are now contained in a separate JAR file, saxon7-sql.jar, which must be on the class path if these extensions are used.

Michael H. Kay
20 December 2001