For changes since version 5.0, see changes.html
The following changes are all made to achieve conformance with the XSLT and XPath specifications:
Top-level elements in the stylesheet that are not recognised as xsl elements or extension elements are now ignored. They can be used to hold lookup data, accessed using document('') which returns a reference to the stylesheet document. SAXON extension elements used at the top level (such as saxon:preview) no longer require "saxon" to be declared as an extension element prefix.
Global variables in the stylesheet can now contain forwards references to other global variables, and circular definitions are detected.
xsl:namespace-alias is implemented.
The [xsl:]exclude-result-prefixes attribute is implemented. Previously, namespace declarations were output only if the namespace was used. Now, as defined in the spec, all namespaces defined on a literal result element are output, unless either they are named in an [xsl:]exclude-result-preifxes attribute on a containing element, or they are declared in an [xsl:]extension-element-prefixes attribute, or the URI is the XSL namespace URI. If a namespace is actually used on a literal result element, the namespace declaration is output regardless.
The namespace axis and namespace nodes are implemented.
The unparsed-entity-uri() function is implemented.
The cdata-section-elements attribute of xsl:output is now namespace-aware
If the document() function is called several times to load the same URI, the same document node is returned each time. Previously a new document node (and a new tree) was created each time.
The construct prefix:* is now recognised in xsl:strip-space and xsl:preserve-space.
If two attribute-sets have the same name, they are effectively merged.
While evaluating a sort key, the current node list is now the list of nodes being sorted, in document order. So you can now sort in reverse document order by specifing xsl:sort select="position()" data-type="number" order="descending". (This implements an unannounced change in the final XSLT specification, and has required a redesign of the way composite sort keys are handled internally).
The names of variables, parameters, templates, attribute-sets, keys, modes, decimal-formats, and system-properties are now namespace-sensitive. Names are now checked to ensure they contain valid characters for a QName. Processing instructions are checked to ensure the name is both an NCName and a PITarget.
All errors that must be reported are now reported. In most cases where XSLT provides the option of reporting an error or recovering, SAXON chooses to recover from it, but this is not invariably true.
Changed the built-in template for attribute nodes (class AttributeCopier) to output only the attribute value, not the entire attribute node.
When a CDATA section is output, the character sequence "]]>" is now intercepted and split as defined in the standard.
Implemented the [xsl]:version attribute and forwards compatibility mode.
The lang attribute of xsl:sort is now recognized. The only language supported directly by SAXON is "en" (English); but additional languages can be supported by writing a user-supplied collating class. The default for the lang attribute is taken from the Java default locale. If no collating class for the language can be loaded, collating is in binary Unicode sequence. This facility can also be used to support user-defined collating sequences for data types such as the names of the months (January, February, etc). For details see extensibility.html. As defined in the final XSLT specification, the data-type can now be a name, and this name is available to the collating class if required; however the selection of a class is still driven by the lang attribute.
The grouping-size and grouping-separator attributes of xsl:number are now implemented; and non-Latin digits and letters are accepted in the format specification.
The lang and letter-value attributes of xsl:number are now recognized. The only language supported directly by SAXON is "en" (English); but additional languages can be supported by writing a user-supplied numbering class. The default for the lang attribute is taken from the Java default locale. If no numbering class for the language can be loaded, English numbering is used. The only use made of letter-value in English numbering is that with format="i", the value "alphabetic" can be used to cause a numbering sequence "i", "j, "k" "l", rather than "i", "ii", "iii", "iv". This facility can also be used to support user-defined numbering sequences such as "one", "two", "three", etc. For details see extensibility.html.
With the "Literal Result Element As Stylesheet" facility, the xsl:version attribute (and therefore the xsl namespace) are now mandatory on the outermost element of the stylesheet. The facility may also now be used on included and imported stylesheets.
The current() function can no longer be used in patterns.
The select attribute of xsl:copy-of is now mandatory (previously it defaulted to the current node)
Code changed to handle multiple key definitions with the same name. If there is one key with name="emp" match="employee" use="@empnr", and another with name="emp" match="contractor" use="@nr", then the function call key('emp','123') will find all employees with empnr=123 and all contractors with nr=123.
Now allow a NodeTest after '@' in an expression or pattern. For example, @node() is equivalent to @*, while @comment() returns an empty node-set.
The string-length(), substring() and translate() functions now handle Unicode surrogate pairs correctly, and surrogate pairs are also handled correctly by the XML output method.
The element-available() function, when the element name is in the XSLT namespace, now returns true only for those XSL elements that are classified as instructions.
In the format-number() function, the pattern (2nd argument) must now be localized
using the characters specified in the relevant decimal-format. For example, if the decimal-separator
is "," then the pattern should be written as "####,##" rather than "####.##". There is now
a built-in default decimal format equivalent to including
If no xsl:output element is supplied, or if there is no method attribute on an xsl:output element, and if the first thing to be output is a text node, the output method now defaults to "xml" as required by the XSLT specification; previously it defaulted to "text". The output will not be a well-formed XML document, but it will be a well-formed external general parsed entity.
Comments and processing instructions in the stylesheet are no longer added to the tree. They were previously added to the tree and ignored. The difference is that the text nodes either side of a comment or PI are now concatenated into a single text node, and are only a candidate for whitespace-stripping if both are whitespace-only.
Any attempt to use an attribute with an unprefixed name on an XSL element, when that attribute is not permitted in the XSLT standard, now results in an error message. As well as conforming to the standard, this feature detects many trivial errors.
The following extension functions are implemented. The conventional prefix sxf must be mapped to a namespace URI ending in "/com.icl.saxon.functions.Extensions"
sxf:system-id() returns the system identifier (URI) of the current node in the source document. It take no arguments.
sxf:line-number() returns the line number of the current node in the source document. It take no arguments.
sxf:intersection(ns1, ns2) returns a node-set that contains all the nodes that are in both ns1 and ns2. It takes two node-sets as arguments.
sxf:difference(ns1, ns2) returns a node-set that contains all the nodes that are in ns1 and not in ns2. It takes two node-sets as arguments.
sxf:has-same-nodes(ns1, ns2) returns a boolean that is true if and only if ns1 and ns2 contain the same set of nodes. (This is different from the "=" operator, which tests whether there is a pair of nodes in the two sets that have the same string-value.) It takes two node-sets as arguments.
sxf:if(test, p1, p2) returns p1 if test, evaluated as a boolean, is true, and p2 otherwise. Note that p1 and p2 will both be evaluated, one of the values will be discarded. The three arguments may be of any data type.
The extension-element-prefixes and exclude-result-prefixes attributes are allowed on xsl:template as well as on xsl:stylesheet and (with the xsl prefix) on literal result elements. Their scope is the template in question.
A new saxon:handler top level extension element is introduced, this replaces the previous "handler" attribute on xsl:template. It allows a Java class (a subclass of NodeHandler) to be used to process nodes, in place of an XSLT template. The handler is invoked under the same conditions as an XSLT template, using the same match, mode, name, and priority attributes; it can be invoked either as a result of xsl:apply-templates or xsl:call-template (or even xsl:apply-imports). The capability to invoke both a Java handler and an XSLT template to process the same event is withdrawn.
The saxon:group extension element is changed so that the "group-by" expression can be any data type; the values are compared directly, rather than being first converted to strings. A group is defined as a sequence of nodes that have the same group-by key when the keys are compared using the XPath "=" operator. The main observable change is that when grouping elements on an attribute value, elements with the attribute absent are no longer grouped together, because "@att=@att" is false when the attribute is absent. To avoid this effect, force conversion to a string by writing group-by="string(@att)".
A new attribute next-in-chain is introduced on the saxon:output element. This allows the output document produced by the stylesheet to be processed by another stylesheet. The next-in-chain attribute simply gives the URL of the stylesheet that is to perform the next stage of processing. For example "<saxon:output next-in-chain="postprocess.xsl">". This attribute is mutually exclusive with the file attribute of saxon:output.
The Propagator has been merged into its parent class, the Controller. References to Propagator can generally be replaced directly with references to the Controller.
The number of different variants of the applyTemplates() method has been reduced; and the Hashtable used for passing parameters has been replaced by a new class, ParameterSet. Change any affected calls by adding null-valued parameters as required.
The setDefaultXXXHandler() methods are withdrawn. Use setHandler() with an appropriate pattern instead: for examle, setDefaultElementHandler(h) is replaced by setHandler("*", h).
The method call setOption(STRIP_SPACE, true) should be replaced by setPreserveSpace(new AnyNameTest(), false)
An extension function may now declare a first argument of class com.icl.saxon.Context; this argument is not supplied explicitly in the calling XSL, but is supplied by SAXON itself. The Context object gives access to many aspects of SAXON's internal state, for example the current node and context node, and the current outputter.
The Emitter interface has been changed, so that startElement() and endElement() now take a Name object rather than a String as their first parameter. This allows the Emitter to handle namespace information more easily. The change means that Emitter no longer extends the standard SAX DocumentHandler interface. However, SAXON will still supply the result tree to either an Emitter or a DocumentHandler, as required.
The interface to the StyleSheet class has been extended, to make it more convenient to supply source data from an application. The application can now call getSourceDocumentHandler() to get a SAX DocumentHandler, to which it can then feed the source document as a sequence of SAX events such as startElement() and endElement(). When the whole document has been supplied, the application should call renderSuppliedDocument() to apply the stylesheet to the document that has been built up. This provides an alternative to registering the preprocessing application as a SAX Parser using setStyleParser(). The setParams() method now requires the global parameters to be supplied as a ParameterSet rather than a Hashtable: note that the name of the parameter must be an interned string, and the value will typically be a StringValue (though any other type of Value will do).
Java written node handlers no longer have ready access to global variables. (It can be achieved, but requires rather detailed knowledge of the product internals). They can still access local parameters by name, using context.getBindery().getLocalParameter(). These are the parameters supplied by the caller using xsl:with-param.
There are changes to the package structure.
All the handling of path expressions and nodesets has been changed to use a pipelined approach rather than allocating temporary nodesets in memory. The pipeline only needs to be broken when a sort is required, or when the last() function is executed. This change has little impact on the execution time for typical stylesheets, but should greatly reduce the memory requirement for handling complex stylesheets or large documents, and also eases the load on the garbage collector in a continuous-running environment.
A new sort routine, which is faster and uses less memory, has been introduced.
The Bindery, which holds variable values at run-time, has been changed to identify variables by means of a Binding object (typically the stylesheet node containing the declaration) rather than by name.
| 4.7/001 | The sample servlet ShowScene makes a call on OutputDetails.setXMLDeclaration(); this method was present in version 4.6 but is replaced in 4.7 by setOmitDeclaration(). Fix: delete the offending line (line 58) of ShowScene.java and recompile. |
| 4.7/002 | An attribute node has a null SystemId (URI). This manifests itself when calling the document() function with the first argument being a nodeset containing an attribute node (e.g. "document(@href)"). Circumvention: assign the attribute value to a variable, or convert it to a string using the string() function. Fixed in 4.7.1 |
| 4.7/003 | In the document() function, relative URLs in general do not work. Circumvention: supply an absolute URL. Fixed in 4.7.1 |
| 4.7/004 | When the node set expression .//x is evaluated, the nodes are not returned in document order, but rather sorted by the document order of the parent node as major key, and the document order of the child node as minor key. This is incorrect, because it is possible for the parent of X to precede the parent of Y in document order even if X follows Y in document order. Fixed in 4.7.1 |
| 4.7/005 | When there is no xsl:output element, or no xsl:output element specifies a method attribute, and the first thing output is a text node with no containing element, SAXON defaults to output method="text". The XSLT spec says it should default to XML, and output a well-formed external general parsed entity. |
| 4.7/006 | When xsl:element or xsl:attribute is used and the name includes a namespace prefix and no namespace attribute is specified, the output namespace is incorrect. |
| 4.7/007 | It is possible using xsl:attribute to create several attributes on the same output element that use the same namespace prefix to refer to different namespace URIs. This will generate illegal XML. The fix for this bug replaces the requested prefix with a synthetic one when the situation is detected. |
| 4.7/008 | In the sample extension element sql:connect, the database connection parameters are wrong. This will affect the ability to connect to any database that checks the user name and password. |
| 4.7/009 | In XML output, characters in the range x10000 to x10FFFF (surrogate pairs) are output incorrectly as two surrogate characters: this is not legal XML. |
| 4.7/010 | With the format-number() function, the localized characters for decimal-separator, grouping-separator, etc, are used in the output string but they cannot be used in the pattern. Further, the per-mille attribute name must be written as "permill". |
| 4.7/011 | A null pointer exception occurs if the second argument to the document() function is an empty node-set. (The spec doesn't say what should happen here; the fix treats it as if the second argument were omitted.) |
| 4.7/012 | If a comment or processing instruction is generated before the start of the document element, and if there is no xsl:output method defined, the comment or processing instruction is discarded and does not appear in the result document. | 4.7/013 | When a stylesheet is prepared once and then used repeatedly to process multiple source documents, a failure occurs if it uses global variables or parameters. |
Fixes bugs 4.7/002, 4.7/003, and 4.7/004
Renamed the following functions: extension-element-available becomes element-available; extension-function-available becomes function-available; normalize becomes normalize-space.
Added the terminate="yes"|"no" attribute to xsl:message, and removed the equivalent saxon:abort extension element.
Renamed the xsl:locale element as xsl:decimal-format, and changed the defaults for the NaN and infinity attributes.
Renamed the xml-declaration attribute of xsl:output and saxon:output as omit-xml-declaration, and reversed its meaning.
Changed the XSLT namespace URI to "http://www.w3.org/1999/XSL/Transform"
The version attribute of the xsl:stylesheet element is mandatory (though forwards-compatible mode is not yet implemented)
The second argument to the document() function is no longer ignored when the first argument is a node set
With output method "html", the character '<' in an attribute value is not escaped
With output method "html", the document type declaration is not output unless either doctype-system or doctype-public (or both) are supplied in xsl:output or saxon:output.
The full axis syntax child:: and attribute:: is now allowed in patterns
The use expression in xsl:key need no longer be a nodeset
xsl:fallback is now available for XSL instructions and SAXON extension elements as well as user-defined extension elements
This version was not released, as it was completed just as the 8 October 1999 specification was released.
Added support for Namespaces. Including the use of namespaces in the source document and stylesheet; the generation of namespace declarations in the output document; the use of namespace prefixes in names occurring within XSLT expressions and patterns; and the use of the wildcard construct "prefix:*" in expressions and patterns; the namespace() function; the namespace attribute of xsl:element and xsl:attribute; the namespace prefix on extension functions; the prefix in extension-element-prefixes. But not yet the namespace axis.
If SAXON extensions are used, the namespace URI for the "saxon" namespace must be "http://icl.com/saxon"
Changed the interface for extension functions. The new mechanism is modelled on that in James Clark's xt. An extension function must have a non-null namespace; the class containing the function is identified by everything after the last "/" in the namespace URI. The method implementing the function is the first method in that class that matches the local name of the function, ignoring hyphens and case, and that has the right number of arguments. The arguments of the method, and its return type must be of appropriate types: one of boolean, double, String, com.icl.saxon.expr.NodeSetValue, or com.icl.saxon.expr.FragmentValue. There is no way currently for the extension function to obtain information about the context (e.g. the current node). The saxon:functions element is now superfluous and is withdrawn.
Implemented element extensibility, and reinstated SQL Stylesheets (which allow data from the source XML document to be inserted into a relational database) as an example of their use.
Implemented xsl:import and xsl:apply-imports
Implemented handling of "}" and "}}" within attribute value templates as specified in the XSLT recommendation (as well as correcting error 4.5/001 below).
Comment nodes are now fully supported. Note however that comment nodes are only available to SAXON if a (non-standard) SAX driver is used that notifies comments as if they were processing instructions with a null target name. The only driver I know of that does this is com.jclark.xml.sax.CommentDriver, which can be selected in the ParserManager.properties file. If any other SAX driver is used, comment nodes will be silently ignored.
Implemented the current() function
Implemented the data-type and case-order attributes of xsl:sort. (But note that the default order is still binary collating sequence, rather than being locale-sensitive).
A number may now begin or end with a decimal point
xsl:variable, xsl:param, xsl:with-param, and saxon:assign now evaluate to a zero-length string (rather than an empty result tree fragment) if there is no select attribute and no content.
The default-space attribute of xsl:stylesheet is removed. In its place, use xsl:strip-space or xsl:preserve-space with elements="*". The "prefix:*" syntax is not yet supported.
Added disable-output-escaping attribute to xsl:text and xsl:value-of
Added support for a relational comparison between a node-set and a result-tree-fragment. (The result-tree-fragment is treated as a string)
Added xsl:output element; replaced "result-ns" and "indent-result" attributes on xsl:stylesheet with new "method" and "indent" attributes on xsl:output. Most of the attributes of xsl:output are implemented, and the details of HTML outputting in particular are greatly enhanced.
Output can now be directed to a user-defined class. This can be either a standard SAX DocumentHandler, or an implementation of the com.icl.saxon.output.Emitter interface, which is an extension of the DocumentHandler interface. If an Emitter is used, more information is available to the user-defined class, for example the various options on the xsl:output element; also comments are passed through which is not possible with a standard DocumentHandler. Simply give the fully-qualified name of the Emitter or DocumentHandler class as the value of the method attribute on xsl:output or saxon:output.
The attributes on the new xsl:output element are also made available on the saxon:output element. The "format" attribute of saxon:output is renamed "method"; its values are "xml", "html", "text", "fop", or the name of a class that implements com.icl.saxon.output.Emitter
The saxon:tag element is withdrawn. Use xsl:text with disable-output-escaping="yes" instead.
The capability on saxon:output to write to an attribute of an ancestor element has been replaced by a more general saxon:set-attribute extension element. This takes a mandatory "name" attribute, defining the name of the attribute to be set; and an optional "select" attribute whose value is a string expression. The new value of the attribute is defined in the same way as for xsl:variable, either by the "select" attribute or by the contents of the saxon:set-attribute element. To convert existing stylesheets that write to an attribute of an ancestor element named A, use saxon:set-attribute within a <xsl:for-each select="ancestor::A">
References to global variables are no longer allowed within the match pattern of xsl:template or xsl:key, nor within the use expression of xsl:key. Instead, it is now possible for the definition of a global variable to use xsl:call-template, xsl:apply-templates, or the key() function.
The internal implementation of Result Tree Fragments has changed. The only observable effect of this is that a result tree fragment must be well-formed XML: it is not possible to disable output escaping, or to use saxon:entity-ref within a result tree fragment.
An extension function is provided to convert a result tree fragment to a nodeset. Calling sxf:nodeset($fragment) returns a node set containing a single document node; the outermost element has the name RESULT-TREE-FRAGMENT, and this in turn contains the actual nodes added to the result tree fragment. This document can be processed in the same way as a secondary document loaded using the document() function. This capability allows a stylesheet to create working data of arbitrary complexity which it can then use later in the processing. (The prefix sxf should map to a namespace whose URI ends with "/com.icl.saxon.functions.Extensions")
Implemented Literal Result Element As Stylesheet (section 2.3 of the XSLT specification).
Implemented an interface to James Tauber's FOP (Formatting Object Processor). FOP allows you to generate PDF output instead of HTML, using the fo: set of literal result elements. FOP must be downloaded and installed separately. It can be invoked simply by executing the SAXON stylesheet with method="fop" specified on xsl:output or saxon:output. SAXON is tested with FOP version 0_10_0.
Removed the SAXON proprietary syntax for accessing an inherited attribute.
Added preview mode. This replaces the facility in earlier SAXON releases for serial processing. Preview mode allows a template to be called while the document is being built in memory, as soon as the end tag of a specified element is encountered. The preview template sees a tree that appears structurally complete, but contains only those nodes that (a) precede the current node in document order or (b) are its descendants. Once the template has been executed, the children of the specified node (but not the node itself) are discarded to release memory. The XSL elements to define a preview element is saxon:preview
Improved diagnostic tracing facilities. The attribute saxon:trace="yes" or "no" may now be applied either at the xsl:template level or at the xsl:stylesheet level (it is treated as an inherited attribute). If the value for a template is "yes", every activation of that template results in a line of output to System.err, identifying the stylesheet template and the current node in the source document, by element type and line number. Tracing only occurs if the template is activated by matching the pattern, not if the template is called by name.
There are numerous changes to support the new XSL facilities. These are not listed individually.
Some classes have moved to a different package, e.g. Outputter is now in com.icl.saxon.output. This will affect import statements.
setOutput() is replaced by setOutputDetails(), which allows you to specify many more details of the output format required, e.g. indenting, encoding, DOCTYPE details, and so on. Note that when setOutputDetails() is called to switch to a new output file, a new Outputter is allocated, so getOutputter() must be called to obtain access to it.
In the Context class, getCurrentNode() is renamed getContextNode(), and a new method getCurrent() is introduced. getContextNode() returns the context node, while getCurrent() returns the current node. They will only be different when evaluating a sub-expression, so the difference will only be visible to applications when implementing an extension function called from a subexpression.
The API to the com.icl.saxon.StyleSheet class has changed. You can now specify different parsers for the source document and the stylesheet (useful, for example, if you want one validated and the other not, or if you want to filter the source document before it is processed by the stylesheet). You can specify full details of the output destination using setOutputDetails(), which replaces the previous setOutput(). The two main calls are prepareStyleSheet(), which does all the parsing and preprocessing of a stylesheet, and renderSource(), which applies the stylesheet to a particular source document. A stylesheet, once prepared, can be used repeatedly to render different source documents.
The element handlers ElementRedirector, ElementSorter, NumberHandler, and AttributeWriter are withdrawn. These functions can be carried out much more easily using XSL, or by using XPath expressions within your Java program. For example, the sample program ShowBooks.java shows how to use a SortedSelection expression to do sorting.
The various setDefaultXXXHandler() methods are merged: instead of setDefaultElementHandler(x), use setDefaultNodeHandler(NodeInfo.ELEMENT, x).
There are many details changes to the tree navigation interfaces caused by the introduction of namespaces. In many cases methods that took an element name as parameter now take a Pattern instead: to search for a named element, create a NamedNodePattern.
The default attribute name used in the NumberHandler element handler has changed from "saxon:nr" to "saxon.nr", to allow its use when the "saxon" namespace has not been declared.
Added line number and URL to all nodes, and now use this in reporting stylesheet errors
Updated the list of HTML elements that are output without an end tag to include all elements listed in section 15.2 of the 13 Aug 1999 XSLT specification
Added optimisation for the predicate "[1]" in filter expressions and steps: this means, for example, that "following::X[1]" will no longer find all the following nodes in the document and then test each one to see if it is the first.
Changed the command line interface to com.icl.saxon.StyleSheet: you can now specify an output file using the -o argument.
The following bugs are fixed in version 4.6, except where stated:
| 4.5/001 | In attribute value templates, the use of '{{' to represent an escaped '{' does not work. SAXON reports a syntax error. (Note that the use of '}}' to represent an escaped '}' was not supported in version 4.5 either, but this was by design.) |
| 4.5/002 | If the ParserManager.properties file cannot be found, SAXON reports an unspecific null pointer exception. |
| 4.5/003 | The built-in template for attribute nodes ignores the attribute rather than copying it to the output tree. |
| 4.5/004 | The standard element handler ElementCopier writes a newline to the output file after writing the element end tag. |
| 4.5/005 | SAXON 4.5 is not thread-safe. (I have made changes that fix known problems in this area, but I cannot guarantee that everything concerned with threads is now OK.) |
| 4.5/006 | The sample file play.xsl, mentioned in the documentation, was missing from the distribution. ** changes not yet applied ** |
| 4.5/007 | The document() function does not work when used in a select expression in a global variable or parameter declaration |
| 4.5/008 | The "ns" (namespace) attribute of saxon:functions has no effect: extension functions must be referenced without a namespace prefix |
| 4.5/009 | If a step in a path expression contains more than one filter, and one of the filters removes all elements of the nodeset, and a subsequent filter is numeric, then an ArrayIndexOutOfBoudsException occurs at com.icl.saxon.expr.Step.applyFilters(Step.java:140) |
| 4.5/010 | SAXON gives the wrong result when comparing a nodeset NS with a boolean B. The semantics assumed by SAXON are "exists X in NS where boolean(X) = B", whereas the correct semantics are "(exists X in NS) = B" |
| 4.5/011 | If there are several templates with the same name, xsl:call-templates chooses the first on rather than the last. The same applies to named attribute sets. |
| 4.5/012 | The use of xml:space="preserve" on a node prevents white space being stripped not only from the descendants of that node, but also from subsequent siblings of that node and their descendants. |
| 4.5/013 | The issued sample file books.xml is not valid. It contains an IDREF attribute (CODE="U") for which there is no corresponding ID attribute. A validating parser will therefore reject this document. Also, the sample stylesheet books.xsl attempts to process this attribute using the "default" attribute of xsl:value-of, which is no longer supported in SAXON 4.5 |
Please note that many of these changes require changes to stylesheets or applications. Sorry! This is all in the interests of improved conformance with the standards.
There has been some radical surgery of parts of the code not needed for XSL: I have removed Distributor, Wanderer, support for the DOM, and the associated node implementations. Also removed Renderer, and setItemRendition() etc from Controller.
This is all in the interests of reducing complexity: this code does things that can now be done more easily using XSL.
I hope to reintroduce serial processing in a later version, in amended form.
The following bugs are fixed in version 4.5, except where stated:
| 4.4/001 | generate-id() fails (null pointer exception) when applied to the document root. |
| 4.4/002 | Filter expressions using predicates at the outer level (not as part of a step) fail, with the error "Unexpected token "[" in expression". (Example: "$test[1]") |
| 4.4/003 | When using the XSL compiler, when a number is used in a boolean context (e.g. <xsl:if test="2">), the boolean condition is evaluated the wrong way round: zero is taken as true, and non-zero as false. |
| 4.4/004 | A class cast exception occurs when the argument to the count() function is not a node set. |
| 4.4/005 | After an xsl:pi element, all subsequent text is output without escaping special characters such as "&" and "<". |
| 4.4/006 | Conversion of a result tree fragment to a string does not discard the markup as it should. Conversion of result tree fragments to numbers or booleans is also incorrect. |
| 4.4/007 | The class org/ccil/cowan/sax/ParserFilter.class was omitted from saxon.jar (It can be downloaded separately John Cowan's web site, or created by compiling the source which is included in src.zip). (This class is not needed with SAXON 4.5) |
| 4.4/008 | The xml:space attribute on a stylesheet node has no effect. |
This is a performance release: there are very few changes in functionality. The majority of changes are purely internal. Detailed changes to methods provided primarily for internal use are not listed here.
Applications should be recompiled.
The following bugs are fixed in version 4.4:
| 4.3/001 | The XSL interpreter ignores xsl:strip-space and xsl:preserve-space elements |
| 4.3/002 | In xsl:attribute the name attribute cannot be an attribute value template |
There is no commitment to produce any future release of SAXON. However, the following changes are under consideration:
A number of incompatible changes have been introduced to reflect the latest XSL working draft. These include:
See the April 21 XSLT specification for full details. Changes include:
See the XSLT specification for further details. Changes include:
A number of incompatible changes have been made in the interests of XSL conformance.
These are largely methods that support the new XSL features.
The following bugs are fixed in version 4.3:
| 4.2/001 | XSL Compiler generates "include" statements for servlet API even when servlet="N" is specified. This causes the compilation to fail under JDK 1.1. |
A number of incompatible changes have been made in the interests of XSL conformance.
These are largely methods that support the new XSL features.
The following bugs are fixed in version 4.2:
| 4.1/001 | After executing xsl:for-each, the current source element is not reset, so a subsequent xsl:for-each (for example) will process the wrong element. |
| 4.1/002 | Where a qualifier is used of the form "[s1=s2]", a null pointer exception occurs if the second value is null. |
| 4.1/003 | If a template in a serial style sheet does not contain xsl:apply-templates, processing hangs indefinitely. |
| 4.1/004 | For an element that is the same element type as its previous sibling, the Distributor assumes that it can use the same element handler. This is not true if the match pattern depends on attribute values. |
| 4.1/005 | The DTDGenerator sample application fails (array index out of bounds) if it encounters a zero-length attribute |
I have given up trying to test each new SAXON release with every possible SAX parser and DOM implementation: there are too many, with many new releases, and on the whole the level of conformance is good. Most of the time I use either the SUN XML library, or the xp parser and Docuverse DOM. I have had problems with the latest IBM xml4j version 2, (2_0_0 and 2_0_3), I understand this is due to a parser bug and a fix is available but I haven't tried to install it. I haven't been able to download the latest ORACLE parser because of broken links on ORACLE's web site, plus excessive registration hassle.
This does mean that the IBMDOMDriver and ORACLEDOMDriver classes (now located in the com.icl.saxon.drivers package) are untested against the latest IBM and ORACLE DOM implementations.
Please let me know what parsers you are using successfully with SAXON, especially if you have to make any changes to the ParserManager.properties file or to the DOM drivers.
This is an error-correction release
Please note the following restrictions:
<xsl:template match="*" handler="com.icl.saxon.ElementCopier"/>
Michael H. Kay
2 December 1999