Abstract

XSLT's template matching mechanism lets the XSLT processor find the best match to process a selected node. XSLT also supports a more traditional way of using templates, where they are called in a way very similar for function calls in most programming languages. Another interesting area of XSLT are variables and parameters, which are used for storing or passing values within XSLT code. One special property of XSLT variables is that they cannot be changed, which is a result of the functional design of the language.

XSLT Core Concepts

• XSLT can be used for very simple matching tasks
  • a mostly static result tree can be produced
  • XPaths can be used to fill in parts of the result tree
  • Iterations and Conditional Instructions provide some flexibility for processing
• More complex transformation require a different approach
  • instead of static structures, nodes are individually mapped to small structures
  • these structure fragments together produce the result tree
  • the process is document-driven and based on the XSLT Processing Model

Processing Nodes in XSLT

• XSLT supports two ways of processing nodes
  • Iterations loop over a set of selected nodes
  • Templates process nodes which have been put on the source node list
• Both mechanisms handle similar situations
  • a set of nodes is selected and should be processed
  • the code for processing has to available in a code block
  • Iterations put this code in the for-each body
  • Templates put this code in a reusable building block

Homogeneous Processing

• Iterations may lead to less modular code
• If the code has to be reused, they may not be a good solution
  • Named Templates may provide some support for reuse
• The selected nodes should require similar processing
  • otherwise, the iteration code will contain many conditional statements
• Iterations should be restricted to small units of code

Heterogeneous Processing

• If the node processing is very different, templates are better
  • different templates are written for all nodes being selected
  • no conditional code has to be written, selection is done by matching nodes to template patterns
• Templates can be reused
  • the nodes appear in different locations and should be processed consistently
  • the matching mechanism provides the ideal support for this scenario
• Extensible code should always use templates
  • other stylesheets can import an existing stylesheet
  • by selectively overwriting templates, the behavior can be customized

Executing Templates

• Templates usually have a match attribute
  • these templates are part of XSLT's special pattern matching processing
• Templates may also be named units of code
  • there is nothing special about these templates
  • they are being called using a name like regular procedures

Named Templates

• template may also carry a name attribute
• call-template calls these template by their name
• Named templates have none of the special properties of XSLT template matching
  • they are called by their name just like regular procedures
  • they do not change the context of XPath evaluation
• Named templates are useful for modularizing code which is not tied to node types
  • in most cases, they are called using Parameters
  • a typical application is the implementation of a facility for printing messages

Programming Language Basics

• Variables in programming languages have different purposes
  1. defining a name for something so that it can be referred to
  2. associating this name with a value so that the value can be used
  3. providing a way to update the variable so that its value changes
• Variables in functional languages cannot change
  • they are immutable (often called constants in other languages)
  • more specifically, they are dynamic constants (i.e., can be computed at runtime)
  • they are defined by giving them a name and referred to by $name
• Variables in XSLT have no type (no static type checking possible)
  • the value that they have is typed
  • but a variable may have values of any type

<xsl:variable name="sum" select="$op1 + $op2"/>
<xsl:variable name="result" select="$sum * $factor"

Why Variables?

• Reuse of values in different locations
  • texts required for the transformation
  • facilitates better separation of structure and content

  <xsl:value-of select="$email-prefix"/> <!-- $email-prefix = 'You have ' -->
  <xsl:value-of select="count(//message)"/>
  <xsl:value-of select="$email-suffix"/> <!-- $email-suffix = ' e-mail messages.' -->

• Using the correct context is essential
  • variables cannot be updated
  • if they need to be updated, they have to be re-created
• Why are they called variables if they are constants?
  • their value varies in different invocations of the context
  • they are computed at runtime (dynamic constants) rather than statically

Scope and Extent

• Variables can be global or local
  • global variables are visible in all templates
  • local variables are visible in their context (i.e., at following-sibling::*/descendant-or-self::*)
  • local variables are allowed to shadow global (not local) variables
• Variable values may be assigned using the select attribute
  • The XPath's result is the value of the variable
• Variables can contain arbitrary XPath code
  • the code is executed in the same way as when constructing the result tree
  • the result tree fragment is the value of the variable
  • it can be used as a string (value-of) or as a tree (copy-of)

Using Variables

 <xsl:variable name="name" select="'value'"/>
 <xsl:template match="/">
  <xsl:choose>
   <xsl:when test="$name = 'value'">
    <xsl:variable name="result" select="'ok'"/>
   </xsl:when>
   <xsl:otherwise>
    <xsl:variable name="result" select="'problem'"/>
   </xsl:otherwise>
  </xsl:choose>
  <xsl:value-of select="$result"/>
 </xsl:template>

 <xsl:variable name="name" select="'value'"/>
 <xsl:template match="/">
  <xsl:variable name="result">
   <xsl:choose>
    <xsl:when test="$name = 'value'">
     <xsl:value-of select="'ok'"/>
    </xsl:when>
    <xsl:otherwise>
     <xsl:value-of select="'problem'"/>
    </xsl:otherwise>
   </xsl:choose>
  </xsl:variable>
  <xsl:value-of select="$result"/>
 </xsl:template>

