XSL Transformations (XSLT) Version 4.0

5.2 Expressions

XSLT uses the expression language defined by XPath 4.0 [XPath 4.0]. Expressions are used in XSLT for a variety of purposes including:

• selecting nodes for processing;

• specifying conditions for different ways of processing a node;

• generating text to be inserted in a result tree.

[Definition: Within this specification, the term XPath expression, or simply expression, means a string that matches the production Expr^XP defined in [XPath 4.0].]

XPath expressions may occur:

• As the value of certain attributes on XSLT-defined instructions (for example, the select attribute of the xsl:apply-templates instruction)

• Within curly brackets in attribute value templates and text value templates.

• As the content of a text node within an xsl:select instruction.

In the above cases, the static processing (compilation) of XPath expressions takes place at the same time as the static processing of the stylesheet itself, while evaluation of the XPath expressions takes place dynamically during stylesheet evaluation. There are also, however:

• XPath expressions where both the static processing and dynamic evaluation of the XPath expression takes place during static processing of the stylesheet. These are referred to as static expressions, and they perform the same function as preprocessing directives in other languages.

• XPath expressions that are dynamically constructed (as character strings): both the static processing and dynamic evaluation of these expressions occurs during stylesheet evaluation. See ???.

In general:

• It is a static error if an XPath expression does not match the XPath production Expr^XP, or if it fails to satisfy other static constraints defined in the XPath specification, for example that all variable references must refer to variables that are in scope. Error codes are defined in [XPath 4.0].

• The transformation fails with a dynamic error if any XPath expression is evaluated and raises a dynamic error. Error codes are defined in [XPath 4.0].

• The transformation fails with a type error if an XPath expression raises a type error, or if the result of evaluating the XPath expression is evaluated and raises a type error, or if the XPath processor raises a type error during static analysis of an expression. Error codes are defined in [XPath 3.0].

There are some exceptions to these rules, for example:

• Static errors may be suppressed where forwards compatible behavior is enabled (see 3.10 Forwards Compatible Processing).

• Dynamic errors may be caught using xsl:try and xsl:catch.

• Dynamic errors evaluating a predicate within a pattern do not cause the transformation to fail, they merely cause the pattern not to match.

[Definition: The context within a stylesheet where an XPath expression appears may specify the required type of the expression. The required type indicates the type of the value that the expression is expected to return.] If no required type is specified, the expression may return any value: in effect, the required type is then item()*.

[Definition:  The term coercion rules means the coercion rules defined in [XPath 4.0], applied unless otherwise specified with XPath 1.0 compatibility mode set to false.]

This specification also invokes the XPath coercion rules to convert the result of evaluating an XSLT sequence constructor to a required type (for example, the sequence constructor enclosed in an xsl:variable, xsl:template, or xsl:function element).

Any dynamic error or type error that occurs when applying the coercion rules to convert a value to a required type results in the transformation failing, in the same way as if the error had occurred while evaluating an expression.

The XPath specification states (see Section A.3.4 End-of-Line Handling^XP) that the host language must specify whether the XPath processor normalizes all line breaks on input, before parsing, and if it does so, whether it uses the rules of [XML 1.0] or [XML 1.1]. In the case of XSLT, all handling of line breaks is the responsibility of the XML parser (which may support either XML 1.0 or XML 1.1); the XSLT and XPath processors perform no further changes.

10.4 Static XPath Evaluation

The two instructions described in this section, xsl:sequence and xsl:select, can be used to evaluate XPath expressions that are statically known: that is, the XPath expressions are statically processed during the static processing of the stylesheet, and are dynamically evaluated during the dynamic evaluation of the stylesheet. The xsl:sequence instruction can also be used to evaluate a sequence constructor.

<xsl:select as="map(*)">
   {  "title"  : $title,
      "author" : $author
   }
</xsl:select>

<xsl:function name="f:book-to-json" as="map(*)">
   <xsl:param name="book" select="element(book)">            
   <xsl:select>
      {  "title"  : string($book/title),
         "isbn"   : string($book/isbn),
         "price"  : number($book/@price),
         "author" : array { $book/author ! string() },
         "date"   : current-date()"
      }
   </xsl:select>
</xsl:function><xsl:function name="f:book-to-json" as="map(*)">
   <xsl:param name="book" as="element(book)">            
   <xsl:select>
      {  "title"  : string($book/title),
         "isbn"   : string($book/isbn),
         "price"  : number($book/@price),
         "author" : array { $book/author ! string() },
         "date"   : current-date()"
      }
   </xsl:select>
</xsl:function><xsl:function name="f:book-to-json" as="map(*)">
   <xsl:param name="book" selectas="elementelement(book)(book)">            
   <xsl:select>
      {  "title"  : string($book/title),
         "isbn"   : string($book/isbn),
         "price"  : number($book/@price),
         "author" : array { $book/author ! string() },
         "date"   : current-date()"
      }
   </xsl:select>
</xsl:function>