Parameters vs. Variables

• Parameters are variables with additional semantics
  • they are passed to their scope from the outside
  • they are available within the scope like a variable (scopes are stylesheets and templates)
  • like variables, they cannot be updated (and only global parameters can be shadowed)
• XSLT does not check proper parameter passing
  • if a declared parameter is not passed, it gets a default value (specified or '')
  • if a passed parameter is not declared, it is ignored
  • like variables, parameters have no type (any value can be passed)
  • XSLT's robustness makes it hard to spot programming errors

Stylesheet Parameters

• Passed to the stylesheet when calling the stylesheet
  • the exact way of specifying the parameters depend on the processor and the environment
  • the passed values are available in the same way as global variables
  • parameter checking has to be done by hand

 <xsl:param name="number" select="0"/>
 <xsl:variable name="number-param">
  <xsl:if test="string(number($number)) = 'NaN'">
   <xsl:message terminate="yes">"number" must be a proper number!</xsl:message>
  </xsl:if>
  <xsl:value-of select="$number"/>
 </xsl:variable>
 <xsl:template match="/">
  <xsl:value-of select="10 * $number-param"/>
 </xsl:template>

Template Parameters

• Parameters can be passed to templates
  • works with apply-templates and call-template
  • with-param elements list the passed parameters
  • parameter matching is done by name (there is no particular order to parameters)
• Templates can be programmed as parametrized components
  • checking the signature has to be done by hand
  • with-param elements list the passed parameters
  • parameter matching is done by name (there is no particular order to parameters)
• Parametrized template calls need a lot of markup
  • XSLT's XML syntax makes the code hard to read

main param start = 1 ; param count = 10 ; {
	loop (0) };
loop param counter ; {
	print $start + $counter ;
	if ( $counter < $count - 1) then 
		loop ($counter + 1) ; }

Parameter Passing

 <xsl:param name="start" select="1"/>
 <xsl:param name="count" select="10"/>
 <xsl:template match="/">
  <xsl:call-template name="loop">
   <xsl:with-param name="counter" select="0"/>
  </xsl:call-template>
 </xsl:template>
 <xsl:template name="loop">
  <xsl:param name="counter"/>
  <xsl:message>
   <xsl:value-of select="$start + $counter"/>
  </xsl:message>
  <xsl:if test="$counter &lt; $count - 1">
   <xsl:call-template name="loop">
    <xsl:with-param name="counter" select="$counter + 1"/>
   </xsl:call-template>
  </xsl:if>
 </xsl:template>

Message Facility

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:param name="message" select="'plain'"/>
    <!-- messaging style: 'silent', 'plain', or 'prefixed' -->
    <xsl:template name="message">
        <xsl:param name="level" select="'fatal'"/>
        <!-- message level: 'warning', 'error', or 'fatal' -->
        <xsl:param name="text" select="'no text given'"/>
        <xsl:choose>
            <xsl:when test="$message = 'silent'"/>
            <xsl:when test="$level = 'warning'">
                <xsl:call-template name="print_message">
                    <xsl:with-param name="level" select="'warning'"/>
                    <xsl:with-param name="terminate" select="'no'"/>
                    <xsl:with-param name="text" select="$text"/>
                </xsl:call-template>
            </xsl:when>
            <xsl:when test="$level = 'error'">
                <xsl:call-template name="print_message">
                    <xsl:with-param name="level" select="'error'"/>
                    <xsl:with-param name="terminate" select="'no'"/>
                    <xsl:with-param name="text" select="$text"/>
                </xsl:call-template>
            </xsl:when>
            <xsl:when test="$level = 'fatal'">
                <xsl:call-template name="print_message">
                    <xsl:with-param name="level" select="'fatal'"/>
                    <xsl:with-param name="terminate" select="'yes'"/>
                    <xsl:with-param name="text" select="$text"/>
                </xsl:call-template>
            </xsl:when>
            <xsl:otherwise>
                <xsl:call-template name="print_message">
                    <xsl:with-param name="level" select="'fatal'"/>
                    <xsl:with-param name="terminate" select="'no'"/>
                    <xsl:with-param name="text" select="concat('fatal:unknown level for message [', $text, ']')"/>
                </xsl:call-template>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>
    <xsl:template name="print_message">
        <!-- this template should never be called from outside; for printing messages, call the "message" template. -->
        <xsl:param name="level"/>
        <xsl:param name="terminate"/>
        <xsl:param name="text"/>
        <xsl:choose>
            <xsl:when test="$message = 'plain'">
                <xsl:message terminate="{$terminate}">
                    <xsl:value-of select="$text"/>
                </xsl:message>
            </xsl:when>
            <xsl:otherwise>
                <xsl:message terminate="{$terminate}">
                    <xsl:value-of select="concat($level, ':', $text)"/>
                </xsl:message>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>
</xsl:stylesheet>

XSLT Programming Environment

• Learning to use the right patterns takes some time
• Templates can be applied and called
• XSLT variables have some unusual properties
• Parameters can be used for stylesheets and templates