Ce document est une traduction de la recommandation XSL Transformations (XSLT) 1.0 du W3C, datée du 16 novembre 1999. Cette version traduite peut contenir des erreurs absentes de l'original, dues à la traduction elle-même. La version originale en anglais, seule normative, se trouve à l'adresse http://www.w3.org/TR/1999/REC-xslt-19991116.

Traduction :

Ramzi Guetari
Jean-Jacques Thomasson
Yves Bazin

Traduction hébergée par XMLfr.

Copyright © 1998 W3C (MIT, INRIA, Keio), tous droits réservés. Les règles du W3C sur la responsabilité, les marques de commerce, les droits d'auteur et les licences de logiciels sont applicables.

Note de traduction: L'entité ISO LATIN I de "oe" ligaturé n'étant pas supportée par certains navigateurs, il sera écrit oe.



 

W3C

Transformations XSL (XSLT)
Version 1.0

Recommandation W3C 16 Novembre 1999

Cette version a été traduite à partir de la version:
http://www.w3.org/TR/1999/REC-xslt-19991116
(existe en XML ou HTML)
Dernière version:
http://www.w3.org/TR/xslt
Versions précédentes:
http://www.w3.org/TR/1999/PR-xslt-19991008
http://www.w3.org/1999/08/WD-xslt-19990813
http://www.w3.org/1999/07/WD-xslt-19990709
http://www.w3.org/TR/1999/WD-xslt-19990421
http://www.w3.org/TR/1998/WD-xsl-19981216
http://www.w3.org/TR/1998/WD-xsl-19980818
Éditeur du document original:
James Clark <jjc@jclark.com>



Sommaire

Cette spécification définit la syntaxe et la sémantique de XSLT, qui est un langage permettant de transformer des documents XML en d'autres documents XML.

XSLT est conçu pour être utilisé comme une partie de XSL, le langage des feuilles de style de XML. En plus de XSLT, XSL inclus un vocabulaire XML pour la spécification de formatage. XSL spécifie les règles de présentation d'un document XML en utilisant XSLT pour décrire comment le document peut être transformé en un autre document qui utilise le vocabulaire de formatage.

XSLT est aussi conçu pour être utilisé indépendamment de XSL. Cependant, XSLT n'est pas censé être utilisé comme un langage de transformation XML à vocation générale. Il a surtout été conçu pour les types de transformations nécessaires lorsque XSLT est utilisé comme une partie de XSL.

État de ce document

La version originale de ce document a été examinée par les Membres du W3C ainsi que d'autres parties concernées, elle a été approuvée par le directeur comme étant une Recommandation du W3C. C'est un document stable pouvant être utilisé comme document de référence ou cité comme une référence normative par d'autres documents. Le rôle du W3C en mettant à disposition cette Recommandation est de promouvoir son déploiement le plus large possible. Ceci dans le but d'améliorer et d'accroître la fonctionnalité et l'interopérabilité du Web.

La liste des erreurs répertoriées dans cette spécification est disponible à: http://www.w3.org/1999/11/REC-xslt-19991116-errata.

Les commentaires sur cette spécification peuvent être adressés à xsl-editors@w3.org; les archives des commentaires sont disponibles. Les discussions publiques sur XSL, y compris les Transformations XSL, se tiennent sur la mailing liste XSL-List.

La version anglaise de cette spécification est la seule version normative (http://www.w3.org/TR/1999/REC-xslt-19991116). Cependant, pour les traductions de ce document, consulter http://www.w3.org/Style/XSL/translations.html.

Une liste des Recommandations courantes du W3C ainsi que d'autres documents techniques peut être trouvée à: http://www.w3.org/TR.

Cette spécification a été produite comme une partie de l'activité Style du W3C.

Table des matières

1 Introduction
2 Structure des feuilles de style
    2.1 Espace de noms XSLT
    2.2 Éléments de feuilles de styles
    2.3 Feuille de style sous forme d'élément littéral résultat
    2.4 Noms qualifiés
    2.5 Traitement de la compatibilité ascendante
    2.6 Combinaison de feuilles de style
        2.6.1 Inclusion de feuilles de style
        2.6.2 Import de feuilles de style
    2.7 Feuilles de style encapsulées
3 Modèle de données
    3.1 Les fils du noeud racine
    3.2 URI base
    3.3 Entités non valides
    3.4 Suppression de caractères espace
4 Expressions
5 Règles modèle
    5.1 Modèle de traitement
    5.2 Modèles
    5.3 Définition de règles modèle
    5.4 Application des règles modèle
    5.5 Résolution de conflits des règles modèle
    5.6 Outrepasser des règles modèles
    5.7 Modes
    5.8 Règles modèle encastrées
6 Modèles nommés
7 Créer l'arbre résultat
    7.1 Créer des éléments et des attributs
        7.1.1 Éléments résultats littéraux
        7.1.2 Créer des éléments avec xsl:element
        7.1.3 Créer des attributs avec xsl:attribute
        7.1.4 Ensembles d'attributs nommés
    7.2 Créer de texte
    7.3 Créer des instructions de traitement
    7.4 Créer des commentaires
    7.5 Copier
    7.6 Calculer le texte généré
        7.6.1 Générer du texte avec xsl:value-of
        7.6.2 Les modèles de valeurs d'attributs
    7.7 Calculer
        7.7.1 Attributs de conversion de nombres en chaînes de caractères
8 Répétition
9 Traitement conditionnel
    9.1 Traitement conditionnel par xsl:if
    9.2 Traitement conditionnel par xsl:choose
10 tri
11 Variables et Paramètres
    11.1 Fragments d'arbre résultat
    11.2 Valeurs des Variables et des Paramètres
    11.3 Utilisation des valeurs des Variables et des Paramètres avec xsl:copy-of
    11.4 Variables et paramètres de haut niveau
    11.5 Les Variables et les Paramètres dans les modèles
    11.6 Passage de paramètres aux modèles
12 Fonctions additionnelles
    12.1 Documents avec sources multiples
    12.2 Clés
    12.3 Formatage de nombres
    12.4 Fonctions additionnelles diverses
13 Messages
14 Extensions
    14.1 Eléments extension
    14.2 Fonctions extension
15 Reprise
16 Sorties
    16.1 La méthode de sortie XML
   16.2 La méthode de sortie HTML
    16.3 La méthode de sortie texte
    16.4 Désactivation de la production littérale des caractères en sortie
17 Conformité
18 Notation

Annexes

A Références
    A.1 Références normatives
    A.2 Autres références
B Récapitulatif de la syntaxe des éléments
C Fragment de la DTD des feuilles de style XSLT (non normatif)
D Exemples (non normatifs)
    D.1 Exemple de document
    D.2 Exemple avec des données
E Avertissements (non normatif)
F Changement depuis la recommandation proposée (non normatif)
G Fonctionnalités à l'étude pour une future version de XSLT (non normatif)


1 Introduction

Cette spécification définit la syntaxe et la sémantique du langage XSLT. Une transformation dans XSLT est exprimée comme un document XML bien formé [XML] conformément aux espaces de noms définis dans la recommandation XML [Noms XML], pouvant aussi bien contenir des éléments définis par XSLT que d'autres éléments non définis par XSLT. Les éléments définis par XSLT se distinguent par leur appartenance à un espace de nom XML spécifique (voir [2.1 Espace de noms XSLT]), qui est référencé dans cette spécification par Espace de noms. Ainsi cette spécification est une définition de la syntaxe et de la sémantique de l'Espace de noms XSLT.

Une transformation exprimée en XSLT décrit les règles pour transformer un arbre source en un arbre résultat. La transformation est obtenue en associant des motifs à des modèles. Les motifs sont appliqués aux éléments de l'arbre source. Le modèle est instancié pour créer une partie de l'arbre résultat. L'arbre résultat est distinct de l'arbre source. La structure de l'arbre résultat peut être complètement différente de la structure de l'arbre source. Pendant la construction de l'arbre résultat, des éléments de l'arbre source peuvent être filtrés et réordonnés, et des structures arbitraires peuvent être ajoutées.

Une transformation exprimée en XSLT est appelée feuille de styles. Ceci parce que quand XSLT est transformé dans le vocabulaire de formatage XSL, la transformation fonctionne comme une feuille de styles.

Ce document ne spécifie pas comment une feuille de styles XSLT est associée à un document XML. Il est recommandé que les processeurs XSL supportent le mécanisme décrit dans [Feuilles de style XML]. Lorsque ce mécanisme ou n'importe quel autre mécanisme rencontre une séquence de plus d'une seule feuille de styles XSLT qu'il faut appliquer simultanément à un document XML, alors le résultat doit être le même que si l'on appliquait une seule feuille de styles qui importerait chaque membre de la séquence dans l'ordre (voir [2.6.2 Import des feuilles de style]).

Une feuille de styles contient un ensemble de règles modèles. Une règle modèle est constituée de deux parties : un motif qui sert à identifier des noeuds de l'arbre source et un modèle pouvant être instancié afin de constituer une partie de l'arbre résultat. Ceci permet à une feuille de styles d'être applicable à une large catégorie de documents ayant des structures d'arbres source similaires.

Un modèle est instancié pour un élément source particulier afin de créer une partie de l'arbre résultat. Un modèle peut contenir des éléments permettant de spécifier littéralement les éléments de la structure résultante. Un modèle peut aussi contenir des éléments de l'espace de noms XSLT représentant des instructions pour la création de fragments de l'arbre résultat. Lorsqu'un modèle est instancié, chaque instruction est exécutée et remplacée par le fragment d'arbre résultat qu'elle aura crée. Les instructions peuvent sélectionner et traiter les descendants des éléments source. La création d'un fragment de l'arbre résultat par le traitement des éléments descendants se fait en trouvant la règle modèle applicable et en instanciant son modèle. Il faut noter que les éléments ne sont traités que lorsqu'ils sont sélectionnés par l'exécution d'une instruction. L'arbre résultat est construit en prenant la règle modèle du noeud racine et en instanciant son modèle.

Lors de la recherche d'une règle modèle applicable, plusieurs autre règles modèle peuvent avoir un motif correspondant à un élément donné. Cependant, une seule et unique règle modèle sera appliquée. La méthode permettant de déterminer quelle est la règle modèle à appliquer est décrite dans [5.5 Résolution de conflits des règles modèle].

Un modèle possède à lui tout seul une puissance considérable : il peut créer des structures de n'importe quel niveau de complexité; il peut accéder et récupérer les valeurs de chaînes de caractères situées à n'importe quel endroit de l'arbre source; il peut générer des structures répétées au fur et à mesure que les occurrences d'éléments sont rencontrées dans l'arbre source. Pour les transformations simples où la structure de l'arbre résultat est indépendante de la structure de l'arbre source, une feuille de styles peut souvent être réduite à un seul modèle, valable pour la génération de la totalité de l'arbre résultat. Les transformations appliquées à des documents XML représentant des données sont souvent de ce type (voir [D.2 Exemple de données]). XSLT offre la possibilité d'utiliser une syntaxe simplifiée pour ce type de feuilles de style (voir [2.3 Feuille de style sous forme d'élément littéral résultat]).

L'instanciation d'un modèle se fait toujours par rapport à un noeud courant et une liste de noeuds courante. Le noeud courant est toujours membre de la liste de noeuds courante. Plusieurs opérations dans XSLT sont relatives au noeud courant. Seules quelques instructions permettent de changer la liste de noeuds courante ou le noeud courant (voir [5 Règles modèle] et [8 Répétition]); Durant l'instanciation de l'une de ces instructions, la liste de noeuds courante est modifiée et forme une nouvelle liste de noeuds courante dont les éléments deviennent, chacun à leur tour, le noeud courant. A la fin de ce processus, le noeud courant et la liste de noeuds courante redeviennent ce qu'ils étaient avant instanciation de l'instruction.

XSLT utilise le langage d'expression défini par [XPath] pour sélectionner les éléments à traiter, les traitements conditionnels et la génération de texte.

XSLT fournit deux ouvertures pour étendre le langage, l'une pour étendre le jeu d'instructions d'utilisables dans les modèles et une autre pour étendre l'ensemble des fonctions utilisables dans les expressions XPath. Ces ouvertures reposent toutes les deux sur l'utilisation des espaces des noms XML. Cette version de XSLT ne définit pas le mécanisme d'implémentation de ces ouvertures. Voir [14 Extensions].

NOTE : Le groupe de travail XSL prévoit de définir ce mécanisme soit dans une future version de cette spécification soit dans une spécification séparée.

La signification des règles d'écriture des éléments spécifiques à la syntaxe XSLT est fournie au chapitre [18 Notation].

Les types MIME text/xml et application/xml [RFC2376] devraient être utilisés pour les feuilles de style XSLT. Il est possible qu'un type de média soit spécifiquement associé à une feuille de style XSLT ; dans ce cas, ce type de média est également autorisé.

2 Structure des feuilles de style

2.1 Espace de noms XSLT

L'URI de l'espace de noms XSLT est : http://www.w3.org/1999/XSL/Transform.

NOTE : La valeur 1999 se trouvant dans l'URI indique l'année d'attribution de l'URI par le W3C. Cela n'indique pas la version de XSLT utilisée; cette dernière étant spécifiée par des attributs (voir [2.2 L'élément de feuille de styles] et [2.3 Feuille de style sous la forme d'élément littéral résultat]).

Les processeurs XSLT doivent utiliser le mécanisme des espaces de noms [Noms XML] pour reconnaître les éléments et les attributs de cet espace de noms. Les éléments de l'espace de noms XSLT sont reconnus uniquement dans la feuille de styles et non dans le document source. La liste complète des éléments XSLT prédéfinis est spécifiée dans [B Récapitulatif des éléments de syntaxe]. Les constructeurs informatique ne doivent pas étendre l'espace de noms XSLT avec des éléments ou des attributs nouveaux. Toute extension doit se présenter sous la forme d'un nouvel espace de noms séparé. Chaque espace de noms utilisé pour des instructions additionnelles doit être identifié au moyen du mécanisme d'extension d'élément spécifié dans [14.1 Éléments extension].

Cette spécification utilise le préfixe xsl: pour référencer les éléments de l'espace de noms XSLT. Cependant, les feuilles de style XSLT sont libres d'utiliser n'importe quel préfixe, à condition qu'il y ait une déclaration d'espace de noms liant le préfixe à l'URI de l'espace de noms XSLT.

Un élément appartenant à l'espace de noms XSLT peut avoir n'importe quel attribut n'appartenant pas à l'espace de noms XSLT, à condition que le nom étendu de l'attribut ne soit pas une URI d'espace de noms nulle. La présence de tels attributs ne doit pas modifier le comportement des éléments XSLT et des fonctions définies dans ce document. Ainsi, un processeur XSLT est toujours libre d'ignorer de pareils attributs, et, ce faisant, n'a pas à signaler d'erreur quand il ne reconnaît pas l'URI de l'espace des noms. De tels attributs peuvent fournir, par exemple, des identificateurs uniques, des indications d'optimisation ou de la documentation.

Une erreur doit être produite quand des éléments de l'espace de noms XSLT ont des attributs dont les noms étendus ont des URI nulles (par exemple : des attributs sans noms préfixés), exception faite des noms d'attributs définis dans la présente spécification.

NOTE : Les conventions utilisées pour les noms des éléments XSLT, les attributs et les fonctions font que tous les noms tous écrits en lettres minuscules, utilisent le trait d'union pour séparer les mots et n'utilisent les abréviations que si elles existent déjà dans la syntaxe du langage en question, comme par exemple XML ou HTML.

2.2 L'élément feuille de styles

<xsl:stylesheet id = id
  extension-element-prefixes = tokens
  exclude-result-prefixes = tokens
  version = number>
  <!-- Contenu : (xsl:import*, top-level-elements)-->
</xsl:stylesheet>

<xsl:transform
  id = id
  extension-element-prefixes = tokens
  exclude-result-prefixes = tokens
  version = number>
  <!-- Contenu : (xsl:import*, top-level-elements)-->
</xsl:transform>

Une feuille de styles est représentée par l'élément xsl:stylesheet dans un document XML. xsl:transform est autorisé comme synonyme de xsl:stylesheet.

L'élément xsl:stylesheet doit avoir un attribut version indiquant la version de XSLT exigées par la feuille de styles. Pour cette version de XSLT, la valeur doit être 1.0. Lorsque la valeur n'est pas égale à 1.0, le traitement en compatibilité ascendante est activé (voir [2.5 Traitement de la compatibilité ascendante]).

L'élément xsl:stylesheet peut contenir les types d'éléments suivants:

xsl:import
xsl:include
xsl:strip-space
xsl:preserve-space
xsl:output
xsl:key
xsl:decimal-format
xsl:namespace-alias
xsl:attribute-set
xsl:variable
xsl:param
xsl:template

Un élément fils de l'élément xsl:stylesheet est appelé élément de haut niveau.

L'exemple suivant montre la structure d'une feuille de styles. Les points de suspension (...) indiquent où les valeurs et les contenus d'attributs ont été omis. Bien que cet exemple montre un cas d'utilisation de chacun des éléments autorisés, les feuilles de style peuvent en contenir de zéro à plusieurs occurrences.

<xsl:stylesheet version="1.0"
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:import href="..."/>
<xsl:include href="..."/>
<xsl:strip-space elements="..."/>
<xsl:preserve-space elements="..."/>
<xsl:output method="..."/>
<xsl:key name="..." match="..." use="..."/>
<xsl:decimal-format name="..."/>
<xsl:namespace-alias stylesheet-prefix="..." result-prefix="..."/>
<xsl:attribute-set name="...">
    ...
</xsl:attribute-set>
<xsl:variable name="...">...</xsl:variable>
<xsl:param name="...">...</xsl:param>
<xsl:template match="...">
    ...
</xsl:template>
<xsl:template name="...">
    ...
</xsl:template>
</xsl:stylesheet>

L'ordre avec lequel les fils de l'élément xsl:stylesheet apparaissent n'est significatif que pour les éléments xsl:import et les récupérations d'erreurs. Les utilisateurs ont la liberté d'ordonner les éléments selon leurs préférences et les outils de création de feuilles de styles n'ont pas besoins de contrôler l'ordre dans lequel apparaissent les éléments.

De plus, l'élément xsl:stylesheet peut contenir n'importe quel élément n'appartenant pas à l'espace de noms XSLT, à la condition que l'URI de l'espace de noms du nom étendu de l'élément soit non nulle. La présence de tels éléments de haut niveau ne doit changer le comportement ni des éléments ni des fonctions XSLT définis dans ce document; ainsi, il ne doit pas être permis de permettre la modification des règles d'un élément de haut niveau comme xsl:apply-templates pour résoudre, par exemple, des conflits. Ainsi, un processeur XSLT est toujours libre d'ignorer ces éléments de haut niveau, et il doit ignorer un élément de haut niveau sans générer d'erreur s'il ne reconnaît pas l'URI de l'espace de noms. De tels éléments peuvent, par exemple, fournir :

les informations utilisées par les extensions d'éléments ou l'extension de fonctions (voir [14 Extensions]),

les informations concernant l'utilisation de l'arbre résultat,

les informations concernant l'obtention de l'arbre source,

les meta-données de la feuille de styles,

une documentation structurée de la feuille de styles.

2.3 Feuille de style sous la forme d'un élément littéral résultat

Une syntaxe simplifiée existe pour les feuilles de style et consiste en un simple et unique modèle appliqué au noeud racine. La feuille de styles peut consister en un simple élément littéral résultat (voir [7.1.1 Les éléments littéraux résultats]). Une telle feuille de styles est équivalente à une feuille de styles qui utiliserait un élément xsl:stylesheet contenant une règle modèle qui contiendrait, elle-même, un élément littéral résultat; la règle modèle ayant comme motif de recherche le caractère /. Par exemple :

<html xsl:version="1.0"
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  xmlns="http://www.w3.org/TR/xhtml1/strict">
   <head>
  <title>Expense Report Summary</title>
   </head>
   <body>
      <p>Total Amount: <xsl:value-of select="expense-report/total"/></p>
    </body>
 </html>

signifie la même chose que:

<xsl:stylesheet version="1.0"
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                xmlns="http://www.w3.org/TR/xhtml1/strict">
<xsl:template match="/">
<html>
  <head>
    <title>Expense Report Summary</title>
  </head>
  <body>
    <p>Total Amount: <xsl:value-of select="expense-report/total"/></p>
  </body>
</html>
</xsl:template>
</xsl:stylesheet>

Quand l'élément littéral résultat est l'élément document de la feuille de styles, il doit avoir l'attribut xsl:version indiquant la version de XSLT requise par la feuille de styles. Pour la version de XSLT décrite dans ce document, la valeur doit être 1.0; La valeur doit être un Nombre. D'autres éléments littéraux résultats peuvent également recevoir l'attribut xsl:version. Lorsque l'attribut xsl:version n'est pas égal à 1.0, le traitement de compatibilité ascendante est activé (voir [2.5 Traitement de la compatibilité ascendante]).

Le contenu d'un élément littéral résultat utilisé comme feuille de styles n'est pas différent de celui autorisé lorsque ce même élément est utilisé à l'intérieur d'une feuille de styles. En conséquence, un élément littéral résultat, même utilisé comme feuille de styles, ne peut contenir d'éléments de haut niveau.

Dans certains cas, la seule manière pour qu'un système puisse déterminer qu'un document XML doit être traité par un processeur XSLT comme feuille de styles est l'examen du document XML lui-même. L'utilisation de la syntaxe simplifiée rend la tâche beaucoup plus difficile.

NOTE : Par exemple, un autre langage XML (AXL) pourrait aussi utiliser un axl:version pour l'élément document pour indiquer qu'il s'agit d'un document XML devant être traité par un processeur AXL; Si le document a en même temps les attributs axl:version et xsl:version, un problème se pose pour savoir si le document doit être traité par un processeur XSLT ou par un processeur AXL.

Par conséquent, la syntaxe simplifiée ne devrait pas être utilisée pour les feuilles de style XSLT pouvant être utilisées dans pareils cas. Cette situation peut se produire, par exemple, lorsqu'une feuille de styles XSLT est transmise par messagerie avec un type MIME associé tel que text/xml ou application/xml à un receveur qui utilisera le type MIME pour déterminer comment traiter le message.

2.4 Noms qualifiés

Le nom d'un objet XSLT interne, en particulier les modèles nommés (voir [6 Modèles nommés]), un mode (voir [5.7 Modes]), un ensemble d'attributs (voir [7.1.4 Ensembles d'attributs nommés]), une clef (voir [12.2 Clés]), un format décimal (voir [12.3 Formatage de nombres]), une variable ou un paramètre (voir [11 Variables et Paramètres]) est spécifié comme étant un nom qualifié (QName). S'il dispose d'un préfixe, alors celui-là est développé en une référence d'URI en lui appliquant les déclarations d'espaces de noms applicables aux attributs dans lesquels le nom apparaît. Le nom étendu, comprenant la partie locale du nom et la possible référence vide à l'URI, est utilisé comme nom de l'objet. L'espace de noms par défaut n'est pas utilisé pour les noms sans préfixes.

2.5 Traitement de la compatibilité ascendante

Un élément active le traitement par compatibilité ascendante pour lui-même, ses attributs, ses descendants et leurs attributs dans le cas où c'est un élément xsl:stylesheet dont l'attribut version est différent de 1.0, ou c'est un élément littéral résultat ayant un attribut xsl:version dont la valeur est différente de 1.0, or lorsque c'est un élément littéral résultat qui n'a pas un attribut xsl:version et qui est l'élément document d'une feuille de styles utilisant la syntaxe simplifiée (voir [2.3 Feuille de style sous forme d'élément littéral résultat]). Un élément littéral résultat ayant un attribut xsl:version dont la valeur est égale à 1.0 désactive le mode de traitement par compatibilité ascendante pour lui-même, ses attributs, ses descendants et leurs attributs.

Si un élément est traité en mode compatibilité ascendante alors:

s'il s'agit d'un élément de haut niveau et que XSLT 1.0 ne permet pas à cet élément d'être de haut niveau, alors il doit être ignoré ainsi que son contenu;

S'il s'agit d'un élément d'un modèle qui n'est pas autorisé comme tel par XSLT 1.0, alors, si l'élément n'est pas instancié, aucune erreur ne doit pas être signalée et si l'élément est instancié, alors XSLT doit exécuter un "recours" pour l'élément tel que spécifié dans [15 Reprise];

Si l'élément a un attribut non autorisé par XSLT 1.0 ou si l'élément a un attribut optionnel dont la valeur n'est pas autorisée par XSLT 1.0, alors l'attribut doit être ignoré.

Ainsi, bien que la feuille de styles suivante inclus des éléments de l'espace de noms XSLT non définis dans cette spécification, n'importe quel processeur XSLT 1.0 doit être capable de traiter cette feuille de styles suivante sans produire d'erreur :

<xsl:stylesheet version="1.1"
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:template match="/">
    <xsl:choose>
      <xsl:when test="system-property('xsl:version') >= 1.1">
        <xsl:exciting-new-1.1-feature/>
      </xsl:when>
      <xsl:otherwise>
        <html>
        <head>
          <title>XSLT 1.1 required</title>
        </head>
        <body>
          <p>Sorry, this stylesheet requires XSLT 1.1.</p>
        </body>
        </html>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>
</xsl:stylesheet>

NOTE : Si une feuille de styles dépend d'une manière cruciale d'un élément de haut niveau introduit dans une version de XSL postérieure à la version 1.0, alors la feuille de styles peut utiliser un élément xsl:message avec terminate="yes" (voir [13 Messages]) pour garantir que les processeurs XSLT qui implémentent les versions antérieures de XSL ne vont pas ignorer silencieusement ces éléments de haut niveau. Par exemple :

<xsl:stylesheet version="1.5"
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:important-new-1.1-declaration/>
  <xsl:template match="/">
    <xsl:choose>
      <xsl:when test="system-property('xsl:version') &lt; 1.1">
        <xsl:message terminate="yes">
          <xsl:text>Sorry, this stylesheet requires XSLT 1.1.</xsl:text>
        </xsl:message>
      </xsl:when>
      <xsl:otherwise>
        ...
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>
  ... </xsl:stylesheet>

Si une expression se produit dans un attribut qui est traité en mode compatibilité ascendante, alors un processeur XSLT doit rattraper les erreurs de traitement de l'expression de la manière suivante :

Si l'expression n'est pas conforme à la syntaxe permise par la grammaire XPath, alors il ne faut pas signaler d'erreurs tant que l'expression n'est pas évaluée;

Si l'expression appelle une fonction dont le nom n'est pas préfixé et qui ne fait pas partie de la librairie XSLT, alors il ne faut pas signaler d'erreurs tant que la fonction n'est pas appelée;

Si l'expression fait un appel de fonction dont les arguments, en nombre ou en type, ne sont pas autorisés par XSLT, alors il ne faut pas signaler d'erreur tant que la fonction n'est pas appelée.

2.6 Combinaison de feuilles de style

XSLT fournit deux mécanismes pour combiner des feuilles de style:

2.6.1 Inclusion de feuilles de style

<!-- Catégorie : élément de haut niveau -->
<xsl:include
  href = uri-reference />

Une feuille de styles XSLT peut inclure une autre feuille de styles XSLT en utilisant l'élément xsl:include . L'élément xsl:include a un attribut href dont la valeur est la référence de l'URI identifiant la feuille de styles à inclure. Une URI relative est résolue par rapport à l'URI base de l'élément xsl:include (voir [3.2 URI base]).

L'élément xsl:include n'est permis que comme élément de haut niveau.

L'inclusion fonctionne au niveau de l'arbre XML. La ressource localisée par la valeur de l'attribut href est analysée comme un document XML, et les fils de l'élément xsl:stylesheet de ce document remplacent l'élément xsl:include dans le document appelant. Le fait que des règles modèle ou des définitions soient incluses n'affecte pas la manière dont elles sont traitées.

La feuille de styles incluse peut utiliser la syntaxe simplifiée décrite dans [2.3 Feuille de style sous forme d'élément littéral résultat]. La feuille de styles incluse est traitée exactement de la même manière que l'élément xsl:stylesheet équivalent.

L'inclusion directe ou indirecte d'une feuille de styles par elle-même doit provoquer une erreur.

NOTE : L'inclusion multiple d'une feuille de styles peut générer des erreurs à cause de la duplication de définitions. De telles inclusions multiples sont moins évidentes lorsqu'elles sont indirectes. Par exemple, si une feuille de styles B inclue une feuille de styles A, une feuille de styles C inclue la feuille de styles A, et une feuille de styles D inclue les deux feuilles de style B et C, alors la feuille de styles A sera inclue indirectement deux fois par D. Si les feuilles de style B, C et D étaient utilisées comme des feuilles de style indépendantes, alors l'erreur pourrait être évitée en créant une feuille de styles B' qui contiendrait tout B sauf l'inclusion de A et en changeant B pour qu'elle ne contienne que l'inclusion de B' et de A, de même pour C, et enfin, en réécrivant D pour que cette feuille de styles ne fasse qu'inclure A, B', C'.

2.6.2 Import des feuilles de style

<xsl:import
      href = uri-reference />

Une feuille de styles XSLT peut importer une autre feuille XSLT en utilisant l'élément xsl:import. Importer ou inclure des feuilles de style revient à faire la même chose (voir [2.6.1 Inclusion de feuilles de style]) à l'exception du fait que les règles modèles et les définitions de la feuille de styles qui importe ont une préférence sur celles de la feuille de styles importée; ceci est décrit avec plus de précision ci-après. L'élément xsl:import possède un attribut href dont la valeur est une adresse URI identifiant la feuille de styles à importer. Une URI relative est résolue en prenant comme base l'URI de l'élément xsl:import (voir [3.2 URI base]).

L'élément xsl:import n'est permis que comme un élément de haut niveau. Les éléments fils de l'élément xsl:import doivent précéder tous les autres éléments fils de l'élément xsl:stylesheet, y compris n'importe quel élément fils de l'élément xsl:include . Lorsque xsl:include est utilisé pour inclure une feuille de styles, tous les éléments xsl:import du document inclus sont déplacés dans le document incluant cette feuille de styles et placés après tous les éléments xsl:import existant dans ce document.

Par exemple :

<xsl:stylesheet version="1.0"
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:import href="article.xsl"/>
  <xsl:import href="bigfont.xsl"/>
  <xsl:attribute-set name="note-style">
    <xsl:attribute name="font-style">italic</xsl:attribute>
  </xsl:attribute-set> </xsl:stylesheet>

Les éléments xsl:stylesheet rencontrés lors du traitement d'une feuille de styles contenant des éléments xsl:import sont considérés comme constituant un arbre d'import (import tree). Dans cet arbre, les éléments xsl:stylesheet ont un fils d'importation par élément xsl:import qu'ils contiennent.

Tout élément xsl:include est résolu avant construction de l'arbre d'import. Dans l'arbre d'import, un élément xsl:stylesheet a une plus faible préséance d'import qu'un autre s'il est lu avant ce dernier dans le sens de parcours réentrant de l'arbre d'import (c'est à dire un parcours de l'arbre tel que les éléments xsl:stylesheet soient parcourus après leurs fils importés). Chaque définition et règle modèle ont une préséance d'import déterminée par l'élément xsl:stylesheet qui le contient.

Par exemple, supposons

une feuille de styles A importe les feuilles de style B et C dans cet ordre;

la feuille de styles B importe la feuille de styles D;

la feuille de styles C importe la feuille de styles E.

Alors, l'ordre de préséance d'import (faible d'abord) est D, B, E, C, A.

NOTE : Puisque les éléments xsl:import doivent apparaître avant toute définition ou règle modèle, une implémentation traitant des feuilles de style importées, au moment ou elle rencontre l'élément xsl:import va rencontrer des définitions et des règles modèle dans l'ordre croissant de préséance d'import.

En général, une définition ou règle modèle avec une préséance d'import supérieure prend la préséance sur une définition ou une règle modèle ayant une préséance d'import plus faible. Ceci est donné avec plus de détail pour chaque type de définition ou de règle modèle.

L'importation directe ou indirecte d'une feuille de styles par elle-même est une erreur. A partir de là, le cas où une feuille de styles avec une URI particulière est importée à plusieurs endroits n'est pas traitée de manière particulière. L'arbre d'import aura un élément xsl:stylesheet différent à chaque endroit où elle est importée.

NOTE : Lorsque xsl:apply-imports est utilisé (voir [5.6 Passer outre des règles modèles]), le comportement peut être différent de celui qui aurait été si la feuille de styles avait été importée simplement avec une préséance d'import supérieure.

2.7 Feuilles de style encapsulées

Normalement une feuille de styles XSLT est un document XML à part entière ayant l'élément xsl:stylesheet comme élément racine. Cependant, une feuille de styles XSLT peut aussi être encapsulée dans une autre ressource. Deux types d'encapsulation sont possibles :

Pour faciliter la deuxième forme d'encapsulation, l'élément xsl:stylesheet est autorisé à avoir un attribut ID permettant de lui attribuer un identifiant unique.

NOTE : Dans le but d'utiliser ce type d'attribut avec la fonction id de XPath, il doit être déclaré dans la DTD comme étant un ID.

L'exemple suivant montre comment l'instruction de traitement xml-stylesheet [feuilles de style XML] peut être utilisée pour permettre à un document de contenir sa propre feuille de styles. L'adresse URI utilise une URI relative avec un fragment d'identification pour localiser l'élément xsl:stylesheet :

<?xml-stylesheet type="text/xml" href="#style1"?>
<!DOCTYPE doc SYSTEM "doc.dtd">
<doc>
<head>
<xsl:stylesheet id="style1"
                version="1.0"
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                xmlns:fo="http://www.w3.org/1999/XSL/Format">
<xsl:import href="doc.xsl"/>
<xsl:template match="id('foo')">
  <fo:block font-weight="bold"><xsl:apply-templates/></fo:block>
</xsl:template>
<xsl:template match="xsl:stylesheet">
  <!-- ignore -->
</xsl:template>
</xsl:stylesheet>
</head>
<body>
<para id="foo"> ...
</para>
</body>
</doc>

NOTE : Une feuille de styles encapsulée dans le document sur lequel elle s'applique ou qui peut être incluse ou importée dans une feuille de styles qui est, elle, encapsulée, doit typiquement contenir une règle modèle précisant que les éléments xsl:stylesheet sont à ignorés.

3 Modèle de données

Le modèle de données utilisé par XSLT est le même que celui utilisé par XPath avec en plus ce qui est décrit dans cette section. XSLT travaille sur les documents de type source, résultat et feuille de styles en utilisant le même modèle de données. Deux documents XML ayant le même arbre seront traités de la même manière par XSLT.

Les instructions de traitement et les commentaires de la feuille de styles sont ignorés : la feuille de styles est traitée comme si, ni les noeuds d'instructions de traitement, ni les noeuds de commentaires, n'étaient inclus dans l'arbre qui représente la feuille de styles.

3.1 Les fils du noeud racine

Les restrictions faites sur les fils du noeud racine sont levées pour l'arbre résultat. L'arbre résultat peut avoir comme enfant n'importe quelle séquence de noeuds qu'il serait possible d'avoir pour un noeud d'élément. En particulier, il peut avoir pour enfant des noeuds textuels et n'importe quel nombre de noeuds d'éléments. Lorsqu'un arbre résultat est sauvegardé en utilisant la méthode d'écriture XML (voir [16 Sortie]), il est possible que l'arbre résultat ne soit pas un document XML bien formé; toutefois, il sera toujours une entité générale externe validée bien formée.

Lorsque l'arbre source est le résultat de l'analyse d'un document XML bien formé, alors le noeud racine de l'arbre source satisfait de facto aux restrictions normales qui sont de ne pas avoir un noeud texte comme enfant et exactement un seul élément enfant. Si l'arbre source est créé par d'autres moyens, par exemple en utilisant DOM, les restrictions habituelles sont levées pour l'arbre source comme pour l'arbre résultat.

3.2 URI base

A chaque noeud est associé une URI qu'on désigne comme étant son URI de base : elle est utilisée pour le remplacement des valeurs relatives des URI d'attributs par des URIs absolues. Si un élément ou une instruction de traitement survient dans une entité externe, alors son URI de base est l'URI de l'entité externe; autrement, l'URI de base est l'URI de base du document. L'URI de base du noeud document est l'URI de l'entité document. L'URI de base d'un noeud textuel, d'un noeud commentaire, d'un noeud d'attribut ou d'un noeud d'espace de noms est l'URI de base du parent du noeud.

3.3 Entités non valides

Le noeud racine dispose de règles de correspondances qui fournissent l'URI de chaque entité non analysée déclarée dans la DTD de ce document. L'URI est générée à partir des identificateurs système et publique spécifiés dans la déclaration de l'entité. Le processeur XSLT peut utiliser l'identifiant publique pour générer l'URI d'une entité au lieu de celle spécifiée dans l'identifiant système. Si le processeur XSLT n'utilise pas un identifiant publique pour générer l'URI, il doit utiliser l'identifiant système; si l'identifiant système est une URI relative, il doit être résolu et transformé en une URI absolue en utilisant comme URI de base, l'URI de la ressource contenant la déclaration de l'entité [RFC2396].

3.4 Suppression des espaces blancs

Une fois l'arbre pour le document source ou la feuille de styles construit, mais avant tout autre traitement XSLT, certains noeuds textuels sont supprimés. Un noeud textuel est supprimé quand il ne contient que des caractères d'espaces blancs. Supprimer le noeud textuel revient à l'enlever de l'arbre. Le processus de suppression prend en entrée un ensemble de noms d'éléments pour lesquels les caractères d'espaces blancs doivent être préservés. Le processus de suppression est appliqué aussi bien aux feuilles de styles qu'aux documents source, cependant, les ensembles des noms d'éléments pour lesquels les caractères d'espaces blancs doivent être préservés sont déterminés différemment pour les feuilles de style et les documents source.

Un noeud textuel est préservé si l'une des conditions suivantes est vérifiée :

le nom de l'élément parent du noeud textuel fait partie de l'ensemble contenant les noms des éléments dont on veut préserver les caractères d'espaces blancs.

Le noeud textuel contient au moins un caractère différent d'un espace blanc. Comme pour XML, les espaces blancs sont les caractères dont les codes hexadécimaux sont #x20, #x9, #xD ou #xA.

Le premier des ancêtres du noeud textuel à avoir l'attribut xml:space renseigné en fixe la valeur à preserve (en d'autres termes : il n'existe aucun élément entre cet ancêtre et le noeud textuel qui modifierait la valeur de cet attribut pour la remettre à default).

Autrement le noeud texte est supprimé.

Les attributs xml:space ne sont pas supprimés de l'arbre.

NOTE : Ceci sous-entend qu'un attribut xml:space est spécifié dans un élément littéral résultat et sera inclus dans le résultat.

Pour les feuilles de style, l'ensemble des noms d'éléments préservant les caractères d'espaces blancs est simplement xsl:text.

<!-- Catégorie : élément de haut niveau -->
<xsl:strip-space
      elements = tokens />

<!--Catégorie : élément de haut niveau -->
<xsl:preserve-space
      elements = tokens />

Pour les documents source, l'ensemble des noms d'éléments préservant les caractères d'espaces blancs est spécifié par les éléments de haut niveau xsl:strip-space et xsl:preserve-space. Chacun de ces éléments a un attribut elements dont la valeur est une liste de NameTests séparés par des caractères espace. A l'origine, l'ensemble des noms d'éléments préservant les caractères d'espaces blancs contient tous les noms d'éléments. Si, dans l'élément xsl:strip-space, un nom d'élément correspond à un NameTest alors, il est retiré de l'ensemble de noms d'éléments préservant les caractères d'espaces blancs. Si un nom d'élément correspond à un NameTest dans l'élément xsl:preserve-space, alors il est ajouté à l'ensemble des noms d'éléments préservant les caractères d'espaces blancs. Un élément correspond à un NameTest si et seulement si son NameTest est vérifié par le test de noeud XPath. Les conflits de correspondances entre les éléments xsl:strip-space and xsl:preserve-space sont résolus de la même manière que les conflits entre les règles modèle (voir [5.5 Résolution de conflits des règles modèle]). Ainsi, la correspondance applicable pour nom d'élément particulier est déterminée de la manière suivante:

Premièrement, toute correspondance avec une préséance d'import plus faible qu'une autre est ignorée.

Deuxièmement, toute correspondance avec un NameTest ayant une priorité par défaut plus faible que celle du NameTest d'une autre correspondance est ignorée.

S'il reste plus d'une correspondance, c'est une erreur. Un processeur XSLT peut signaler l'erreur; s'il ne signale pas l'erreur, il doit la rattraper en choisissant, parmi les correspondances restantes, celle utilisée en dernier dans la feuille de styles.

4 Expressions

XSLT utilise le langage d'expression défini par XPath [XPath]. Les expressions sont utilisées dans XSLT pour une variété de possibilités incluant :

Une expression doit correspondre à la règle de production Expr de XPath.

Les expressions interviennent comme valeurs de certains attributs d'éléments XSLT et entre accolades dans des modèles de valeurs d'attributs.

Dans XSLT, une expression autonome (c'est à dire : une expression qui ne fait partie d'aucune autre expression) prend son contexte comme suit :

Le noeud contextuel est le noeud courant

la position contextuelle vient de la position du noeud courant dans la liste courante de noeuds; la première position est 1

la dimension contextuelle est issue de la dimension de la liste courante de noeuds

les liens variables sont ceux dans le périmètre de l'élément ayant un attribut dans lequel l'expression se produit (voir [11 Variables et Paramètres])

l'ensemble de déclarations d'espace de noms sont celles dans le champ de l'élément ayant l'attribut dans lequel l'expression se produit ; ceci inclus la déclaration implicite du préfixe xml exigé par la Recommandation des espaces de noms [Noms XML] ; l'espace de noms par défaut (comme déclaré par xmlns) n'appartient pas à cet ensemble.

la librairie de fonctions est représentée par la librairie de fonctions de base augmentée des fonctions additionnelles définies dans [12 Fonctions additionnelles] et des fonctions d'extension décrites dans [14 Extensions]; Lorsqu'une expression appelle une quelconque autre fonction, une erreur doit être générée.

5 Règles modèle

5.1 Modèle de traitement

Une liste de noeuds sources est traitée pour créer un fragment de l'arbre résultat. L'arbre résultat est construit par traitement d'une liste contenant juste le noeud racine. Une liste de noeuds sources est traitée par rajout successif des arbres résultants du traitement successif de chaque noeud de la liste. Un noeud est traité en trouvant toutes les règles modèle dont les motifs correspondent au noeud, et en choisissant le meilleur parmi elles; la règle modèle retenue est alors instanciée en considérant le noeud comme noeud courant et la liste de noeuds source comme liste courante de noeuds. Typiquement, un modèle contient des instructions traitant une liste de noeuds source sélectionnés. Le processus de correspondance, instanciation et sélection se poursuit récursivement et se termine lorsque aucun nouveau noeud source n'est sélectionné pour traitement.

Les outils sont libres de traiter le document source par n'importe quel moyen du moment ou le résultat produit est le même que s'il était traité par ce modèle de traitement.

5.2 Modèles

Les règles modèle identifient les noeuds auxquels elles s'appliquent en utilisant un motif. Les motifs sont aussi bien utilisés dans des règles modèle que pour la numérotation (voir [7.7 Numérotation]) ou la déclaration de clés (voir [12.2 Clés]). Un motif spécifie un ensemble de conditions sur un noeud. Un noeud satisfaisant les conditions correspond au motif; un noeud qui ne satisfait pas les conditions ne correspond pas au motif. La syntaxe pour les motifs est un sous-ensemble de la syntaxe pour les expressions. En particulier, les chemins de localisation soumis à certaines restrictions peuvent être utilisés comme des motifs. Une expression, qui est aussi un motif, donne toujours comme résultat un objet qui est un ensemble de noeuds. Un noeud correspond à un motif si le noeud est membre du résultat de l'évaluation du motif, considéré alors comme expression respectant un certain contexte; ce cas se produit quand le noeud contextuel est le noeud en train d'être mis en correspondance ou l'un de ses ancêtres.

Voici quelques exemples de motifs:

para correspond à n'importe quel élément para

* correspond à n'importe quel élément

chapter|appendix trouve tous les éléments chapter et appendix

olist/item trouve tous les éléments item ayant olist comme parent

appendix//para correspond à n'importe quel élément para dont un ancêtre est appendix

/ correspond au noeud racine

text() correspond à n'importe quel noeud textuel

processing-instruction() correspond à n'importe quel instruction de traitement

node() correspond à n'importe quel noeud autre qu'un noeud attribut et que le noeud racine

id("W11") correspond à l'élément ayant l'identifiant unique W11

para[1] correspond au premier des éléments para d'un parent

*[position()=1 and self::para] correspond à n'importe quel élément para qui est le premier élément fils de son parent

para[last()=1] correspond à n'importe quel élément para qui est l'unique élément para de son élément parent

items/item[position()>1] correspond à tous les éléments item, autres que le premier, et dont le parent est items

item[position() mod 2 = 1] serait vrai pour tous les fils item de numéro d'ordre impair par rapport à leur parent.

div[@class="appendix"]//p correspond à tous les éléments p ayant un ancêtre div pour lequel l'attribut class prend la valeur appendix

@class correspond à tous les attributs class (pas à tous les éléments ayant l'attribut class)

@* correspond à n'importe quel attribut

Un motif doit concorder avec la grammaire des motifs (Pattern). Un motif est un ensemble de motifs de chemins de localisation séparés par |. Un motif de chemin de localisation est un chemin de localisation dont les étapes n'utilisent que les axes child ou attribute. Bien que les motifs ne doivent pas utiliser l'axe descendant-or-self, ils peuvent utiliser l'opérateur // tout aussi bien que l'opérateur /. Les motifs de chemins de localisation peuvent aussi commencer par un appel de fonction id ou key avec un argument littéral. Les prédicats d'un motif peuvent utiliser n'importe quelle expression exactement comme ceux des chemins de localisation.

Modèles
[1]  Pattern    ::=  LocationPathPattern
| Pattern '|' LocationPathPattern
[2]  LocationPathPattern    ::=  '/' RelativePathPattern?
| IdKeyPattern (('/' | '//') RelativePathPattern)?
| '//'? RelativePathPattern
[3]  IdKeyPattern    ::=  'id' '(' Literal ')'
| 'key' '(' Literal ',' Literal ')'
[4]  RelativePathPattern    ::=  StepPattern
| RelativePathPattern '/' StepPattern
| RelativePathPattern '//' StepPattern
[5]  StepPattern    ::=  ChildOrAttributeAxisSpecifierNodeTestPredicate*
[6]  ChildOrAttributeAxisSpecifier    ::=  AbbreviatedAxisSpecifier
| ('child' | 'attribute') '::'

Un motif est conçu pour concorder avec un noeud si et seulement s'il existe un contexte tel que lorsque le motif est évalué comme une expression dans ce contexte, le noeud appartient à l'ensemble de noeuds résultat. Lorsqu'une correspondance est en train d'être établie pour un noeud, les contextes possibles ont un noeud contextuel qui est le noeud en train d'être mis en correspondance ou un de ses ancêtres, et une liste de noeuds contextuels réduite au seul noeud contextuel.

Par exemple, p concorde avec n'importe quel élément p, parce que pour tout p, si l'expression p est évaluée dans le contexte de son élément parent, alors cet élément p appartiendra à l'ensemble des noeuds résultat.

NOTE : Cela correspond même à un élément p qui serait l'élément document puisque la racine du document est le parent de l'élément document.

Bien que la sémantique des motifs soit indirectement spécifiée en terme d'évaluation d'expressions, il est facile de comprendre directement la signification des motifs sans devoir les considérer comme des évaluations d'expression. Dans un motif, | indique les alternatives; un motif avec un ou plusieurs | séparant différentes alternatives concorde si l'une des alternatives concorde. La correspondance pour un motif composé d'une séquence d'étapes (StepPatterns) séparés par / ou // est faite de droite vers la gauche. La concordance du motif ne se produit que si l'étape la plus à droite concorde et qu'un élément approprié concorde avec le reste du motif; si le séparateur est / alors seul le parent est un élément approprié; si le séparateur est //, alors tout élément ancêtre peut être un élément approprié. Une séquence d'étape (StepPatterns) qui utilise l'axe fils concorde si le test de noeud (NodeTest) est vrai pour le noeud et si le noeud n'est pas un noeud d'attribut. Une séquence d'étapes (StepPattern) qui utilise l'axe des attributs concorde si le test de noeud (NodeTest) est vrai pour le noeud et si le noeud est un noeud attribut. Si [] est présent, alors la première expression du prédicat (PredicateExpr) dans une séquence d'étapes (StepPattern est évalué en considérant que le noeud pour lequel une concordance est en train d'être établie est le noeud contextuel et que ses suivants correspondant au test de noeud (NodeTest) forment la liste des noeuds contextuels, à moins que le noeud en train d'être recherché ne soit un noeud d'attribut, auquel cas, la liste des noeuds contextuels correspond à tous les attributs ayant le même parent que l'attribut en train d'être recherché et qui concorde avec le test de nom (NameTest).

Par exemple :

appendix//ulist/item[position()=1]

correspond à un noeud si et seulement si tout ce qui suit est vrai:

le test de noeud (NodeTest) item est vrai pour le noeud et le noeud n'est pas un attribut; en d'autres termes, le noeud est un élément item

L'évaluation du prédicat (PredicateExpr) position()=1 est vraie en considérant le noeud comme noeud contextuel et les suivants du noeud (qui sont des éléments item) comme liste de noeuds contextuels

Le noeud a un parent qui concorde avec le motif appendix//ulist ; Ceci est vrai si le parent est un élément ulist dont un des ancêtres est l'élément appendix.

5.3 Définition de règles modèle

<!--Catégorie : élément de haut niveau -->
<xsl:template
      match = pattern
      name = qname
      priority = number
      mode = qname>
      <!-- Contenu : (xsl:param*, template)-->
</xsl:template>

Une règle modèle est spécifiée en utilisant l'élément xsl:template. L'attribut match est un motif (Pattern) qui identifie le noeud source ou les noeuds pour lesquels la règle s'applique. L'attribut match est exigé à moins que l'élément xsl:template ait un attribut name (voir [6 Modèles nommés]). Si la valeur de l'attribut match contient une expression de type VariableReference c'est une erreur. Le contenu de l'élément xsl:template est le modèle qui est instancié lorsque la règle modèle est appliquée.

Par exemple, un document XML peut contenir:

This is an <emph>important</emph> point.

La règle modèle suivante concorde avec les éléments emph et produit un objet de formatage fo:inline-sequence avec la propriété font-weight valant bold.

<xsl:template match="emph">
  <fo:inline-sequence font-weight="bold">
    <xsl:apply-templates/>
  </fo:inline-sequence>
</xsl:template>

NOTE : Les exemples de ce document utilisent le préfixe fo: pour l'espace de noms http://www.w3.org/1999/XSL/Format qui est l'espace de noms des objets de formatage défini dans [XSL].

Comme décrit dans ce qui suit, l'élément xsl:apply-templates traite d'une manière récursive les fils de l'élément source.

5.4 Application des règles modèle

<!--Catégorie : instruction -->
<xsl:apply-templates
      select = node-set-expression
      mode = qname>
      <!-- Contenu : (xsl:sort | xsl:with-param)*-->
</xsl:apply-templates>

L'exemple suivant crée un bloc pour l'élément chapter et traite ses fils directs.

<xsl:template match="chapter">
  <fo:block>
    <xsl:apply-templates/>
  </fo:block>
</xsl:template>

En l'absence de l'attribut select, l'instruction xsl:apply-templates traite tous les fils du noeud courant, y compris les noeuds textuels. Cependant, tous les noeuds textuels supprimés conformément à[3.4 Suppression des espaces blancs] ne sont pas traités. Si la suppression des espaces blancs est désactivée pour un élément, alors tous les espaces blancs du contenu de cet élément sont traités comme du texte; et ainsi, les espaces blancs entre les éléments fils compteront pour déterminer la position d'un élément fils comme le retourne la fonction position.

Un attribut select peut être utilisé pour traiter les noeuds sélectionnés par une expression au lieu de traiter tous les éléments. La valeur de l'attribut select est une expression. L'expression doit retourner un ensemble de noeuds. L'ensemble des noeuds sélectionnés est traité dans l'ordre du document, à moins qu'une spécification d'ordonnancement ne soit présente (voir [10 Ordonnancement]).

L'exemple suivant traite tous les fils author de author-group :

<xsl:template match="author-group">
  <fo:inline-sequence>
    <xsl:apply-templates select="author"/>
  </fo:inline-sequence>
</xsl:template>

L'exemple suivant traite tous les éléments given-name des éléments authors, eux-mêmes étant des fils de author-group :

<xsl:template match="author-group">
  <fo:inline-sequence>
    <xsl:apply-templates select="author/given-name"/>
  </fo:inline-sequence>
</xsl:template>

Cet exemple traite tous les éléments heading descendant de l'éléments book.

<xsl:template match="book">
  <fo:block>
    <xsl:apply-templates select=".//heading"/>
  </fo:block>
</xsl:template>

Il est aussi possible de traiter des éléments qui ne soient pas des descendants du noeud courant. Dans cet exemple, on suppose qu'un élément department a des enfants group et des descendants employee. Il trouve le service (department)  d'un employé (employee) puis les enfants group du service (department).

<xsl:template match="employee">
  <fo:block>
    Employee <xsl:apply-templates select="name"/> belongs to group
    <xsl:apply-templates select="ancestor::department/group"/>
  </fo:block>
</xsl:template>

Plusieurs éléments xsl:apply-templates peuvent être utilisés dans un seul modèle pour faire des réordonnancements simples. L'exemple suivant crée deux tables HTML. La première table est remplie avec les ventes intérieures et la deuxième avec les ventes à l'exportation.

<xsl:template match="product">
  <table>
    <xsl:apply-templates select="sales/domestic"/>
  </table>
  <table>
    <xsl:apply-templates select="sales/foreign"/>
  </table>
</xsl:template>

NOTE : A ce stade, il est possible d'avoir deux descendants qui concordent dont l'un est descendant de l'autre. Ce cas n'est pas traité d'une manière spécifique; les deux descendants seront traités comme d'habitude. Par exemple, pour le document source :

<doc><div><div></div></div></doc>

la règle

<xsl:template match="doc">
  <xsl:apply-templates select=".//div"/>
</xsl:template>

traite aussi bien les éléments externes à div que les éléments interne à div.

NOTE : Typiquement, xsl:apply-templates est utilisé pour traiter uniquement les noeuds qui sont des descendants du noeud courant. Une telle utilisation de xsl:apply-templates ne peut engendrer une boucle de traitement infinie. Cependant, lorsque xsl:apply-templates est utilisé pour traiter les éléments qui ne sont pas des descendants du noeud courant, il y a une possibilité de boucle infinie. Par exemple :

<xsl:template match="foo">
  <xsl:apply-templates select="."/>
</xsl:template>

Les outils peuvent, dans certains cas, être capables de détecter de pareilles boucles, mais la possibilité qu'une feuille de styles entre dans une boucle infinie sans que le programme ne la détecte persiste.

5.5 Résolution de conflits des règles modèle

Il est possible qu'un noeud source concorde avec plusieurs règles modèle. La règle à utiliser est déterminée de la manière suivante:

Premièrement, toutes les règles concordantes ayant une préséance d'import plus faible que la règle considérée ou que celles qui ont la préséance d'import plus forte sont éliminées.

Ensuite, toutes les règles ayant une plus faible priorité que la règle considérée ou que les règles ayant la priorité la plus forte sont éliminées. La priorité d'une règle modèle est spécifiée par l'attribut priority de la règle. Sa valeur doit être un nombre réel (négatif ou positif), conforme à la règle de production Number avec un signe moins (-) optionnel au début du nombre. La priorité par défaut est calculée comme suit :

Si le motif contient plusieurs alternatives séparées par |, alors il est traité comme si c'était un ensemble de règles modèle, une pour chaque alternative.

Si le motif a la forme d'un nom qualifié (QName) précédé par un ChildOrAttributeAxisSpecifier ou a la forme d'une instruction de traitement processing-instruction(Literal) précédé par un ChildOrAttributeAxisSpecifier, alors la priorité est 0.

Si le motif a la forme d'un nom sans deux points (NCName):* précédé d'un ChildOrAttributeAxisSpecifier, alors la priorité est -0.25.

Autrement, si le pattern consiste uniquement en un test de noeud NodeTest précédé par un ChildOrAttributeAxisSpecifier, alors la priorité est -0.5.

Sinon, la priorité est 0.5.

Ainsi le plus commun des types de motifs (un motif qui teste un type particulier de noeuds avec un nom étendu particulier) a une priorité 0. Ensuite, le type de motif le moins spécifique (un motif qui teste un type particulier de noeuds et un nom étendu avec une URI particulière indiquant son espace de noms) a une priorité de -0.25. Les motifs les moins spécifiques (motifs permettant de tester un type particulier de noeuds) ont une priorité de -0.5. Les motifs les plus spécifiques que le motif le plus commun ont une priorité de 0.5.

Si après vérification des conditions ci-dessus il reste plus qu'une seule règle modèle qui concorde alors il y a une erreur. Un processeur XSLT peut signaler l'erreur; s'il ne le fait pas, il doit la rattraper en choisissant, parmi les règles concordantes restantes, celle qui arrive en dernière dans la feuille de styles.

5.6 Passer outre des règles modèles

<!-- Catégorie : instruction -->
<xsl:apply-imports />

Une règle modèle en train d'être utilisée pour passer outre une règle modèle dans une feuille de styles importée (voir [5.5 Résolution de conflits des règles modèle]) peut utiliser l'élément xsl:apply-imports pour invoquer la règle outrepassée.

A chaque étape du traitement de la feuille de styles correspond une règle modèle courante. Dès qu'une règle est retenue par un motif de concordance, elle devient la règle modèle courante pour l'instanciation de la règle modèle. Lorsqu'un élément xsl:for-each est instancié, la règle courante devient nulle pour l'instanciation du contenu de l'élément xsl:for-each.

xsl:apply-imports traite le noeud courant en utilisant uniquement les règles modèle qui étaient importées dans l'élément de la feuille de styles contenant la règle modèle courante; le noeud est traité dans le mode de la règle modèle courante. Si xsl:apply-imports est instancié alors que la règle modèle courante est nulle alors c'est une erreur.

Par exemple, supposons que la feuille de styles doc.xsl contienne une règle modèle pour les éléments example :

<xsl:template match="example">
  <pre><xsl:apply-templates/></pre>
</xsl:template>

Une autre feuille de styles pourrait importer doc.xsl et modifier le traitement des éléments example de la manière suivante:

<xsl:import href="doc.xsl"/>
<xsl:template match="example">
  <div style="border: solid red">
     <xsl:apply-imports/>
  </div>
</xsl:template>

L'effet combiné transformerait un élément example dans un élément de la forme :

<div style="border: solid red"><pre>...</pre></div>

5.7 Modes

Les modes permettent à un élément d'être traité plusieurs fois, en produisant un résultat différent à chaque fois.

Les éléments xsl:template et xsl:apply-templates ont tous les deux l'attribut optionnel mode. La valeur de l'attribut mode est un nom qualifié (QName), pouvant être développé comme décrit dans [2.4 Noms qualifiés ]. Si xsl:template n'a pas d'attribut match, il ne doit pas avoir non plus un attribut mode. Si un élément xsl:apply-templates a un attribut mode, alors il s'applique uniquement aux règles modèle des éléments xsl:template ayant un attribut mode avec la même valeur; si un élément xsl:apply-templates n'a pas d'attribut mode, alors il ne s'applique qu'aux règles modèle des éléments xsl:template qui n'ont pas d'attribut mode.

5.8 Règles modèle internes

Il existe une règle modèle interne permettant à un traitement récursif de continuer même en cas de non-concordance de motif par une règle modèle explicite de la feuille de styles. Cette règle modèle s'applique aussi bien aux noeuds d'éléments qu'au noeud racine. Ce qui suit montre ce qui équivaut à cette règle interne :

<xsl:template match="*|/">
  <xsl:apply-templates/>
</xsl:template>

Il existe aussi une règle modèle interne pour chaque mode, permettant à un traitement récursif de continuer dans le même mode en cas d'absence d'une correspondance de motif avec une règle modèle explicite delta feuille de styles. Cette règle modèle s'applique tant aux noeuds d'éléments qu'au noeud racine. Ce qui suit montre ce qui équivaut à cette règle modèle interne pour un mode m.

<xsl:template match="*|/" mode="m">
  <xsl:apply-templates mode="m"/>
</xsl:template>

Il existe aussi une règle modèle interne pour les noeuds textuels et les noeuds d'attribut qui sert à en recopier le texte :

<xsl:template match="text()|@*">
  <xsl:value-of select="."/>
</xsl:template>

La règle modèle interne pour le traitement des instructions et des commentaires ne fait rien.

<xsl:template match="processing-instruction()|comment()"/>

La règle modèle interne pour les noeuds d'espaces de noms ne fait rien non plus. Il n'existe aucun motif pouvant concorder avec un noeud d'espace de noms; dans ce cas, la règle modèle interne est la seule règle modèle appliquée aux noeuds d'espace de noms.

Les règles modèle internes sont traitées comme si elles étaient importées implicitement avant la feuille de styles et, par conséquent, ont une préséance d'import plus faible que toutes les autres règles modèle. Ainsi, l'auteur peut remplacer une règle modèle interne en écrivant explicitement une règle modèle.

6 Modèles nommés

<!--Catégorie : instruction -->
<xsl:call-template
  name = qname>
  <!-- Contenu : xsl:with-param*-->
</xsl:call-template>

Les modèles peuvent être invoqués par leur nom. L'utilisation de l'attribut name de l'élément xsl:template permet de spécifier un nom de modèle. La valeur de l'attribut name est un nom qualifié (QName), qui est développé tel que décrit au chapitre [2.4 Noms qualifiés]. Quand l'élément xsl:template est qualifié par l'attribut name, il peut, sans que cela soit obligatoire, avoir également un attribut match. L'élément xsl:call-template permet d'appeler un modèle par son nom; il a un attribut obligatoire name qui identifie le modèle à appeler. Au contraire de l'élément xsl:apply-templates, xsl:call-template ne modifie pas le noeud courant ou la liste courante de noeuds.

Les attributs match, mode et priority d'un élément xsl:template n'ont pas d'effet si le modèle est invoqué par un élément xsl:call-template. De même, l'attribut name d'un élément xsl:template n'a pas d'effet si le modèle est invoqué par un élément xsl:apply-templates.

Une erreur est produite si une même feuille de styles contient plus d'un modèle ayant à la fois le même nom et la même préséance d'import.
 

7 Création de l'arbre résultant

Cette section décrit les instructions qui créent directement des noeuds dans l'arbre résultant.

7.1 Création d'éléments et d'attributs

7.1.1 Eléments résultats littéraux

Dans un modèle, un élément d'une feuille de style qui n'appartient pas à l'espace de noms XSLT et n'est pas un élément extension (voir [14.1 Eléments extension]) est instancié pour créer un noeud élément avec le même nom étendu. le contenu de l'élément est un template qui est instancié pour donner le contenu de l'élément noeud créé. L'élément noeud créé aura les noeuds attributs qui étaient présents sur le noeud élément dans l'arbre de la feuille de style, plutôt que les attributs avec les noms dans l'espace de noms XSLT.

Le noeud élément créé aura aussi une copie de l'espace de noms des noeuds qui étaient présents sur l'élément noeuds dans la feuille de style avec l'exception que tout espace de noms dont la valeur textuelle est l'espace de noms XSLT URI (http://www.w3.org/1999/XSL/Transform),un nom d'espace URI déclaré a une extension d'espace de noms (voir [14.1 Éléments extension]) ou un espace de noms URI désigné comme un espace de noms exclu. Un espace de noms URI est désigné comme un espace de noms exclu en utilisant un attribut exclude-result-prefixes sur un élément xsl:stylesheet ou un attribut xsl:exclude-result-prefixes sur un élément résultat littéral. La valeur de ces deux attributs est une liste de préfixes d'espace de noms séparés par un espace blanc. L'espace de nom relié à chacun des préfixes est désigné comme un espace de noms exclu. C'est une erreur s'il n'y a pas d'espace de noms relié au préfixe sur un élément supportant l'attribut exclude-result-prefixes ou xsl:exclude-result-prefixes. L'espace de noms par défaut (comme déclaré par xmlns) peut-être désigné comme un espace de noms exclu en incluant #default dans la liste des préfixes d'espace de noms. La désignation d'un espace de noms comme par exemple un espace de noms exclu est effectif dans un sous arbre de la feuille de style relié à l'élément supportant l'attribut exclude-result-prefixes ou xsl:exclude-result-prefixes ; un sous arbre relié à un élément xsl:stylesheet n'inclue pas toutes les feuilles de style importées ou inclues par les enfants de cet élément.

NOTE: Quand une feuille de style utilise une déclaration d'espace de noms seulement dans le but d'adresser un arbre source, en spécifiant le préfixe dans l'attribut exclude-result-prefixes, cela n'empêche pas les déclarations superflues d'espaces de noms dans l'arbre résultant.

La valeur d'un attribut d'un élément résultat littéral est interprétée comme la valeur de l'attribut template: il peut contenir des expressions contenues entre accolades ({}).

Un espace de noms URI dans l'arbre d'une feuille de style est utilisé pour spécifier un espace de noms URI dans l'arbre résultant est appelé espace de noms URI littéral. Cela s'applique à:

l'espace de noms URI est un nom étendu d'un élément résultat littéral dans la feuille de style

l'espace de noms URI dans le nom étendu d'un attribut spécifié dans un élément résultat littéral dans la feuille de style

la valeur textuelle d'un noeud d'espace de noms sur un élément résultat littéral d'une feuille de style

<!-- Category: top-level-element -->
<xsl:namespace-alias
  stylesheet-prefix = prefix | "#default"
  result-prefix = prefix | "#default" />

Une feuille de style peut utiliser l'élément xsl:namespace-alias pour déclarer qu'un espace de noms URI est un alias pour un autre espace de noms URI. Quand un espace de noms URI littéral a été déclaré comme étant un alias pour un autre espace de noms URI, alors l'espace de noms URI dans l'arbre résultat sera l'espace de noms que l'espace de noms littéral URI est son alias, au lieu de l'espace de noms URI littéral lui-même. L'élément xsl:namespace-alias déclare que l'espace de noms relié au préfixe spécifié par l'attribut stylesheet-prefix est un alias pour l'espace de noms URI relié au préfixe spécifié par l'attribut result-prefix. Donc, l'attribut stylesheet-prefix  spécifie l'espace de noms URI qui apparaîtra dans la feuille de style, et l'attribut result-prefix spécifie l'espace de noms URI correspondant qui apparaîtra dans l'arbre résultant. L'espace de noms par défaut (comme déclaré par xmlns) peut-être spécifié en utilisant #default au lieu d'un préfixe. Si un espace de noms URI est déclaré être un alias pour plusieurs espaces de noms URIs différents, alors la déclaration avec la plus haute précédence d'importation est utilisée. C'est une erreur s'il y a plus d'une déclaration de ce type. Un processeur XSLT peut signaler une erreur, s'il ne provoque pas d'erreur, il faut récupérer en choisissant, parmi les déclarations ayant l'importation de la plus haute préséance, celle de la dernière feuille de style.

Quand des éléments résultats littéral sont utilisés pour créer un élément, un attribut ou un noeud d'espace de noms déjà utilisé par l'espace de noms de l'URI de XSLT, la feuille de style doit être un alias. Par exemple, la feuille de style :

<xsl:stylesheet
  version="1.0"
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  xmlns:fo="http://www.w3.org/1999/XSL/Format"
  xmlns:axsl="http://www.w3.org/1999/XSL/TransformAlias">
<xsl:namespace-alias stylesheet-prefix="axsl" result-prefix="xsl"/>
<xsl:template match="/">
  <axsl:stylesheet>
    <xsl:apply-templates/>
  </axsl:stylesheet>
</xsl:template>
<xsl:template match="block">
  <axsl:template match="{.}">
     <fo:block><axsl:apply-templates/></fo:block>
  </axsl:template>
</xsl:template>
</xsl:stylesheet>

génèrera une feuille de style XSLT à partir d'un document de la forme :

<elements>
<block>p</block>
<block>h1</block>
<block>h2</block>
<block>h3</block>
<block>h4</block>
</elements>

NOTE: Il peut être aussi nécessaire d'utiliser des alias pour les espaces de noms plutôt que les espaces de noms XSLT URI. Par exemple, les éléments résultats littéraux appartenant à un espace de noms qui comportent des signatures digitales peuvent faire qu'une feuille de style XSLT soit mal comprise par un programme sécuritaire, en utilisant un alias pour l'espace de noms l'on peut éviter une telle confusion.

7.1.2 Créer des éléments avec xsl:element

<!-- Category: instruction -->
<xsl:element
  name = { qname }
  namespace = { uri-reference }
  use-attribute-sets = qnames>
  <!-- Content: template -->
</xsl:element>

L'élément xsl:element permet la création d'un élément ayant un nom calculé. Le nom étendu de l'élément à créer est spécifié par l'attribut obligatoire name et un attribut optionnel namespace. Le contenu de l'élément xsl:element est le modèle des attributs et enfants de l'élément créé.

L'attribut name est interprété comme une valeur d'attribut modèle. C'est une erreur si la chaîne résultant de l'instanciation de la valeur de l'attribut modèle n'est pas un QName. Un processeur XSLT peut signaler l'erreur, s'il ne le fait pas, alors il doit la rattraper en faisant que le résultat de l'instanciation de l'élément xsl:element  soit la séquence de noeuds créée en instanciant le contenu de l'élément xsl:element, excluant tout noeud attribut initial. Si l'attribut de l'espace de noms n'est pas présent, alors le QName est étendu en nom étendu en utilisant les déclarations des espaces de noms en cours pour l'élément xsl:element, incluant toute déclaration d'espace de noms par défaut.

Si l'attribut namespace est présent, alors il est interprété comme  valeur d'attribut modèle. La chaîne de caractères résultant de l'instanciation de la valeur d'attribut modèle devrait être une référence URI. Ce n'est pas une erreur si la chaîne n'est pas syntaxiquement une référence URI correcte. Si la chaîne est vide, alors le nom étendu de l'élément à un espace de noms URI nul. Sinon, la chaîne est utilisée comme un espace de noms URI du nom étendu de l'élément créé. La partie locale du  QName spécifiée par l'attribut name est utilisée comme partie locale au nom étendu de l'élément créé.

Les processeurs XSLT peuvent utiliser le préfixe du QName spécifié dans l'attribut name au moment de choisir le préfixe utilisé pour produire l'élément créé comme XML ; toutefois, ils ne sont pas obligé de le faire.

7.1.3 Créer des attributs avec xsl:attribute

<!-- Category: instruction -->
<xsl:attribute
  name = { qname }
  namespace = { uri-reference }>
  <!-- Content: template -->
</xsl:attribute>

L'élément xsl:attribute peut être utilisé pour ajouter des attributs aux éléments résultats qui sont créés soit par un élément résultat littéral dans la feuille de style soit par des instructions telles que xsl:element. Le nom étendu de l'attribut à créer est spécifié par l'attribut obligatoire name et un attribut optionnel namespace . Instancier un élément xsl:attribute ajoute un noeud attribut à l'élément noeud résultat. le contenu de l'élément xsl:attribute est un modèle de la valeur de l'attribut créé.

l'attribut name est interprété comme une valeur d'attribut modèle. C'est une erreur si la chaîne résultante de l'intanciation de la valeur de l'attribut modèle n'est pas un QName ou est la chaîne xmlns. Un processeur XSLT peut provoquer une erreur, s'il ne le fait pas, il faut la rattraper en n'ajoutant pas l'attribut à l'arbre résultant. Si l'attribut de l'espace de noms n'est pas présent, alors le  QName est éténdu en un nom étendu en utilisant les déclarations d'un espace de noms en cours pour l'élément xsl:attribute, n' incluant aucune déclaration d'espace de noms par défaut.

Si  l'attribut namespace est présent, alors il est aussi interprété comme une valeur d'attribut modèle. La chaîne résultante de l'intanciation devrait être une référence URI. Ce n'est pasune erreur si la chaîne n'est pas une référence URI syntaxiquement correcte. Si c'est une chaîne vide, alors le nom étendu de l'attribut à créer a une URI d'espace de noms nulle. Sinon, la chaîne de caractères est utilisée comme URI espace de noms du nom étendu de l'attribut à créer. La partie locale de  QName specifiée par l'attribut name est utilisée comme partie locale du nom étendu  de l'attribut à créer.

Les processeurs XSLT peuvent utilser le préfixe du QName specifié dans l'attribut name au moment de choisir le préfixe utilisé pour produire l'attribut créer en XML ; par contre, ils ne sont pas obligés de le faire et, si le préfix est xmlns, ils ne faut pas le faire. Par conséquent, ce n'est pas une erreur que d'écrire :

<xsl:attribute name="xmlns:xsl" namespace="whatever">http://www.w3.org/1999/XSL/Transform</xsl:attribute>

le résultat ne sera pas la déclaration d'un espace de noms.

En ajoutant un attribut à un élément remplace l'attribut existant de cet élément avec le même nom étendu.

Les opération suivantes sont des erreurs:

NOTE: Quand  un xsl:attribute contient un noeud de texte avec un saut de ligne, alors la sortie XML doit contenir une référence de caractère. Par exemple,

<xsl:attribute name="a">x
y</xsl:attribute>

donnera comme résultat :

a="x&#xA;y"

(ou tout autre référence de caractère équivalente). La sortie XML peut être

a="x
y"

C'est parceque XML 1.0 demande que les retours à la ligne dans les valeurs d'attributs soient traités comme des espaces, mais ne l'exige pas des références de caractère de retour à la ligne. Les valeurs d'attributs du modèle de données représentent la valeur de l'attribut après normalisation. Si un retour à la ligne se trouvant dans une valeur d'attribut de l'arbre était sorti comme un caractère de retour à la ligne plutôt que comme une référence de caractère, alors la valeur de l'attribut dans l'arbre créé en reparsant le fichier XML contiendrait un espace et nom un saut de ligne, ce qui signifirait que l'arbre n'a pas été produit correctement.

7.1.4 Ensembles d'attributs nommés

<!-- Category: top-level-element -->
<xsl:attribute-set
  name = qname
  use-attribute-sets = qnames>
  <!-- Content: xsl:attribute* -->
</xsl:attribute-set>

L'élément xsl:attribute-set défini un ensemble d'attributs nommés.L'attribut name spécifie le nom de l'ensemble d'attributs. La valeur de l'attribut name est un QName, qui est expansé comme décrit dans  [2.4 Noms qualifiés]. Le contenu de l'élément xsl:attribute-set consiste en zéro ou plus éléments xsl:attribute spécifiant les attributs de l'ensemble.

Les ensembles d'attributs sont utilisés en spécifiant un attribut use-attribute-sets  sur les éléments xsl:element, xsl:copy (voir [7.5 Copier]) ou xsl:attribute-set. La valeur de l'attribut use-attribute-sets est une liste de noms d'ensemble d'attributs séparés par des espaces. Chaque nom est spécifié comme étant un QName, lequel s'expand comme décrit dans [2.4 Noms qualifiés]. Spécifier un attribut use-attribute-sets est équivalent à ajouter des éléments xsl:attribute à chaque attribut de chacun des ensembles d'attributs nommés au début du contenu de l'élément ayant l'attribut use-attribute-sets, dans le même ordre que celui avec lequel les noms des ensembles d'attributs sont spécifiés dans l'attribut use-attribute-sets. C'est une erreur si l'utilisation des attributs use-attribute-sets avec des éléments xsl:attribute-set fait qu'un ensemble d'attribut s'utilise lui-même directement ou indirectement.

Les ensembles d'attributs peuvent être utilisés en spécifiant l'attribut xsl:use-attribute-sets dans un élément résultat littéral. La valeur de l'attribut xsl:use-attribute-sets est une liste de noms d'ensembles d'attributs séparés par un espace. L'attribut xsl:use-attribute-sets a le même effet que l'attribut use-attribute-sets de xsl:element mais avec une règle supplémentaire qui spécifie que les attribues de l'élément résultat littéral lui-même sont traités comme s'ils étaient spécifiés par des éléments xsl:attribute avant tout élément xsl:attribute courant mais après tout élément xsl:attribute induit par l'attribut xsl:use-attribute-sets. Alors, pour un élément résulat littéral, les attributs d'un ensemble d'attributs nommé dans un attribut xsl:use-attribute-sets sera ajouté en premier, dans l'odre listé dans l'attribut ; puis, les attributs spécifiés sur un élément résutat littéral seront ajoutés ; finalement, tout attribut spécifié par l'élément xsl:attribute seront ajoutés. Puisque le fait de rajouter un attribut à un élément provoque le remplacement de tout attribut de même nom déjà existant sur l'élément, cela signifie que les attributs spécifiés dans les ensembles d'attributs peuvent être écrasés par les attributs spécifiés sur l'élément résultat littéral lui-même.

Le modèle contenu à l'intérieur de chaque élément  xsl:attribute d'un élément xsl:attribute-set est instancié chaque fois que l'ensemble d'attributs est utilisé ; Il est instancié en utilisant le même noeud courrant et la même liste de moeuds qui ceux utilisés pour instancier un élément supportant l'attribut use-attribute-sets ou xsl:use-attribute-sets. Cependant, c'est la position dans la feuille de style de l'élément xsl:attribute plutôt que l'élément supportant l'attribut use-attribute-sets ou xsl:use-attribute-sets qui détermine quelles sont les associations de variables visibles (voir [11 Variables et paramètres]); Donc, seuls les variables et paramètres déclarés par  les éléments top-level xsl:variable et xsl:param sont visibles

L'exemple suivant crée un ensemble d'attributs title-style et l'utilise dans une règle modèle.

<xsl:template match="chapter/heading">
  <fo:block quadding="start" xsl:use-attribute-sets="title-style">
    <xsl:apply-templates/>
  </fo:block>
</xsl:template>
<xsl:attribute-set name="title-style">
  <xsl:attributename="font-size">12pt</xsl:attribute>
  <xsl:attribute name="font-weight">bold</xsl:attribute>
</xsl:attribute-set>

Des définitions multiples d'un ensemble d'attributs ayant le même nom étendu sont fusionnées. Un attribut d'une définition qui possède une préséance d'import plus élevée passe avant l'attribut d'une définition qui en aurait une plus faible. C'est une erreur quand il y a deux ensembles d'attributs ayant un même nom étendu et une même préséance d'import et que les deux contiennent le même attribut, à moins que ne soit précisé une définition de l'ensemble d'attribut qui confère à l'un d'eux une plus haute préséance d'import Un processeur XSLT peut signaler l'erreur, si il ne le fait pas, il doit rattraper l'erreur en choisissant parmi les définittions qui spécifient l'attribut que celle qui a la plus haute préséance d'import est la dernière à avoir été spécifiée dans la feuille de style. L'emplacement où les attributs d'un ensemble d'attributs sont spécifiés est significatif uniquement en fusionnant les attributs dans un ensemble d'attributs ; cela ne fait aucune différence de savoir quand l'ensemble d'attributs est utilisé .

7.2 Créer du texte

Un modèle peut aussi contenir des noeuds textuels. Chaque noeud textuel du modèle restant après que les espaces blancs aient été filtrés conformément à ce qui est spécifié au chapitre [3.4 Suppression d'espaces] créera un noeud textuel de même valeur textuelle dans l'arbre résultant. Les noeuds textuels adjacents d'un arbre résultat seront automatiquement fusionnés.

Noter que le texte est traité au niveau de l'arbre. Donc, le balisage de &lt; dans le modèle sera représenté dans l'arbre de la feuille de style par un noeud textuel incluant le caractère <. Cela créera un noeud textuel dans l'arbre résultat qui contiendra  <, lequel sera représenté par l'entité &lt; (ou une référence de caractère équivalente) quand l'arbre résultat est mis sous la forme d'un document XML (à moins que la méthode de sortie XML soit désactivée comme décrit dans [16.4 Désactivation de la production littérale des caractères en sortie]).

<!-- Category: instruction -->
<xsl:text
  disable-output-escaping = "yes" | "no">
  <!-- Content: #PCDATA -->
</xsl:text>

Les caractères de données littérales peuvent être enveloppés dans un élément xsl:text. L'enveloppement des ces caractères peut changer la façon dont est géré le filtrage des caractères d'espacement (voir [3.4 Suppression d'espaces]) mais n'affecte pas la façon dont sont gérés les caractères par le processeur XSLT après cela.

NOTE:  Les attributs xml:lang et xml:space ne sont pas traités de manière particulière par XSLT. En particulier, il est de la reponsabilité de l'auteur de la feuille de style que de mettre tous les attributs xml:lang ou xml:space nécessaires dans le résultat; spécifier un attribut  xml:lang ou xml:space sur un élément de l'espace de noms XSLT ne provoquera pas l'affichage des ces attributs.

7.3 Créer des instructions de traitement

<!-- Category: instruction -->
<xsl:processing-instruction
  name = { ncname }>
  <!-- Content: template -->
</xsl:processing-instruction>

L'élément xsl:processing-instruction sert à créer un noeud instruction de traitement . Le contenu de l'élément xsl:processing-instruction sert de modèle pour la valeur textuelle du noeud intruction de traitement. L'élément xsl:processing-instruction possède un attribut obligatoire name qui spécifie le nom du noeud instruction de traitement. La valeur de l'attribut  name est interprétée comme une valeur d'attribut modèle.

Par exemple;

<xsl:processing-instruction name="xml-stylesheet">href="book.css" type="text/css"</xsl:processing-instruction>

créera l'instruction de traitement

<?xml-stylesheet href="book.css" type="text/css"?>

Ce n'est pas une erreur quand le résultat de l'intanciation n'est ni un NCName ni un PITarget. Un processeur XSLT peut signaler l'erreur ; si il ne le fait pas, il doit la rattraper en supprimant l'instruction de traitement de l'arbre résultant.

NOTE: Cela signifie que l'élément  xsl:processing-instruction ne peut pas être utilisé pour produire une déclaration XML. L'élément xsl:output devra être utilisé à la place (voir [16 Sorties]).

C'est une erreur quand l'intanciation du contenu de xsl:processing-instruction crée un noeud autre qu'un noeud textuel. Un processeur XSLT peut signaler l'erreur mais si il ne le fait pas, il doit ignorer les noeuds posant problème ainsi que leur contenu.
C'est une erreur si l'intanciation du contenu de xsl:processing-instruction contient  la chaîne ?>. Un processeur XSLT peut signaler l'erreur ; si il ne le fait pas, il doit rattraper l'erreur en insérant un espace après toute occurence de ? qui est suivie par un >.

7.4 Créer des commentaires

<!-- Category: instruction -->
<xsl:comment>
  <!-- Content: template -->
</xsl:comment>

L'élément commentaire xsl:comment sert à créer un noeud commentaire dans l'abre résultant. Le contenu de l'élément xsl:comment sert de modèle pour la valeur textuelle du noeud commentaire.

Par exemple :

<xsl:comment>This file is automatically generated. Do not edit!</xsl:comment>

Créera ce commentaire :

<!--This file is automatically generated. Do not edit!-->

C'est une erreur si l'instanciation du contenu de xsl:comment crée des noeuds autres que des noeuds textuels. Un processeur XSLT  peut signaler l'erreur, si'l ne le fait pas, il doit la rattraper en ignorant le noeud posant problème ainsi que son contenu.

C'est une erreur si le contenu résultant de l'instanciation de xsl:comment contient la chaîne -- ou si elle finit par -. Un processeur XSLT peut signaler l'erreur ; si il ne le fait pas, il doit rattraper l'erreur en insérant un espace après toute occurence de - suivie d'un autre carcatère - ou qui se trouve être à la fin du commmentaire.

7.5 Copier

<!-- Catégorie : instruction -->
  <xsl:copy
      use-attribute-sets = qnames>
      <!-- Content: template -->
  </xsl:copy>

L'élément xsl:copy fournit un moyen simple pour copier le noeud courant. L'instanciation de l'élément xsl:copy crée une copie du noeud courant. Les noeuds espace de noms du noeud courant sont également copiés automatiquement, mais les attributs et les enfants du noeud ne sont pas copiés automatiquement. Le contenu de l'élément xsl:copy est le modèle des attributs et enfants à créer sur le noeud résultant ; le contenu est instancié uniquement pour les noeuds dont le type leur permet d'avoir des attributs ou des enfants (par exmple les noeuds racines et les noeuds d'éléments).

L'élément xsl:copy peut recevoir l'attribut use-attribute-sets (voir [7.1.4 Les ensembles d'attributs nommés]). Cela n'est utilisé que pour la copie de noeuds éléments.

Le noeud racine est un cas particulier parce que le noeud racine de l'arbre résultat est créé implicitement. Quand le noeud courant est le noeud racine, xsl:copy ne créera pas un noeud racine, seul son modèle de contenu sera utilisé.

Par exemple, la transformation identité peut être écrite en utilisant xsl:copy comme suit:

<xsl:template match="@*|node()">
  <xsl:copy>
    <xsl:apply-templates select="@*|node()"/>
  </xsl:copy>
</xsl:template>

Quand le noeud courant est un attribut, c'est une erreur que d'utiliser xsl:attribute pour créer un attribut du même nom que le noeud courant, il en est également de même avec xsl:copy (voir [7.1.3 Créer des attributs avec xsl:attribute]).

L'exemple suivant montre comment l'attribut xml:lang peut être facilement copié de l'arbre source à l'arbre résultat. Si une feuille de style définit le modèle nommé suivant :

<xsl:template name="apply-templates-copy-lang">
 <xsl:for-each select="@xml:lang">
   <xsl:copy/>
 </xsl:for-each>
 <xsl:apply-templates/>
</xsl:template>

Alors, il est possible d'utiliser simplement :

<xsl:call-template name="apply-templates-copy-lang"/>

au lieu de :

<xsl:apply-templates/>

quand il est nécessaire de copier l'attribut xml:lang.

7.6 Calculer le texte généré

A l'intérieur d'un modèle, l'élément xsl:value-of peut être utilisé pour calculer le texte généré, par exemple en extrayant du texte de l'arbre source ou en insérant le contenu d'une variable. L'élément xsl:value-of permet de faire cela par utilisation d'une expression spécifiée comme étant la valeur de l'attribut select. Les expressions peuvent également être utilisées à l'intérieur de valeurs d'attributs d'éléments résultats littéraux en entourant l'expression d'accolades ({}).

7.6.1 Générer du texte avec xsl:value-of

<!-- Catégorie : instruction -->
<xsl:value-of
  select = string-expression
  disable-output-escaping = "yes" | "no" />

L'élément xsl:value-of est instancié pour créer un noeud textuel de l'arbre résultant. L'attribut obligatoire select est une expression ; cette expression est évaluée et l'objet résultant est converti en une chaîne de caractères comme l'aurait fait la fonction string. La chaîne de caractères spécifie la valeur textuelle du noeud textuel créé. Si la chaîne est vide, le noeud textuel ne sera pas créé. Le noeud textuel créé sera fusionné avec tout autre noeud textuel adjacent.

L'élément xsl:copy-of peut être utilisé pour copier un ensemble de noeuds vers l'arbre résultat sans les convertir en chaîne. Voir [11.3 Utiliser des valeurs de variables et de paramètres avec xsl:copy-of ].

Par exemple, les déclarations suivantes créent un paragraphe HTML à partir de l'élément person et de ses attributs given-name et family-name. Le paragraphe contiendra la valeur de l'attribut given-name du noeud courant suivie d'un espace et de la valeur de l'attribut family-name du noeud courant.

<xsl:template match="person">
  <p>
   <xsl:value-of select="@given-name"/>
   <xsl:text>
</xsl:text>
  <xsl:value-of select="@family-name"/>
  </p>
</xsl:template>

Dans cet autre exemple, un paragraphe HTML est créé à partir de l'élément person et des ses éléments enfants given-name et family-name. Le paragraphe contiendra la valeur textuelle du premier élément enfant given-name suivie d'un espace et de la valeur textuelle de l'élément family-name.

<xsl:template match="person">
  <p>
   <xsl:value-of select="given-name"/>
   <xsl:text> </xsl:text>
   <xsl:value-of select="family-name"/>
  </p>
</xsl:template>

Le code suivant crée avant chaque élément procedure un paragraphe contenant le niveau de sécurité de la procédure. Il garantit que le niveau de sécurité qui s'applique à une procédure est déterminé par l'attribut security de l'élément procedure ou de l'un de ses ancêtres. Il garantit également que si plus d'un élément a un attribut security alors le niveau de sécurité est déterminé par l'élément qui est le plus près de l'élément procedure.

<xsl:template match="procedure">
  <fo:block>
    <xsl:value-of select="ancestor-or-self::*[@security][1]/@security"/>
  </fo:block>
  <xsl:apply-templates/>
</xsl:template>

7.6.2 Modèles de valeurs d'attributs

Dans une valeur d'attribut qui est interprétée comme modèle de valeur d'attribut, comme par exemple une valeur d'attribut d'un élément résultat, une expression peut être utilisée à condition de l'encadrer par des accolades ({}). Le modèle de valeur d'attribut est instancié en remplaçant l'expression et les accolades qui la délimitent par le résultat de l'évaluation de l'expression et la conversion de ce résultat en chaîne de caractères à l'identique de la fonction string. Les accolades ne sont pas reconnues dans une valeur d'attribut d'une feuille de styles XSLT à moins que l'attribut n'ait été spécialement déclaré comme étant un modèle de valeur d'attribut ; dans la syntaxe résumée des éléments, la valeur de tels attributs est présentée entre accolades.

NOTE : Tous les attributs ne sont pas interprétés comme des modèles. Les attributs dont la valeur est une expression ou un motif, les attributs d'éléments de haut niveau et les attributs qui font références à des objets XSLT nommés ne sont pas interprétés comme des modèles de valeurs d'attributs. De plus, les attributs xmlns ne sont pas interprétés comme des modèles de valeurs d'attributs ; Il ne serait pas conforme à la Recommandation XML des Espaces de Noms de le faire.

L'exemple suivant crée un élément résultat img à partir de l'élément source photograph ; la valeur de l'attribut src de l'élément img est calculée à partir de la valeur de la variable image-dir et de la valeur textuelle de l'enfant href de l'élément photograph ; la valeur de l'attribut width de l'élément img est calculée à partir de la valeur de l'attribut width de l'enfant size de l'élément photograph :

<xsl:variable name="image-dir">/images</xsl:variable>
<xsl:template match="photograph">
<img src="{$image-dir}/{href}" width="{size/@width}"/>
</xsl:template>

Avec le source :

<photograph>
  <href>headquarters.jpg</href>
  <size width="300"/>
</photograph>

Le résultat serait :

<img src="/images/headquarters.jpg" width="300"/>

Quand un modèle de valeur d'attribut est instancié, la présence d'une accolade double (droite ou gauche) en dehors d'une expression entraînera la production d'une accolade simple (droite ou gauche). Quand une accolade droite simple apparaît dans un modèle d'attribut à l'extérieur d'une expression, c'est une erreur. Une accolade droite à l'intérieur d'un Littéral d'une expression n'est pas reconnue comme terminant l'expression.

Les accolades ne sont pas reconnues récursivement à l'intérieur des expressions. Par exemple :

<a href="#{id({@ref})/title}">

n'est pas autorisée. A la place, utiliser simplement :

<a href="#{id(@ref)/title}">

7.7 Calculer

<!-- Catégorie : instruction -->
<xsl:number
  level = "single" | "multiple" | "any"
  count = pattern
  from = pattern
  value = number-expression
  format = { string }
  lang = { nmtoken }
  letter-value = { "alphabetic" | "traditional" }
  grouping-separator = { char }
  grouping-size = { number } />

L'élément xsl:number est utilisé pour produire un nombre formaté dans l'arbre résultat. Le nombre à insérer peut être spécifié par une expression. L'attribut value contient une expression. L'expression est évaluée et l'objet résultant est converti en un nombre comme avec la fonction number. Le nombre est arrondi à un entier puis converti en chaîne de caractères en utilisant les attributs spécifiés au chapitre [7.7.1 Attributs de conversion de nombres en chaînes de caractères] ; dans ce contexte, la valeur de chacun de ces attributs est interprétée comme un modèle de valeur d'attribut. Au terme de la conversion, la chaîne résultante est insérée dans l'arbre résultant. Par exemple, l'exemple suivant numérote une liste triée :

<xsl:template match="items">
  <xsl:for-each select="item">
    <xsl:sort select="."/>
    <p>
      <xsl:number value="position()" format="1. "/>
      <xsl:value-of select="."/>
    </p>
  </xsl:for-each>
</xsl:template>

Si aucun attribut value n'est spécifié, alors l'élément xsl:number insère un nombre basé sur la position du noeud courant dans l'arbre source. Les attributs suivants contrôlent la manière dont le noeud courant doit être numéroté :

L'attribut level spécifie les niveaux de l'arbre source qui doivent être considérés ; les valeurs possibles sont single, multiple ou any. La valeur par défaut est single.

L'attribut count est un motif qui spécifie les noeuds à comptabiliser dans les niveaux spécifiés. Si l'attribut count n'est pas spécifié, alors sa valeur par défaut est le motif qui correspond à tous les noeuds de même type que le noeud courant et, si le noeud courant a un nom expansé, ayant le même nom expansé que le noeud courant.

L'attribut from est un motif qui spécifie où commence l'énumération.

De plus, les attributs décrits au chapitre [7.7.1 Attributs de conversion de nombres en chaînes de caractères] sont utilisés dans les conversions de nombres en chaînes de caractères, comme lorsque l'attribut value est spécifié.

L'élément xsl:number commence par construire une liste d'entiers positifs en utilisant les attributs level, count et from selon les règles suivantes :

Quand level="single", le premier des ancêtres dans l'axe ancêtre-ou-réflexif (ancestor-or-self) correspondant au motif spécifié par l'attribut count est recherché puis une liste contenant cet ancêtre et tous ses prédécesseurs correspondant eux-mêmes au motif précisé par l'attribut count est construite. Si le premier ancêtre n'existe pas, la liste construite est vide. Si l'attribut from est spécifié, alors, les seuls ancêtres recherchés sont ceux qui sont des descendants de l'ancêtre le plus proche correspondant au motif from. Les prédécesseurs ont ici la même signification que dans l'axe des prédécesseurs (preceding-sibling axis).

Quand level="multiple", une liste de tous les ancêtres du noeud courant dans l'ordre du document est construite terminée par le noeud courant lui-même; ensuite, les noeuds correspondant au motif count sont extraits de cette liste et chacun d'eux provoque la création d'une liste composée du noeud et de l'ensemble de ses prédécesseurs correspondant au motif count. Si l'attribut from est spécifié, alors les seuls ancêtres à être recherchés sont ceux qui sont des descendants de l'ancêtre le plus proche correspondant au motif from. Les prédécesseurs ont ici la même signification que dans l'axe des prédécesseurs (preceding-sibling axis).

Quand level="any", une liste à un élément est constituée contenant le nombre de noeuds qui correspondent au motif count et appartiennent à l'ensemble formé du noeud courant et de tous les noeuds du document, quel que soit leur niveau, qui se trouvent avant le noeud courant dans l'ordre du document, à l'exclusion des noeuds d'espace de noms et d'attribut (en d'autres termes, il s'agit de l'union des membres des axes prédécesseurs (preceding) et ancêtres-ou-réflexif (ancestor-or-self). Si l'attribut from est spécifié, alors seuls les noeuds qui se trouvent après le premier noeud précédant le noeud courant et correspondant au motif from sont pris en considération.

La liste des nombres est ensuite convertie en une chaîne de caractères en utilisant les attributs décrits au chapitre [7.7.1 Attributs de conversion de nombres en chaînes de caractères] ;dans ce contexte, la valeur de chacun de ces attributs est interprétée comme un modèle de valeur d'attribut. Après conversion, la chaîne de caractères résultante est insérée dans l'arbre résultat.

Les lignes suivantes calculent le nombre d'items d'une liste ordonnée :

<xsl:template match="ol/item">
  <fo:block>
    <xsl:number/>
    <xsl:text>. </xsl:text>
    <xsl:apply-templates/>
  </fo:block>
<xsl:template>

Les deux règles suivantes calculent le nombre d'éléments title. Cela s'entend pour un document contenant une série de chapitres suivis par une série d'annexes, où les chapitres ainsi que les annexes contiennent des sections, qui, à leur tour, contiennent des sous-sections. Les chapitres sont numérotés 1, 2, 3; les annexes sont numérotées A, B, C; les sections des chapitres sont numérotées 1.1, 1.2, 1.3; les sections des annexes sont numérotées A.1, A.2, A.3.

<xsl:template match="title">
  <fo:block>
     <xsl:number level="multiple"
                 count="chapter|section|subsection"
                 format="1.1 "/>
     <xsl:apply-templates/>
  </fo:block>
</xsl:template>
<xsl:template match="appendix//title" priority="1">
  <fo:block>
     <xsl:number level="multiple"
                 count="appendix|section|subsection"
                 format="A.1 "/>
     <xsl:apply-templates/>
  </fo:block>
</xsl:template>

L'exemple suivant numérote séquentiellement les notes d'un chapitre :

<xsl:template match="note">
  <fo:block>
     <xsl:number level="any" from="chapter" format="(1) "/>
     <xsl:apply-templates/>
  </fo:block>
</xsl:template>

L'exemple suivant numérote les éléments HTML H4 avec un préfixe composé de 3 parties :

<xsl:template match="H4">
 <fo:block>
   <xsl:number level="any" from="H1" count="H2"/>
   <xsl:text>.</xsl:text>
   <xsl:number level="any" from="H2" count="H3"/>
   <xsl:text>.</xsl:text>
   <xsl:number level="any" from="H3" count="H4"/>
   <xsl:text> </xsl:text>
   <xsl:apply-templates/>
 </fo:block>
</xsl:template>

7.7.1 Attributs de conversion de nombres en chaînes de caractères

Les attributs suivants sont utilisés pour contrôler la conversion d'une liste de nombre en une chaîne de caractères. Les nombres sont des entiers supérieurs à 0. Les attributs sont tous optionnels.

L'attribut principal est format. La valeur par défaut de l'attribut format est 1. La valeur de l'attribut format est découpée en une séquence de marques dont chacune est soit la séquence la plus longue possible de caractères alphanumériques soit la séquence la plus longue possible de caractère non-alphanumériques. Alphanumérique se rapporte aux caractères dont la catégorie Unicode est de type Nd, Nl, No, Lu, Ll, Lt, Lm ou Lo. Les marques alphanumériques (marques de formatage) spécifient le format à utiliser pour chaque nombre de la liste. Si la première marque n'est pas alphanumérique, alors la chaîne de caractères construite commencera avec cette marque; si la dernière marque n'est pas alphanumérique, alors la chaîne de caractères produite finira par cette marque. Les marques non-alphanumérique qui interviennent entre 2 marques de formatage sont des séparateurs qui sont utilisés pour joindre les nombres de la liste. La marque de formatage nth est utilisée pour formatter le n-ième nombre de la liste. S'il y a plus de nombre que de marques de formatage, alors la dernière marque de formatage sera utilisée pour formatter les nombres restants. S'il n'y a pas de marque de formatage, alors la marque de formatage valant 1 est utilisée pour formatter tous les nombres de la liste. La marque de formatage spécifie la chaîne de caractères à utiliser pour représenter le nombre 1. Chaque nombre après le premier sera séparé de son prédécesseur par le séparateur précédent la marque de formatage utilisée pour formatter ce nombre, ou, s'il n'y a pas de séparateur, par un . (le caractère point).

Les marques de formatage sont un sur ensemble des valeurs autorisées de l'attribut type de l'élément OL de HTML 4.0 et qui sont interprétées comme suit :

Toute marque de formatage composée du caractère dont la représentation numérique est 1 (tel que spécifié dans la base de propriétés des caractères Unicode), lui-même précédé de caractères dont la valeur Unicode lui est inférieure de 1 (typiquement le caractère zéro : 0) génère une représentation des nombres dans laquelle chaque nombre a une longueur au moins égale à celle de la marque de formatage. Aussi, la marque de formatage 1 génère la séquence 1 2 ... 10 11 12 ..., et la marque de formatage 01 génère la séquence 01 02 ... 09 10 11 12 ... 99 100 101.

Une marque de formatage A produit la séquence A B C ... Z AA AB AC....

Une marque de formatage a produit la séquence a b c ... z aa ab ac....

Une marque de formatage i produit la séquence i ii iii iv v vi vii viii ix x ....

Une marque de formatage I produit la séquence I II III IV V VI VII VIII IX X ....

Toute autre marque de formatage indique une séquence de numérotation qui commence par cette marque. Si une implémentation ne supporte pas une numérotation qui commençerait par cette marque, elle doit alors lui substituer la marque 1.

Quand on numérote avec une séquence alphabétique, l'attribut lang spécifie quel alphabet de langue doit être utilisé; il a la même gamme de valeurs que xml:lang[XML]; si aucune valeur lang n'est spécifiée, la langage doit être déterminé de l'environnement système. Les développeurs de logiciels doivent documenter les langages supportés par leur implémentation de la numérotation.

NOTE : les développeurs de logiciels ne doivent faire aucune supposition concernant la manière dont la numérotation fonctionne dans des cas particuliers de langages et doivent correctement étudier les langages qu'ils se proposent de supporter. Les conventions de numérotations étant différentes de l'anglais dans de nombreux langages.

L'attribut letter-value permet de lever les ambiguïtés concernant les séquences de numérotation reposant sur des lettres. Dans de nombreux langages, il y a deux séquences communément utilisées de numérotations à base de lettres. L'une attribue des valeurs numériques aux lettres ordonnées selon l'alphabet, et l'autre attribue des valeurs numériques aux lettres selon d'autres critères traditionnels propre au langage. En anglais, cela correspondrait aux règles de numérotation a et i. Dans d'autres langages, le premier membre de chaque séquence est le même, faisant que la seule marque de formatage serait ambïgue. La valeur alphabetic permet de spécifier qu'il s'agit d'une séquence alphabétique; La valeur traditional permet de préciser une autre séquence. Si l'attribut letter-value n'est pas précisé, alors la levée de l'ambiguïté dépend de l'implémentation.

NOTE : Il est possible que deux processeurs XSLT conformes ne convertissent pas tout à fait un même nombre en une chaîne de caractères strictement identique. Il se peut que des processeurs XSLT ne supportent pas certains lanagages. De plus, il peut y avoir des variations dans la manière dont les conversions sont effectuées pour des langages spécifiques qui ne soient pas contrôlables par les attributs de xsl:number. Les futures versions de XSLT pourront fournir des attributs additionnels pour pouvoir contrôler ces variations. Les implémentations peuvent également utiliser sur l'élément xsl:number des attributs issus d'espaces de noms spécifiques à l'implémentation.

L'attribut grouping-separator donne le séparateur utilisé comme séparateur de groupes (par exemple les milliers) des séquences numériques, et l'attribut optionnel grouping-size spécifie la taille (habituellement 3) du regrouppement. Par exmple, grouping-separator="," et grouping-size="3" produiraient des nombres de la forme 1,000,000. Si un seul des deux attributs grouping-separator et grouping-size est spécifié, alors il est ignoré.

Voici quelques exemples de spécifications de conversion :

format="&#x30A2;" spécifie une numérotation en Katakana

format="&#x30A4;" spécifie une numérotation Katakana dans l'ordre "iroha"

format="&#x0E51;" spécifie une numérotation en chiffres Thai

format="&#x05D0;" letter-value="traditional" spécifie une numérotation traditionnelle en Hébreu

format="&#x10D0;" letter-value="traditional" spécifie une numérotation en Géorgien

format="&#x03B1;" letter-value="traditional" spécifie une numérotation en Grec "classique"

format="&#x0430;" letter-value="traditional" spécifie une numérotation en vieux Slave

8 Répétition

<!-- Category: instruction -->

<xsl:for-each
  select = node-set-expression>
  <!-- Content: (xsl:sort*, template) -->
</xsl:for-each>

Il est utile de pouvoir spécifier directement le modèle pour les noeuds sélectionnés lorsque le résultat est une structure régulière connue. L'instruction xsl:for-each contient un modèle qui est instancié pour chaque noeud sélectionné par l'expression spécifiée en tant que valeur de l'attribut select. L'attribut select est obligatoire. Le résultat de l'évaluation de l'expression doit être un ensemble de noeuds. Le modèle est instancié avec le noeud sélectionné identifié comme le noeud courant, et avec la liste de tous les noeuds sélectionnés identifiée comme la liste courante de noeuds. À moins qu'une spécification d'ordre ne soit présente, les noeuds sont traités dans l'ordre induit par le document (voir [10 Tri]).

Par exemple, Considérons un document XML avec la structure suivante :

<customers>
  <customer>
    <name>...</name>
    <order>...</order>
    <order>...</order>
  </customer>
  <customer>
    <name>...</name>
    <order>...</order>
    <order>...</order>
  </customer>
</customers>

ce qui suit permet de créer un document HTML contenant une table contenant une ligne pour chaque élément customer

<xsl:template match="/">
  <html>
    <head>
      <title>Customers</title>
    </head>
    <body>
      <table>
        <tbody>
          <xsl:for-each select="customers/customer">
            <tr>
              <th>
                <xsl:apply-templates select="name"/>
              </th>
              <xsl:for-each select="order">
                <td>
                  <xsl:apply-templates/>
                </td>
              </xsl:for-each>
            </tr>
          </xsl:for-each>
        </tbody>
      </table>
    </body>
  </html>
</xsl:template>

9 Traitement conditionnel

XSLT propose deux instructions qui pemettent le traitement conditionnel dans un modèle : xsl:if et xsl:choose . L'instruction xsl:if sert à exprimer la condition simple si-alors ; L'instruction xsl:choose permet quant à elle un choix parmi plusieurs possibilités.

9.1 Traitement conditionnel par xsl:if

<!-- Category: instruction -->


<xsl:if
  test = boolean-expression>
  <!-- Content: template -->
</xsl:if>

L'élément xsl:if a un attribut test qui spécifie une expression. Le contenu est un modèle. Après évaluation de l'expression, le résultat est converti en booléen comme si elle avait été évaluée par la fonction boolean. Si le résultat est vrai alors le contenu du modèle est instancié, sinon rien n'est créé . Dans l'exemple suivant, les noms dans un groupe de noms sont formatés sous la forme d'une liste de noms séparés par des virgules :

<xsl:template match="namelist/name">
  <xsl:apply-templates/>
  <xsl:if test="not(position()=last())">, </xsl:if>
</xsl:template>

L'exemple suivant colore en jaune une ligne de tableau sur 2 (les lignes de rang pair) :

<xsl:template match="item">
  <tr>
    <xsl:if test="position() mod 2 = 0">
       <xsl:attribute name="bgcolor">yellow</xsl:attribute>
    </xsl:if>
    <xsl:apply-templates/>
  </tr>
</xsl:template>

9.2 Traitement conditionnel par xsl:choose

<!-- Category: instruction -->


<xsl:choose>
  <!-- Content: (xsl:when+, xsl:otherwise?) -->
</xsl:choose>

<xsl:when
  test = boolean-expression>
  <!-- Content: template -->
</xsl:when>

<xsl:otherwise>
  <!-- Content: template -->
</xsl:otherwise>

L'élément xsl:choose permet de faire un choix parmi plusieurs alternatives. Il consiste en une séquence d'éléments xsl:when suivis par un élément xsl:otherwise optionnel. Chacun des éléments xsl:when possède un attribut test unique qui spécifie une expression. Le contenu des éléments xsl:when et xsl:otherwise est un modèle. Le traitement d'une instruction xsl:choose, consiste à tester à tour de rôle chacun des éléments xsl:when en évaluant l'expression et en convertissant l'objet résultant en un booléen comme si'il avait été évalué par la fonction l'exécution de la fonction boolean. Seul le contenu du premier élément xsl:when évalulé à vrai est instancié. Si aucun des éléments xsl:when n'est évalué à vrai, c'est le contenu de l'élément xsl:otherwise qui est instancié. Si aucun des éléments xsl:when n'est évalué à vrai et qu'il n'y a pas d'élément xsl:otherwise alors rien n'est créé.

L'exemple suivant énumère des items d'une liste ordonnée en utilisant les chiffres arabes, les lettres et les chiffres romains en fonction de la profondeur d'imbrication des listes.

<xsl:template match="orderedlist/listitem">
  <fo:list-item indent-start='2pi'>
    <fo:list-item-label>
      <xsl:variable name="level"
                    select="count(ancestor::orderedlist) mod 3"/>
      <xsl:choose>
        <xsl:when test='$level=1'>
          <xsl:number format="i"/>
        </xsl:when>
        <xsl:when test='$level=2'>
          <xsl:number format="a"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:number format="1"/>
        </xsl:otherwise>
      </xsl:choose>
      <xsl:text>. </xsl:text>
    </fo:list-item-label>
    <fo:list-item-body>
      <xsl:apply-templates/>
    </fo:list-item-body>
  </fo:list-item>
</xsl:template>

10 tri

<xsl:sort
  select = string-expression
  lang = { nmtoken }
  data-type = { "text" | "number" | qname-but-not-ncname }
  order = { "ascending" | "descending" }
  case-order = { "upper-first" | "lower-first" } />

Le tri est spécifié en ajoutant des éléments xsl:sort comme fils d'un élément xsl:apply-templates ou d'un élément xsl:for-each. Le premier fils xsl:sort spécifie la clé primaire de tri, le deuxième fils xsl:sort spécifie la clé de tri secondaire et ainsi de suite. Lorsqu'un élément xsl:apply-templates ou un élément xsl:for-each a un un ou plusieurs fils xsl:sort, au lieu de traiter les noeuds sélectionnés dans l'ordre où ils apparaissent dans le document, ces derniers sont triés en fonction des clés de tri spécifiés et traités dans l'ordre induit par ce tri. Lorsque des éléments xsl:sort sont utilisés dans xsl:for-each, ils doivent apparaître en premier. Lorsqu'un modèle est instancié par xsl:apply-templates et xsl:for-each, la liste de noeuds courante consiste en la liste complète des noeuds en cours de traitement dans l'ordre spécifié par le tri.

xsl:sort possède un attribut select dont la valeur est une expression. Pour chaque noeud à traiter, l'expression est évaluée avec ce noeud pris comme le noeud courant et avec la liste complète non triée des noeuds en cours de traitement prise comme la liste courante de noeuds. L'objet résultant est convertit en une chaîne de caractères comme s'il avait été le résultat de l'éxécution de la fonction string; cette chaîne de caractères résultat est utilisée comme clé de tri pour ce noeud. La valeur par défaut de l'attribut select est le caractère point "." dont l'occurrence induit l'utilisation comme clé de tri de la représentation sous forme de chaîne de caractères, du noeud courant.

Cette chaîne de caractères sert de clé de tri pour le noeud. Les attributs optionnels suivants de xsl:sort contrôlent comment les clés de tri de la liste sont ordonnées; les valeurs de tous ces attributs sont interprétées comme de modèles de valeur d'attribut (attribute value templates).

NOTE: Deux processeurs XSLT conformes peuvent ne pas faire exactement le même tri. Certains processeurs XSLT peuvent ne pas supporter certaines langues. Il peut aussi y avoir des variations possibles lors d'un tri dans n'importe quelle langue particulière qui n'est pas spécifiée par l'attribut de xsl:sort, par exemple, lorsque Hiragana ou Katakana est trié en Japonais dans un premier temps. Les versions de XSLT peuvent fournir des attributs additionnels afin de permettre un contrôle sur ces variations. Pour cela, les réalisations peuvent aussi utiliser des attributs appartenant à des espaces de noms spécifiques à l'implémentation en question pour xsl:sort.

NOTE: Il est recommandé aux développeurs de consulter [UNICODE TR10] pour des informations sur le tri internationalisé.

Le tri doit être stable: dans une liste de noeuds triée, n'importe quel sous-liste ayant des clés de tri égales doit être ordonnée dans l'ordre du document.

Considérons par exemple, une base de données répertoriant des employés et ayant la forme

<employees>
  <employee>
    <name>
      <given>James</given>
      <family>Clark</family>
    </name>
    ...
  </employee>
</employees>

Alors, une liste d'employés triée par le nom peut être générée en utilisant

<xsl:template match="employees">
  <ul>
    <xsl:apply-templates select="employee">
      <xsl:sort select="name/family"/>
      <xsl:sort select="name/given"/>
    </xsl:apply-templates>
  </ul>
</xsl:template>
<xsl:template match="employee">
  <li>
    <xsl:value-of select="name/given"/>
    <xsl:text> </xsl:text>
    <xsl:value-of select="name/family"/>
  </li>
</xsl:template>

11 Variables et Paramètres

<!-- Category: top-level-element -->


<!-- Category: instruction -->
<xsl:variable
  name = qname
  select = expression>
  <!-- Content: template -->
</xsl:variable>

<!-- Category: top-level-element -->
<xsl:param
  name = qname
  select = expression>
  <!-- Content: template -->
</xsl:param>

Une variable est un nom pouvant être rattaché à une valeur. La valeur à laquelle est rattachée la variable (la valeur de la variable) peut être un objet de n'importe quel type que les expressions peuvent retourner. Il y a deux éléments qui peuvent être rattachés à des variables: xsl:variable et xsl:param. La différence est que la valeur spécifiée pour la variable de xsl:param est seulement une valeur de lien par défaut; lorsque le modèle ou la feuille de style dans lequel l'élément xsl:param se produit est invoqué, des paramètres peuvent être passés pour être utilisés à la place des valeurs par défaut.

xsl:variable et xsl:param ont un attribut name obligatoire qui indique le nom de la variable. La valeur de l'attribut name est un QName, qui est étendu comme indiqué dans [2.4 Noms Qualifiés].

Pour toute utilisation de ces éléments de liens de variables, il y a une région dans l'arbre de la feuille de style dans laquelle le lien est visible; tout lien d'une variable, visible dans l'élément de lien, est caché dans cette région. Ainsi, n'est visible que le lien le plus profond d'une variable. L'ensemble de liens d'une variable dans la portée d'une expression consiste en tous les liens qui sont visibles à l'endroit de la feuille de style où l'expression se produit.

11.1 Fragments d'arbre résultat

Les variables introduisent un type de données additionnel dans le langage d'expression. Ce type de données est appelé fragment d'arbre résultat. Une variable peut être liée un fragment d'arbre résultat au lieu d'être liée à l'un des quatre types de base de XPath (string, number, boolean, node-set). Un fragment d'arbre résultat est un fragment de l'arbre résultat. Il est traité de la même manière qu'un ensemble de noeuds contenant uniquement un un simple noeud racine. Les opérations autorisées sur un fragment d'arbre résultat ne sont, cependant, qu'un sous ensemble des opérations permises sur un ensemble de noeuds. Une opération n'est permise sur un fragment d'arbre résultat que si elle pouvait l'être sur une chaîne de caractères (L'opération sur la chaîne de caractères peut entraîner sa conversion en un nombre ou en un booléen en premier lieu). Il n'est particulièrement pas autorisé d'utiliser les opérateurs /, //, et [] sur les fragments d'arbre résultat. L'exécution d'une opération valide sur un fragment d'arbre résultat se déroule de la même manière que si cette opération est exécutée sur un ensemble de noeuds équivalent au fragment d'arbre résultat.

Lors de la copie d'un fragment d'arbre résultat dans l'arbre résultat (voir [11.3 Utilisation des valeurs des variables et des paramètres avec xsl:copy-of ]), tous les noeuds fils du noeud racine de l'ensemble des noeuds équivalent au fragment d'arbre résultat sont ajoutés en séquence à l'arbre résultat.

Les expressions ne peuvent retourner des valeurs de type fragment d'arbre résultat que par des références à des variables de type fragment d'arbre résultat ou en appelant des fonctions d'extension retournant un fragment d'arbre résultat ou récupérant les propriétés système dont les valeurs sont des fragments d'arbre résultat.

11.2 Valeurs des Variables et des Paramètres

Un élément de lien de variable peut spécifier la valeur de la variable selon trois alternatives.

NOTE: Lorsqu'une variable est utilisée pour sélectionner des noeuds par position, éviter de faire:

<xsl:variable name="n">2</xsl:variable>
...
<xsl:value-of select="item[$n]"/>

Cela cause l'affichage du premier élément item, car la variable n sera liée un fragment d'arbre résultat et non à un nombre. Utiliser plutôt

<xsl:variable name="n" select="2"/>
...
<xsl:value-of select="item[$n]"/>

ou

<xsl:variable name="n">2</xsl:variable>
...
<xsl:value-of select="item[position()=$n]"/>

NOTE: Un moyen pratique pour fixer la valeur d'un paramètre à l'ensemble de noeuds vide est :

<xsl:param name="x" select="/.."/>

11.3 Utilisation des valeurs des variables et des paramètres avec xsl:copy-of

<!-- Category: instruction -->


<xsl:copy-of
  select = expression />

L'élément xsl:copy-of, contrairement à xsl:value-of (voir [7.6.1 Generating Text with xsl:value-of ]), peut être utilisé pour insérer un fragment d'arbre résultat dans un arbre résultat, sans avoir à commencer par le convertir en une chaîne de caractères. L'attribut select exigé contient une expression. Lorsque le résultat de l'évaluation de l'expression est fragment d'arbre résultat, alors le fragment complet est copié dans l'arbre résultat. Lorsque le résultat est un ensemble de noeuds, alors tous les noeuds de cet ensemble sont copiés dans l'arbre résultat dans le même ordre où ils apparaissent dans le document; la copie d'un élément noeud copie les noeuds attributs, les noeuds espaces de noms et les enfants de l'élément noeud ainsi que l'élément noeud lui-même; la copie d'un noeud racine se fait par la copie de ses enfants. Si le résultat n'est ni un ensemble de noeuds ni un fragment d'arbre résultat, alors il est doit être convertit en une chaîne de caractères et ensuite inséré dans l'arbre résultat de la même manière qu'avec xsl:value-of .

11.4 Variables et Paramètres de haut niveau

Les éléments xsl:variable et xsl:param sont tous deux autorisés à être utilisés comme éléments de haut niveau (top-level). Un élément lien de variable de haut niveau déclare une variable globale visible partout. Un élément xsl:param de haut niveau déclare un paramètre pour la feuille de style; XSLT ne définit pas le mécanisme permettant de transmettre les paramètres à la feuille de style. Une feuille de style ne peut contenir plus d'un lien à une variable de haut niveau ayant le même nom et la même préséance d'import. Au niveau le plus haut, l'expression ou le modèle spécifiant la valeur d'une variable est évalué dans le même contexte le traitement du noeud racine d'un document source : le noeud courant est le noeud racine du document source et la liste courante de noeuds est une liste contenant uniquement le noeud racine du document source. Si le modèle ou l'expression spécifiant la valeur d'une variable globale x fait référence à une variable globale y, alors la valeur de y doit être calculée avant la valeur de x. S'il était impossible de traiter toutes les variables globales de la sorte alors c'est une erreur; en d'autres termes, si la définition est circulaire alors c'est une erreur.

L'exemple suivant montre la déclaration d'une variable globale para-font-size, qui est référencée dans la valeur d'un attribut modèle.

<xsl:variable name="para-font-size">12pt</xsl:variable>
<xsl:template match="para">
 <fo:block font-size="{$para-font-size}">
   <xsl:apply-templates/>
 </fo:block>
</xsl:template>

11.5 Les Variables et les Paramètres dans les modèles

De même qu'il est possible d'utiliser dans les élément de haut niveau, xsl:variable et xsl:param sont aussi permis dans les modèles. Dans un modèle, xsl:variable est autorisé partout où une instruction l'est. Dans ce cas, le lien est visible pour tous les frères suivant ainsi que leurs descendants. Notez bien que le lien n'est pas visible par l'élément xsl:variable lui-même. xsl:param est permis lorsqu'il est fils au début d'un élément xsl:template. Dans ce cas précis, le lien est visible pour tous les frères suivant et à leurs descendants. Notez que le lien n'est pas visible par l'élément xsl:param lui-même.

Un lien inhibe un autre lien si le lien se produit à un point où l'autre lien est visible, et les deux liens doivent avoir le même nom. Si un lien établit par un élément xsl:variable ou un élément xsl:param dans un modèle inhibe un autre lien établit aussi dans un modèle par un élément xsl:variable ou un élément xsl:param alors c'est une erreur. Par contre, lien un établit par un élément xsl:variable ou un élément xsl:param dans un modèle peut inhiber un autre lien établit par un élément de haut niveau xsl:variable ou un élément de haut niveau xsl:param. Ainsi, ce qui suit est erroné :

<xsl:template name="foo">
<xsl:param name="x" select="1"/>
<xsl:variable name="x" select="2"/>
</xsl:template>

Cependant ce qui suit est autorisé :

<xsl:param name="x" select="1"/>
<xsl:template name="foo">
<xsl:variable name="x" select="2"/>
</xsl:template>

NOTE: L'équivalent Java le plus proche d'un élément xsl:variable dans un modèle est la déclaration avec initialisation d'une variable locale terminale. Par exemple,

<xsl:variable name="x" select="'value'"/>

a la même sémantique que

final Object x = "value";

XSLT ne fournit pas un équivalent à l'opérateur d'initialisation de Java

x = "value";

car ceci rend plus difficile une implémentation qui traite un document d'une manière autre que la manière de traitement par lots, partant du début jusqu'à la fin.

11.6 Passage de paramètres aux modèles

<xsl:with-param
  name = qname
  select = expression>
  <!-- Content: template -->
</xsl:with-param>

Le passage de paramètres aux modèle se fait par le moyen de l'élément xsl:with-param. L'attribut name obligatoire indique le nom du paramètre (la variable dont la valeur doit être remplacée). La valeur de l'attribut name est un QName, qui est résolu comme décrit dans [2.4 Noms qualifiés]. xsl:with-param est permis aussi bien dans xsl:call-template que dans xsl:apply-templates. La valeur du paramètre est spécifiée de la même manière que pour xsl:variable et xsl:param. Le noeud courant et la liste courante de noeuds utilisés pour calculer la valeur spécifiée par l'élément xsl:with-param sont les mêmes que ceux utilisés pour l'élément xsl:apply-templates ou pour l'élément xsl:call-template dans lequel il se apparaît. Ce n'est pas une erreur de passer un paramètre x à un modèle qui n'a pas d'élément xsl:param pour le paramètre x ; dans ce cas là, le paramètre x est tout simplement ignoré.

L'exemple suivant défini un modèle nommé pour un numbered-block avec un argument pour contrôler le format du nombre.

<xsl:template name="numbered-block">
  <xsl:param name="format">1. </xsl:param>
  <fo:block>
    <xsl:number format="{$format}"/>
    <xsl:apply-templates/>
  </fo:block>
</xsl:template>
<xsl:template match="ol//ol/li">
  <xsl:call-template name="numbered-block">
    <xsl:with-param name="format">a. </xsl:with-param>
  </xsl:call-template>
</xsl:template>

12 Fonctions additionnelles

Cette section décrit les mécanismes d'ajout de fonctions spécifiques à la librairie des fonctions du noyau de XPath. Certaines de ces fonctions additionnelles se servent d'informations spécifiées par des éléments de premier niveau dans la feuille de style; cette section décrit aussi ces éléments.

12.1 Documents avec sources multiples

Fonction: node-setdocument(object, node-set?)

La fonction document permet d'accéder aux documents XML autres que le document source principal.

Lorsque la fonction document a exactement un argument et que cet argument est un ensemble de noeuds alors, le résultat est l'union, pour chaque noeud de l'ensemble de noeuds reçu en argument, du résultat de l'exécution de la fonction document avec comme premier argument la string-value du noeud, et comme deuxième argument un ensemble de noeuds dont l'unique élément est le noeud lui-même. Lorsque la fonction document a deux arguments et que le premier argument est un ensemble de noeuds alors, le résultat est la réunion, pour chaque noeud de l'ensemble de noeuds reçu en argument, du résultat de l'exécution de la fonction document avec comme premier argument la string-value du noeud et, comme deuxième argument, le deuxième argument passé à la fonction document.

Si le premier argument de la fonction document n'est pas un ensemble de noeuds alors il sera convertit en une chaîne de caractères comme par l'exécution de la fonction string. Cette chaîne de caractères est traitée comme une référence à un URI; la ressource identifiée par l'URI est extraite. Les données résultant de la fonction d'extraction sont analysées comme un document XML et un arbre est construit en concordance avec le modèle de données (voir [3 Modèle de données]). Si l'extraction de la ressource se solde par une erreur alors, le processeur XSLT peut signaler l'erreur; s'il ne le fait pas, il doit récupérer sur l'erreur en retournant un ensemble vide de noeuds. Une erreur pouvant se produire à l'extraction résulte du fait que le processeur XSLT ne supporte pas le schéma utilisé par l'URI. Un processeur XSLT n'est sensé supporter aucun schéma particulier d'URI. Les schémas d'URI supportés par un processeur XSLT doivent être clairement indiqués dans sa documentation.

Si la référence à l'URI ne contient pas un identificateur de fragment alors, la fonction retourne l'ensemble de noeuds contenant uniquement le noeud racine du document. Si la référence à l'URI contient un identificateur de fragment alors, la fonction retourne un ensemble de noeuds contenant les noeuds de l'arbre identifiés par l'identificateur du fragment de la référence à l'URI. La sémantique de l'identificateur de fragment dépend du type de média du résultat de l'extraction de l'URI. Si lors du traitement de l'identificateur de fragment, une erreur se produisait, alors le processeur XSLT peut signaler cette erreur; dans le cas contraire, il doit récupérer l'erreur en retournant un ensemble vide de noeuds. Les erreurs possibles comportent :

Les données résultant de l'action d'extraction sont analysées comme un document XML sans tenir compte du type de média du résultat de l'extraction; si le type média de haut niveau est text, alors il est analysé comme si le type média était text/xml; autrement, il est analysé comme si le type média était application/xml.

NOTE: Puisqu'il n'y a pas de type média xml de haut niveau, les données avec un type média autre que text/xml ou application/xml peuvent être XML.

La référence à l'URI peut être relative. L'URI de base (voir [3.2 URI base]) du noeud qui apparaît le premier dans le document et qui appartient à l'ensemble de noeuds du deuxième argument est utilisé comme URI de base pour résoudre les URI relatives et les transformer en URI absolues. Lorsque le deuxième argument est omis, le noeud de la feuille de style qui contient l'expression incluant un appel à la fonction document est utilisé comme noeud de substitution par défaut. Notez qu'une référence à une URI de taille nulle est une référence au document dont l'URI qui lui est relative est en cours de résolution; ainsi document("") fait référence au noeud racine de la feuille de style; la représentation en arbre de la feuille de style est exactement la même que si le document XML contenant la feuille de style était le document source initial.

Deux documents sont traités comme le même document s'ils sont identifiés par le même URI. L'URI absolue est utilisé pour la comparaison dans laquelle chaque URI relative a été résolue et ne contient aucun identificateur de fragment. Un noeud racine est traité comme si c'était le même noeud qu'un autre noeud racine si les deux noeuds sont tous deux du même document. Ainsi, l'expression suivante est toujours vrai:

generate-id(document("foo.xml"))=generate-id(document("foo.xml"))

La fonction document augmente la possibilité qu'un ensemble de noeuds puisse contenir des noeuds provenant de plusieurs documents. Avec un tel ensemble de noeuds, l'ordre du document relatif pour deux noeuds dans un même document est l'ordre du document normal définit par XPath [XPath]. L'ordre de deux noeuds relatif au document dans deux documents différents est déterminé un ordre dépendant de l'implémentation des documents contenant les deux noeuds. Il n'y a pas de contraintes sur la manière selon laquelle l'implémentation ordonne les documents autres que le fait que l'ordonnancement doit se faire du'une manière consistante: une implémentation doit toujours utiliser le même ordre pour le même ensemble de documents.

12.2 Clés

Les clés procurent le moyen de travailler avec des documents contenant une structure implicite de références croisées. Les types d'attributs ID, IDREF et IDREFS dans XML fournissent un mécanisme permettant les documents XML de rendre explicites leurs références croisées. La fonction id de XPath permet à XSLT de supporter ce mécanisme. Cela dit, ce mécanisme a un certain nombre de limitations :

À cause ces limitations, les documents XML peuvent parfois contenir une structure de références croisées qui n'est pas explicitement déclarée par les attributs ID/IDREF/IDREFS.

Une clé est un triplet contenant :

  1. un noeud contenant la clé
  2. le nom de la clé (un nom étendu)
  3. la valeur de la clé (une chaîne de caractères)

Pour chaque document, une feuille de style déclare un ensemble de clé à l'aide de l'élément xsl:key. Pour un élément de cet ensemble de clés ayant un noeud x, un nom y et une valeur z, nous disons que le noeud x a une clé dont le nom est y et la valeur est z.

Ainsi, une clé est une sorte de ID généralisé qui n'est pas contraint par les mêmes limitations qu'un ID XML:

<!-- Category: top-level-element -->


<xsl:key
  name = qname
  match = pattern
  use = expression />

L'élément xsl:key sert à la déclaration de clés. Le nom de la clé est spécifié dans l'attribut name. La valeur de l'attribut name est un QName, qui est étendu comme indiqué dans [2.4 Noms qualifiés]. L'attribut match est un Pattern; un élément xsl:key informe sur les clés de n'importe quel noeud et qui concordent avec un motif spécifié par l'attribut match. L'attribut use est une expression spécifiant la valeur de la clé; cette expression est évaluée une fois pour chaque noeud concordant avec le motif. Si le résultat est un ensemble de noeuds alors, pour chaque noeud de cet ensemble, le noeud concordant avec le motif a une clé dont le nom est celui spécifié et dont la valeur est celle de la chaîne de caractères du noeud de l'ensemble de noeuds; autrement le résultat est convertit en une chaîne de caractères et le noeud qui concorde avec le motif a une clé dont le nom est celui spécifié et dont dont la valeur est égale à cette chaîne de caractères. Ainsi, un noeud x a une clé dont le nom est y et dont la valeur est z si et seulement s'il existe un élément xsl:key tel que :

Notez bien aussi qu'il est possible d'avoir plus d'un élément xsl:key concordant un noeud donné; tous les éléments xsl:key concordants sont utilisés, même si leurs préséance d'import n'est pas la même.

Si l'un des attributs use ou match contenait une VariableReference alors c'est une erreur.

Fonction: node-setkey(string, object)

La fonction key joue le même rôle pour les clés que celui de la fonction id pour les IDs. Le premier argument spécifie le nom de la clé. La valeur de cet argument doit être un QName, qui est étendu comme c'est décrit dans [2.4 Noms qualifiés]. Lorsque le type du deuxième argument de la fonction key est un ensemble de noeuds alors, le résultat est la réunion des résultats de l'application de la fonction key à la valeur de la chaîne de caractères de chacun des noeuds de l'ensemble de noeuds reçu en deuxième argument par la fonction. Si le type du deuxième argument de la fonction key n'est pas un ensemble de noeuds alors l'argument est converti en une chaîne de caractères de la même manière que par l'appel de la fonction string; elle retourne, sous forme d'un ensemble de noeuds contenant les noeuds du même document, un noeud contexte dont la valeur de la clé nommée est égale à cette chaîne de caractères.

Étant donné, par exemple, la déclaration suivante :

<xsl:key name="idkey" match="div" use="@id"/>

l'expression key("idkey",@ref) retourne le même ensemble de noeuds que id(@ref), à condition que le seul attribut ID déclaré dans le document source XML est :

<!ATTLIST div id ID #IMPLIED>

et que l'attribut ref du noeud courant ne contient pas d'espaces.

Considérons un document décrivant une librairie de fonction et utilisant un élément prototype pour définir les fonctions

<prototype name="key" return-type="node-set">
<arg type="string"/>
<arg type="object"/>
</prototype>

ainsi qu'un élément function pour faire référence aux noms des fonctions

<function>key</function>

La feuille de style peut alors générer des hyperliens entre les références et les définition comme suit :

<xsl:key name="func" match="prototype" use="@name"/>
<xsl:template match="function">
<b>
  <a href="#{generate-id(key('func',.))}">
    <xsl:apply-templates/>
  </a>
</b>
</xsl:template>
<xsl:template match="prototype">
<p><a name="{generate-id()}">
<b>Function: </b>
...
</a></p>
</xsl:template>

La fonction key peut être utilisée pour récupérer une clé à partir d'un document autre que le document contenant le noeud contexte. Supposons par exemple, un document contenant des références bibliographiques sous la forme <bibref>XSLT</bibref>, et qu'il y ait un document XML séparé bib.xml contenant la base de données bibliographiques dont les entrées sous de la forme :

<entry name="XSLT">...</entry>

Alors, pour la transformation des éléments bibref la feuille de style peut contenir ce qui suit :

<xsl:key name="bib" match="entry" use="@name"/>
<xsl:template match="bibref">
  <xsl:variable name="name" select="."/>
  <xsl:for-each select="document('bib.xml')">
    <xsl:apply-templates select="key('bib',$name)"/>
  </xsl:for-each>
</xsl:template>

12.3 Formatage de nombres

Fonction: stringformat-number(number, string, string?)

La fonction format-number converti son premier argument en une chaîne de caractères en utilisant comme format de conversion, la chaîne de caractères motif spécifiée par le deuxième argument et le format décimal indiqué par le troisième argument, ou le format décimal par défaut en cas d'absence du troisième argument. La chaîne de caractères motif de conversion doit respecter la syntaxe spécifiée par la classe DecimalFormat de JDK 1.1. La chaîne de caractères motif doit être une chaîne localisée : le format décimal détermine quels sont les caractères ayant une signification particulière dans le motif (à l'exception du caractère guillemet qui n'est pas localisé). Le motif de format ne doit pas contenir le symbole monétaire (#x00A4); le support de cette caractéristique a été ajouté après la release initiale de JDK 1.1. Le nom du format5 décimal doit être un QName, qui est étendu comme décrit dans [2.4 Noms qualifiés]. Si la feuille de style ne contient pas une déclaration du format décimal avec expanded-name spécifié alors c'est une erreur.

NOTE: Les implémentations ne doivent pas forcément utiliser l'implémentation de JDK 1.1 implémentation, et les implémentation ne doivent pas être forcément réalisées en Java.

NOTE: Les feuilles de style peuvent utiliser d'autres moyens de XPath pour contrôler l'arrondissement des nombres.

<!-- Category: top-level-element -->


<xsl:decimal-format
  name = qname
  decimal-separator = char
  grouping-separator = char
  infinity = string
  minus-sign = char
  NaN = string
  percent = char
  per-mille = char
  zero-digit = char
  digit = char
  pattern-separator = char />

L'élément xsl:decimal-format déclare un format décimal qui contrôle l'interprétation d'un motif de format utilisé par la fonction format-number. S'il y a un attribut name alors, l'élément déclare un format décimal nommé; autrement, il déclare le format décimal par défaut. La valeur de l'attribut name est un QName, qui est étendu comme décrit dans [2.4 Noms qualifiés]. A moins qu'un format décimal ne soit déclaré chaque fois avec la même valeur pour tous les attributs (en tenant compte de n'importes quelles valeurs par défaut), la déclaration multiple (même avec des préséances d'import différentes), du format décimal par défaut ou d'un format décimal nommé est une erreur.

Les autres attributs de l'élément xsl:decimal-format correspondent aux méthodes de la classe DecimalFormatSymbols de JDK 1.1. Pour chaque paire de méthodes get/set il existe un attribut défini pour l'élément xsl:decimal-format .

Les attributs suivants permettent de contrôler aussi bien l'interprétation des caractères dans le motif de format que de spécifier les caractères pouvant apparaître dans le résultat de formatage du nombre :

Les attributs suivants contrôlent l'interprétation des caractères dans le motif de format:

Les attributs suivants indiquent les caractères ou les chaînes de caractères pouvant apparaître dans le résultat de formatage d'un nombre :

12.4 Fonctions additionnelles diverses

Fonction: node-setcurrent()

La fonction current retourne un ensemble de noeuds ayant pour seul élément le noeud courant. Pour une expression indépendante (ne se produisant pas dans une autre expression), le noeud courant est toujours le même que le noeud contexte. Ainsi,

<xsl:value-of select="current()"/>

a la même signification que

<xsl:value-of select="."/>

Cependant dans des crochets, le noeud courant est habituellement différent du noeud contexte. Par exemple,

<xsl:apply-templates select="//glossary/item[@name=current()/@ref]"/>

traite tous les éléments item qui ont un élément glossary parent et qui ont un attribut name dont la valeur est égale à la valeur de l'attribut ref du noeud courant. Ceci est différent de

<xsl:apply-templates select="//glossary/item[@name=./@ref]"/>

qui signifie la même chose que

<xsl:apply-templates select="//glossary/item[@name=@ref]"/>

permettant de traiter tous les éléments item ayant un élément glossary parent et ayant un attribut name et un attribut ref ayant la même valeur.

L'utilisation de la fonction current dans un motif est une erreur.

Fonction: stringunparsed-entity-uri(string)

La fonction unparsed-entity-uri retourne l'URI de l'entité non valide avec un nom spécifié dans le même document que le noeud contexte (voir [3.3 Entités non valides]). Si une pareille entité n'existe pas alors la fonction retourne une chaîne de caractères vide.

Fonction: stringgenerate-id(node-set?)

La fonction generate-id retourne une chaîne de caractères qui identifie d'une manière unique le noeud dans l'ensemble de noeuds reçu en argument qui est le premier selon l'ordre du document. L'identificateur unique doit être composé de caractères ASCII alphanumériques et doit commencer par un caractère alphabétique. Ainsi, la chaîne de caractères est syntaxiquement parlant un nom XML. Une implémentation est libre de générer un identificateur de la façon qui lui est la plus appropriée de telle manière qu'un même identificateur est toujours généré pour le même noeud et différents identificateurs sont toujours générés à partir de noeuds différents. Une implémentation n'est pas obligée de générer les mêmes identificateurs chaque fois qu'un document subi une transformation. Rien ne garanti identificateur unique généré sera est distinct de n'importe quel IDs unique spécifié dans le document source. Si l'ensemble de noeuds reçu en argument est vide la fonction retourne la chaîne de caractères vide. Si l'argument est omis, il est remplacé par le noeud contexte.

Fonction: objectsystem-property(string)

L'argument de cette fonction doit être évalué par une chaîne de caractères de type QName. Le QName est étendu en un nom utilisant la déclaration de l'espace de noms dans la portée de l'expression. La fonction system-property retourne un objet représentant la valeur de la propriété système identifiée par le nom. Si une telle propriété système n'existe pas alors la chaîne de caractères vide est retournée.

Les implémentations doivent fournir les propriétés système suivantes qui sont toutes dans l'espace de noms XSLT :

13 Messages

<!-- Category: instruction -->


<xsl:message
  terminate = "yes" | "no">
  <!-- Content: template -->
</xsl:message>

L'instruction xsl:message permet d'envoyer un message d'une manière qui dépend du processeur XSLT. Le contenu de l'instruction xsl:message est un modèle. L'instruction xsl:message est instanciée par l'instanciation du contenu afin de créer un fragment XML. Le fragment XML est le contenu du message.

NOTE: xsl:message peut être implémenté par un processeur XSLT de telle sorte qu'il déclenche une dialogue popup d'alerte, ou en écrivant dans un fichier log.

Si la valeur de l'attribut terminate est yes alors, le processeur XSLT doit terminer son traitement après l'envoi du message. La valeur par défaut est no.

Pour la localisation des messages, un moyen pratique consiste à stocker l'information localisée (texte des messages, etc.) dans un document XML qui devient un fichier d'entrée additionnel pour la feuille de style. Supposons par exemple que les messages pour une langue L sont stockés dans un fichier XML resources/L.xml sous la forme :

<messages>
  <message name="problem">A problem was detected.</message>
  <message name="error">An error was detected.</message>
</messages>

La feuille de style doit alors utiliser l'approche suivante pour localiser les messages :

<xsl:param name="lang" select="en"/>
<xsl:variable name="messages"
  select="document(concat('resources/', $lang, '.xml'))/messages"/>
<xsl:template name="localized-message">
  <xsl:param name="name"/>
  <xsl:message>
    <xsl:value-of select="$messages/message[@name=$name]"/>
  </xsl:message>
</xsl:template>
<xsl:template name="problem">
  <xsl:call-template name="localized-message"/>
    <xsl:with-param name="name">problem</xsl:with-param>
  </xsl:call-template>
</xsl:template>

14 Extensions

XSLT autorise 2 sortes d'extension, l'une s'applique aux éléments, l'autre aux fonctions.

Cette version de XSLT ne fournit aucun mécanisme de définition des implémentations d'extension. Aussi, une feuille de styles XSLT qui se veut portable entre différentes implémentations de XSLT ne peut-elle pas dépendre d'extensions spécifiques. XSLT fournit des mécanismes qui permettent à une feuille de styles XSLT de déterminer si le processeur XSLT qui la traite est capable de traiter des extensions particulières, et de spécifier ce qui doit arriver quand les extensions ne sont pas disponibles. Si une feuille de styles XSLT est écrite en faisant attention à l'utilisation de ces mécanismes, alors il lui est possible de tirer partie des extensions tout en restant portable sur n'importe quelle implémentation de XSLT.

14.1 Eléments extension

Le mécanisme d'extension d'éléments permet de désigner des espaces de noms comme étant des espaces de noms d'extension. Lorsqu'un espace de noms est qualifié d'espace de noms d'extension, et qu'un élément dont le nom fait partie de cet espace est utilisé dans un modèle, alors cet élément est traité comme une instruction plutôt que comme un élément résultat littéral. L'espace de nom détermine alors la sémantique de l'instruction.

NOTE : Puisqu'un élément fils d'un élément xsl:stylesheet n'apparaît pas dans le modèle, les éléments de haut niveau non-XSLT ne sont pas des extensions d'éléments telles que définies ici, et rien dans cette section ne s'applique à eux.

On qualifie un espace de noms d'espace de noms d'extension en utilisant soit l'attribut extension-element-prefixes de l'élément xsl:stylesheet soit l'attribut xsl:extension-element-prefixes sur un élément résultat littéral ou un élément extension. La valeur de ces attributs est une liste de préfixes d'espaces de noms séparés par des espaces. L'espace de nom lié à chacun de ces préfixes se nomme espace de noms d'extension. Une erreur doit être signalée si aucun espace de noms n'est rattaché au préfixe utilisé par l'élément porteur de l'attribut extension-element-prefixes ou xsl:extension-element-prefixes. L'espace de noms par défaut (tel que déclaré par xmlns) peut être désigné comme un espace de noms d'extension, en incluant #default dans la liste des préfixes d'espaces de noms. La désignation d'un espace de noms comme espace de noms d'extension est effective à l'intérieur du sous arbre de la feuille de styles dont la racine est l'élément porteur de l'attribut extension-element-prefixes ou de l'attribut xsl:extension-element-prefixes. Les sous-arbres qui ont pout racine l'élément xsl:stylesheet, alors il n'inclue aucune des feuilles de style importées ou incluses de cet élément xsl:stylesheet.

Si le processeur XSLT ne dispose pas d'implémentation pour un élément extension particulier, alors la fonction element-available doit retourner la valeur faux pour le nom de l'élément. Quand un tel élément extension est instancié, le processeur XSLT doit exécuter un retour pour l'élément tel que spécifié en [15 Reprise]. Un processeur XSLT ne doit pas signaler d'erreur simplement parce qu'un modèle contient une extension d'élément pour laquelle il n'y aurait aucune implémentation disponible.

Si le processeur XSLT dispose d'une implémentation pour un élément extension particulier, alors la fonction element-available doit retourner la valeur vraie pour le nom de l'élément.

14.2 Fonction extension

Si, dans une expression d'appel de fonction (FunctionCall), un nom de fonction (FunctionName) n'est pas conforme à un sans deux points (NCName) (c'est à dire s'il contient le caractère deux points), alors il est traité comme un appel à une fonction d'extension. Le nom de la fonction (FunctionName) est étendu en un nom utilisant la déclaration d'espace de noms trouvé dans son contexte d'évaluation.

Si le processeur XSLT n'a pas d'implémentation particulière pour un nom d'fonction d'extension, alors la fonction "fonctions disponibles" (function-available) doit retourner la valeur faux pour ce nom de fonction. Si une telle fonction d'extension survient dans une expression et si l'fonction d'extension est en cours d'appel, le processeur XSLT doit signaler une erreur. Un processeur XSLT ne doit pas signaler d'erreur simplement parce qu'une expression contient une fonction extension inconnue.

Si le processeur XSLT dispose de l'implémentation d'une fonction d'extension particulière, alors la fonction function-available (fonction-disponible) doit retourner la valeur vrai pour ce nom de fonction. Lorsque cette extension est appelée, alors le processeur XSLT doit exécuter l'implémentation correspondante en lui passant les arguments effectifs. Le résultat retourné par l'implémentation est renvoyé comme résultat de l'appel de la fonction.

15 Reprise

<!--Catégorie: instruction --> <xsl:fallback>
  <!-- Contenu: modèle -->
</xsl:fallback>

Théoriquement, l'instanciation de l'élément xsl:fallback ne fait rien. Cependant, quand un processeur XSLT exécute un reprise sur un élément d'instructions, si l'élément d'instruction a un ou plusieurs éléments fils xsl:fallback, alors le contenu de chacun de ces fils xsl:fallback doit être instancié séquentiellement ; sinon une erreur doit être signalée. Le contenu d'un élément xsl:fallback est un modèle.

Les fonctions suivantes peuvent être utilisées avec les instructions xsl:choose et xsl:if pour contrôler explicitement le comportement de la feuille de styles dans son traitement du cas particulier des éléments et fonctions indisponibles.

Fonction: booléen element-available (chaîne de caractère)

La chaîne de caractères passée en argument doit être un nom qualifié (QName). Le nom qualifié (QName) est expansé pour donner un nom expansé (expanded-name) utilisant les déclarations d'espaces de noms dans le champ de l'expression. La fonction element-available retourne la valeur vraie si et seulement si le nom expansé est le nom d'une instruction. Si le nom expansé a une URI d'espace de noms égale à l'URI de l'espace de noms de XSLT, alors il référence un élément défini par XSLT. Autrement, il référence un élément extension. Si l'URI de l'espace de nom du nom expansé est nulle, la fonction element-available doit retourner la valeur faux.

Fonction : booléen function-available(chaîne de caractères)

L'argument doit s'évaluer en une chaîne de caractères de type nom qualifié. Le nom qualifié est résolu en un nom expansé utilisant les déclarations d'espaces de noms pour l'expression. La fonction function-available retourne la valeur vraie si et seulement si le nom expansé est celui d'une fonction de la bibliothèque de fonctions. Si l'URI de l'espace de noms du nom expansé n'est pas une chaîne vide, alors il s'agit d'une fonction d'extension ; sinon, il s'agit d'une fonction définie par XPath ou XSLT.

16 Sorties

<!-- Catégorie: élément de haut niveau -->
<xsl:output
      method = "xml" | "html" | "text" | qname-but-not-ncname
      version = nmtoken
      encoding = string
      omit-xml-declaration = "yes" | "no"
      standalone = "yes" | "no"
      doctype-public = string
      doctype-system = string
      cdata-section-elements = qnames
      indent = "yes" | "no"
      media-type = string />

Un processeur XSLT peut produire l'arbre résultat comme une séquence d'octets, bien que cette fonctionnalité ne soit pas obligatoire (voir [17 Conformité]). L'élément xsl:output permet aux auteurs de feuilles de styles de spécifier la manière dont ils souhaitent produire l'arbre résultat. Si un processeur XSLT produit un arbre résultat, il doit le faire conformément à ce qui est spécifié avec l'élément xsl:output; Toutefois, il n'est pas demandé de le faire ainsi.

L'élément xsl:output est uniquement autorisé comme élément de haut niveau.

L'attribut method de l'élément xsl:output identifie la méthode générale qui doit être utilisée pour produire l'arbre résultat. Sa valeur doit être un nom qualifié. Si ce nom qualifié n'est pas préfixé, alors il identifie une méthode spécifiée dans ce document et doit prendre l'une des valeurs suivantes : xml, html ou text. Si le nom qualifié est préfixé, alors il est résolu en un nom expansé tel que décrit au chapitre [2.4 Noms qualifiés]; Le nom expansé identifie la méthode de sortie; le comportement, dans ce cas, n'est pas spécifié dans ce document.

La valeur par défaut de l'attribut method est choisie comme suit :

Si

l'élément racine de l'arbre résultat a un élément enfant

le nom expansé du premier élément enfant du noeud racine (par exemple l'élément document) de l'arbre résultat a une partie locale html (quelques soient les combinaisons majuscule/minuscule) et une URI d'espace de nom nulle

tout noeud textuel précédent le premier élément enfant de l'élément racine de l'arbre résultat ne contient que des caractères d'espaces blancs

alors la méthode de sortie par défaut est html;

Sinon, la méthode est xml.

La méthode de sortie par défaut doit être utilisée s'il n'y a pas d'élément xsl:output ou si aucun des éléments xsl:output ne spécifie une valeur pour l'attribut method.

Les autres attributs de l'élément xsl:output sont des paramètres de la méthode de sortie qui sont :

version spécifie la version de la méthode de sortie.

indent spécifie si le processeur XSLT est autorisé à rajouter des espaces blancs additionnels pendant qu'il génère l'arbre résultat; la valeur ne peut être que yesou no.

encoding spécifie le système de codage de caractères préférentiel que le processeur XSLT doit utiliser pour représenter des séquences de caractères en tant que séquences d'octets; la valeur de cet attribut doit être traîtée sans tenir compte de la casse; la valeur ne peut contenir que des caractères compris entre #x21 et #x7E (c'est à dire les caractères imprimables de l'ASCII); la valeur doit soit être un jeu de caractères charset enregistré auprès de l'IANA [IANA], [RFC2278] soit commencer par X-.

media-type spécifie le type de support (type de contenu MIME) des données issues de l'arbre résultat; le paramètre charset ne doit pas être spécifié explicitement; au lieu de cela, quand le type de support de plus haut niveau est text, un paramètre charset doit être rajouté en conformité avec le codage des caractères en vigueur pour la méthode de sortie.

doctype-system spécifie l'identifiant système qui doit être utilisé dans la déclaration de type de document.

doctype-public spécifie l'identifiant public qui doit être utilisé dans la déclaration de type de document.

omit-xml-declaration spécifie si le processeur XSLT doit produire une déclaration XML; la valeur est obligatoirement yes ou no

standalone spécifie si le processeur XSLT doit générer une déclaration de document autonome; la valeur doit être yes ou no

cdata-section-elements spécifie une liste de noms d'éléments dont les fils de type noeud texte doivent être produit en tant que section CDATA dans l'arbre résultat.

Le sémantique détaillée de chaque attribut sera décrite séparemment pour chaque méthode de sortie à laquelle l'attribut est applicable. Si la sémantique de l'attribut n'est pas décrite pour une méthode de sortie, alors cela signifie que cette méthode ne lui est pas applicable.

Une feuille de styles peut contenir plusieurs éléments xsl:output et peut inclure ou importer des feuilles de style qui contiennent aussi des éléments xsl:output. Tous les éléments xsl:output intervenant dans une feuille de styles sont fusionnés au sein d'un seul élément effectif xsl:output. La valeur effective de l'attribut cdata-section-elements est l'union des valeurs spécifiées. Pour les autres attributs, la valeur effective est la valeur spécifiée ayant la plus grande priorité d'importation. La présence de plus d'une telle valeur pour un attribut est une erreur. Un processeur XSLT peut signaler l'erreur; s'il ne le fait pas, il doit traiter l'erreur en utilisant la valeur qui apparaît en dernier dans la feuille de styles. Les valeurs des attributs sont prises par défaut après que les éléments xsl:output aient été fusionnés; différentes méthodes de sortie peuvent avoir différentes valeur par défaut pour un attribut.

16.1 La méthode de sortie XML

La méthode de sortie xml produit l'arbre résultat sous la forme d'une entité générale XML bien formée et correcte. Si le noeud racine de l'arbre résultat a un unique fils et aucun autre fils de type texte, alors l'entité devrait aussi être bien formée. Si l'entité est référencée dans un document XML simple comme dans l'exemple suivant,

<!DOCTYPE doc [
<!ENTITY e SYSTEM "entity-URI">
]>
<doc>&e;</doc>

dans lequel entity-URI est l'URI de l'entité, alors le document englobant doit être globalement un document XML bien formé conforme aux Recommandations des Espaces de Noms XML [Noms XML]. De plus, le résultatdoit être tel que si un nouvel arbre était produit à partir du document englobant pris comme document XML conformément aux spécifications faites en [3 Modèle de données], puis en enlevant l'élément document et en faisant de ses enfants des enfants de l'élément racine, alors le nouvel arbre serait le même que l'arbre résultat, aux possibles exceptions suivantes près :

L'ordre des attributs pourrait être différent dans les deux arbres.

Le nouvel arbre pourrait contenir des noeuds d'espaces de noms qui n'étaient pas présents dans l'arbre résultat initial.

NOTE : Un processeur XSLT pourrait avoir besoin de rajouter des déclarations d'espaces de noms pendant la génération au format XML, de l'arbre résultat.

Si le processeur XSLT avait généré une déclaration de type de document à cause de l'attribut doctype-system, alors les conditions ci-dessus s'appliquent à l'entité dans laquelle la déclaration de type de document générée aura été enlevée.

L'attribut version spécifie la version de XML à considérer pour produire l'arbre résultat. Si le processeur XSLT ne supporte pas cette version de XML, il doit utiliser une version de XML qu'il supporte. La version mentionnée dans la déclaration XML (si la déclaration XML est produite) doit correspondre à la version de XML que le processeur aura utilisé pour produire l'arbre résultat. La valeur de l'attribut version doit être conforme à la règle de production VersionNum définie dans les Recommandations XML (XML Recommendation [XML]). La valeur par défaut est 1.0.

L'attribut encoding spécifie le codage préférentiel à utiliser pour produire l'arbre résultat. Des processeurs XSLT sont requis pour respecter les valeurs de UTF-8 et UTF-16. Pour les autres valeurs, si le processeur XSLT ne supporte pas le codage spécifié il peut généré une erreur; s'il ne signale pas d'erreur il doit utiliser UTF-8 ou UTF-16 à la place. Le processeur XSLT ne doit pas utiliser d'encodage dont le nom n'est pas conforme à la règle de production des noms d'encodage (EncName) de la Recommandation XML (XML Recommendation [XML]). Si aucun attribut encoding n'est spécifié, alors le processeur XSLT doit utiliser soit UTF-8 soit UTF-16. l est possible que l'arbre résultat contienne un caractère qui ne puisse pas être représenté dans le système d'encodage que le processeur XSLT utilise. Dans ce cas, si le caractère apparaît dans un contexte où XML reconnaît les références de caractères (c'est à dire dans la valeur d'un noeud d'attribut ou d'un noeud textuel), alors le caractère produit devra l'être sous la forme d'une référence de caractère; sinon (par  exemple, si le caractère se produit dans le nom d'un élément) le processeur XSLT doit signaler une erreur.

Si la valeur de l'attribut indent est Yes, alors la méthode de sortie xml peut produire des espaces blancs en plus de ceux de l'arbre résultat (peut-être basé sur les espaces blancs épurés soit du document source soit de la feuille de styles) dans le but d'indenter le résultat proprement; si l'attribut indent a la valeur no, il ne doit produire aucun espace blanc additionnel. La valeur par défaut est no. La méthode de sortie xml doit utiliser un algorithme pour rajouter les espaces blancs additionnels qui garantisse que le résultat, si les espaces blancs venaient à être supprimé de la sortie en utilisant le processus décrit en [3.4 Suppression des espaces blancs] et en réduisant l'ensemble des éléments conservant les espaces blancs au seul cas xsl:text, serait le même, que les espaces blancs additionnels soit mis dans la sortie ou qu'ils ne le soient pas.

NOTE : Il n'est normalement pas fiable d'utiliser indent="yes" avec des types de documents qui contiennent des types d'éléments à contenu mixte.

L'attribut cdata-section-elements contient une liste de noms qualifiés séparés par des espaces blancs. Chaque nom qualifié est expansé pour former un nom expansé en utilisant les déclarations d'espaces de noms en vigueur sur l'élément xsl:output dans lequel le nom qualifié apparaît; s'il existe un espace de noms par défaut, il sera utilisé pour les noms qualifiés qui n'ont pas de préfixe. L'expansion est réalisée avant que la fusion des éléments multiples xsl:output en un seul élément xsl:output ait lieu. Si le nom expansé d'un parent d'un noeud textuel est un membre de la liste, alors le noeud textuel doit être sorti en tant que paragraphe de type CDATA. Par exemple,

<xsl:output cdata-section-elements="example"/>

appliqué à un élément résultat littéral écrit dans la feuille de styles comme ceci :

<example>&lt;foo></example>

ou comme :

<example><![CDATA[<foo></example>

donnerait en sortie le même résultat que :

<example><![CDATA[<foo></example>

Si le noeud textuel contient la séquence de caractères, alors la section CDATA actuellement ouverte devrait être fermée après le ]] et une nouvelle section CDATA ouverte avant le >. Par exemple, un élément résultat littéral écrit dans la feuille de style de cette manière :

<example>]]&gt;</example>

serait sorti comme

<example><![CDATA[]]<![CDATA[></example>

Si le noeud de type texte contient un caractère qui n'appartient pas au jeu de caractères en cours d'utilisation pour la génération de l'arbre résultat, alors la section CDATA courante doit être fermée juste avant la génération dudit caractère ; le caratère doit alors être généré en tant qu'une référence de caractère ou une référence d'entité, et une nouvelle section CDATA doit être ouverte pour la génération des caractères restant du noeud de type texte.

Les sections CDATA doivent être utilisées exclusivement pour les noeuds de type texte dont l'attribut cdata-section-elements spécifie explicitement qu'ils doivent être généré en utilisant des sections CDATA.

La méthode de sortie xml doit produire une déclaration XML à moins que l'attribut omit-xml-declaration a la valeur yes. La déclaration XML doit inclure aussi bien une information de version qu'une déclaration d'encodage. Si l'attribut standalone est spécifié, la sortie doit comporter une déclaration pour un document autonome dont la valeur est la même que celle spécifiée dans l'attribut standalone. Sinon, elle ne doit pas inclure de déclaration pour un document autonome ; Ceci garantit que c'est à la fois une déclaration XML (autorisée au début d'une entité document) et une déclaration textuelle (autorisée au début d'une entité générale externe valide).

Si l'attribut doctype-system est spécifié, la méthode de sortie xml doit générer une déclaration de type de document immédiatement avant le premier élément. Le nom suivant <!DOCTYPE doit être celui du premier élément. Si l'attribut doctype-public est également spécifié, alors la méthode de sortie xml doit générer la chaîne de caractères PUBLIC suivie de l'identifiant public et de l'identifiant système; sinon, la méthode doit générer la chaîne de caractères SYSTEM suivie de l'identifiant système. Le sous ensemble local de déclaration doit être vide. L'attribut doctype-public doit être ignoré à moins que l'attribut doctype-system soit renseigné.

L'attribut media-type est applicable à la méthode de sortie xml. La valeur par défaut de l'attribut media-type est text/xml.

16.2 La méthode de sortie HTML

La méthode de sortie html produit un arbre résultat conforme à HTML; par exemple,

<xsl:stylesheet version="1.0"
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="html"/>
<xsl:template match="/">
  <html>
   <xsl:apply-templates/>
  </html>
</xsl:template>
...
</xsl:stylesheet>

L'attribut version indique la version d'HTML. La valeur par défaut est 4.0, ce qui spécifie que le résultat doit être conforme aux recommandations de HTML 4.0 [HTML].

La méthode de sortie html ne devrait pas sortir les éléments différemment de la méthode xml sauf si l'URI du nom expansé de l'élément a un espace de nom nul; un élément dont le nom expansé a une URI d'espace de nom non nulle doit être sorti comme pour XML. Si le nom expansé de l'élément a une URI d'espace de nom nulle, et que la partie locale du nom expansé n'est pas reconnue comme étant le nom d'un élément HTML, alors l'élément doit être sorti de la même manière qu'un élément non vide, en ligne, tel que span.

La méthode de sortie html ne devrait pas produire de balise fermante pour les éléments vides. En HTML 4.0, les éléments vides sont area, base, basefont, br, col, frame, hr, img, input, isindex, link, meta et param. Par exemple, un élément écrit <br/> ou <br></br> dans la feuille de styles est généré sous la forme <br> en sortie.

La méthode de sortie html devrait reconnaître les noms des éléments HTML indépendamment de leur casse. Par exemple, les éléments nommés br, BR ou Br doivent tous être reconnus comme étant l'élément HTML br, et sorti sans balise de fin.

La méthode de sortie html ne doit pas masquer le contenu des éléments script et style. Par exemple, un élément résultat littéral écrit dans la feuille de styles de la manière suivante :

<script>if (a &lt; b) foo()</script>

ou

<script><![CDATA[if (a < b) foo()</script>

doit produire le résultat suivant :

<script>if (a < b) foo()</script>

La méthode de sortie html ne doit pas masquer les caractères < qui apparaissent dans les valeurs d'attributs.

Si l'attribut indent a la valeur yes, alors la méthode de sortie html peut rajouter ou retirer des espaces blancs pendant la sortie de l'arbre résultat, tant que cela ne change pas comment un agent utilisateur de HTML interpréterait la sortie. La valeur par défaut est yes.

La méthode de sortie html doit traiter les caractères non-ASCII dans les valeurs d'attribut d'URI en utilisant la méthode recommandée à la section B.2.1 des recommandations de HTML 4.0.

La méthode de sortie html peut utiliser une référence d'entité caractère pour produire un caractère, si une telle entitté est définie pour ce caractère dans la version de HTML que la méthode de sortie utilise.

La méthode de sortie html devrait clore les instructions de traitement en utilisant le caractère > plutôt que ?>.

La méthode de sortie html devrait générer les attributs de type booléen (les attributs qui ne peuvent prendre qu'une seule valeur possible : leur propre nom) sous une forme minimale. Par exemple, une balise ouvrante écrite dans la feuille de styles de la manière suivante :

<OPTION selected="selected">

doit produire le résultat suivant :

<OPTION selected>

La méthode de sortie html doit tenir compte du caractère & quand il apparaît dans une valeur d'attribut et qu'il est suivi du caractère{ (voir Section B.7.1 de la recommandation 4.0). Par exemple, une balise ouvrante écrite dans la feuille de styles de la manière suivante

<BODY bgcolor='&amp;{{randomrbg}};'>

doit être sorti comme ceci :

<BODY bgcolor='&{randomrbg};'>

L'attribut encoding spécifie le codage de caractères à utiliser de préférence. S'il y a un élément HEAD, alors la méthode de sortie de html doit rajouter immédiatement après, un élément META spécifiant le codage utilisé. Par exemple,

<HEAD>
<META http-equiv="Content-Type" content="text/html; charset=EUC-JP">
...

Il est possible que l'arbre résultat contienne un caractère qui ne puisse pas être représenté dans le codage que le processeur XSLT utilise pour la sortie. Dans ce cas, si le caractère apparaît dans un contexte où HTML reconnaît les références de caractères, alors le caractère doit être généré en tant qu'entité caractère ou en tant qu'une référence numérique décimale de caractère ; sinon (par exemple, cas des éléments script ou style et des commentaires), le processeur XSLT doit signaler une erreur.

Si les attributs doctype-public ou doctype-system sont précisés, alors la méthode de sortie html doit produire un déclaration de type de document immédiatement avant le premier élément. Le nom suivant <!DOCTYPE doit être HTML ou html. Si l'attribut doctype-public est spécifié, alors la méthode de sortie doit produire le mot PUBLIC suivi de l'identifiant public spécifié; si l'attribut doctype-system est également spécifié, la méthode devra également sortir l'identifiant système spécifié suivi de l'identifiant public. Si l'attribut doctype-system est spécifié mais que l'attribut doctype-public ne l'est pas, alors la méthode de sortie doit produire le mot SYSTEM suivi par l'identifiant système.

L'attribut media-type n'est applicable qu'à la méthode de sortie html. La valeur par défaut est text/html.

16.3 La méthode de sortie texte

La méthode de sortie text produit l'arbre résultat en sortant les valeurs textuelles de chaque noeud de l'arbre résultat, dans l'ordre du document sans exception.

L'attribut media-type est applicable à cette méthode de sortie. Sa valeur par défaut est text/plain.

L'attribut encoding spécifie le codage que la méthode de sortie doit utiliser pour convertir les séquences de caractères en séquences d'octets. La valeur par défaut dépend du système. Si l'arbre résultat contient un caractère qui ne peut pas être représenté avec le codage choisi, alors le processeur XSLT doit signaler une erreur.

16.4 Désactivation de la production littérale des caractères en sortie

Normalement, la méthode de sortie xml conserve tel quel les caractères & et < (et potentiellement d'autres caractères) au moment de la sortie des noeuds textuels de manière à garantir que la sortie soit bien formée au sens XML. Toutefois, il est parfois utile de pouvoir produire une forme qui soit globalement bien formée XML sans toutefois l'être complètement; par exemple, la sortie peut inclure des sections pas bien formées mais qui le deviendront par un traitement ultérieur indépendant de toute syntaxe XML. Pour cette raison, XSLT produit un moyen pour changer ce comportement. Les éléments xsl:value-of et xsl:text peuvent recevoir l'attribut disable-output-escaping dont les valeurs autorisées sont yes ou no; La valeur par défaut est no; si la valeur est mise à yes, alors les caractères & et < des noeuds textuels générés par instanciation de l'élément xsl:value-of ou xsl:text seront interprétés. Par exemple :

<xsl:text disable-output-escaping="yes">&lt;</xsl:text>

est une instruction qui signifie à la méthode de sortie de produire le caractère <.

Désactiver la production littérale des caractères sur un noeud textuel utilisé à autre chose (qu'un noeud textuel) dans l'arbre de sortie est une erreur. Aussi, désactiver la production littérale sur l'élément xsl:value-of ou xsl:text qui est utilisé pour produire un commentaire, une instruction de traitement ou un noeud d'attribut est une erreur; c'est également une erreur que de convertir un fragment de l'arbre résultat en un nombre ou une chaîne si ce fragment contient un noeud textuel pour lequel la production littérale a été désactivée. Dans les deux cas, un processeur XSLT peut signaler une erreur; s'il ne le fait pas, il doit la rattraper en ignorant l'attribut disable-output-escaping.

L'attribut disable-output-escaping peut être aussi bien utilisé avec la méthode de sortie html qu'avec la méthode de sortie xml. La méthode de sortie text ignore l'attribut disable-output-escaping, puisque cette méthode ne fait, de base, aucune interprétation.

Un processeur XSLT ne sera capable de désactiver la production littérale de sortie que s'il contrôle la manière dont l'arbre résultat est sorti. Cela n'est pas obligatoirement le cas. Par exemple, l'arbre résultat peut être utilisé comme arbre source pour une autre transformation XSLT. Un processeur XSLT n'est pas obligé de supporter la fonction de désactivation de la production littérale de caractères en sortie. Si un élément xsl:value-of ou xsl:text spécifie que la production littérale doit être désactivée et que le processeur XSLT ne le supporte pas, alors le processeur XSLT peut signaler une erreur; s'il ne le fait pas, il doit la rattraper en ne désactivant pas l'interprétation de sortie.

Si la production littérale de sortie est désactivée pour un caractère qui n'a pas de représentation dans le codage XSLT utilisé par le processeur en sortie, alors le processeur XSLT peut signaler une erreur; s'il ne le fait pas, il doit la rattraper en ne désactivant pas la production littérale en sortie.

Since disabling output escaping may not work with all XSLT processors and can result in XML that is not well-formed, it should be used only when there is no alternative.

17 Conformité

Un processeur XSLT conforme doit être capable d'utiliser une feuille de styles pour transformer un arbre source en un arbre résultat d'après les spécifications écrites dans ce document. Un processeur XSLT conforme n'a pas besoin d'être capable de produire le résultat en XML où toute autre forme.

NOTE : Les vendeurs de processeurs XSLT sont fortement encouragés à fournir un moyen de vérifier que leurs processeurs ont un comportement conforme en permettant que l'arbre résultat soit sorti sous forme XML ou en fournissant un accès à l'arbre résultat au travers d'une API standard telle que DOM ou SAX.

Un processeur XSLT doit signaler toute erreur à l'exception de celles qui dans ce document, sont explicitement autorisées à ne pas être signalées. un processeur XSLT n'est pas obligé de récupérer toutes les erreurs bien que cela puisse se réveler nécessaire.

Un processeur XSLT conforme peut imposer des limites sur les ressources de traitement consommées par le traitement d'une feuille de styles.

18 Notation

La spécification de chaque type d'élément défini pour XSLT est précédée par un résumé de sa syntaxe sous la forme d'un modèle pour les éléments de ce type d'élément. La signification de la notation syntaxique résumée est comme suit :

Un attribut est requis si et seulement si son nom est en gras.

La chaîne de caractères écrite à la place de la valeur d'attribut spécifie les valeurs d'attributs autorisées pour l'attribut. Si cette chaîne est encadrée par des accolades, elle représente alors une forme architecturale de la valeur d'attribut, et les valeurs d'attributs autorisées sont celles obtenues lors de l'instanciation de cette forme architecturale. Le connecteur | représente le ou, les valeurs listées séparées par ce connecteur sont mutuellement exclusive. Une chaîne entre cotes signifie que la valeur de l'attribut doit être égale à cette chaîne spécifique. Un nom sans cote, en italique est une spécification d'un type particulier de valeur d'attribut.

Si l'élément ne doit pas avoir un contenu vide, alors il contient un commentaire spécifiant le contenu autorisé. Le contenu autorisé est spécifié de la même manière pour une déclaration de type d'élément en XML ; template signifie que n'importe quel combinaison de noeuds textuels, éléments résultat littéraux, éléments d'extension, et des éléments XSLT de la catégorie instruction est autorisée ; top-level-element signifie que toute combinaison d'éléments XSLT de la catégorie top-level-element est autorisée.

L'élément est préfacé par des commentaires indiquant s'il appartient à la catégorie instruction ou top-level-element ou aux deux. La catégorie d'un élément ne fait que signaler s'il est autorisé dans les contenus dont les modèles de contenus sont du type modèle ou éléments de hauts niveaux.


A Références

A.1 Références normatives

XML
World Wide Web Consortium. Extensible Markup Language (XML) 1.0. W3C Recommendation. Voir http://www.w3.org/TR/1998/REC-xml-19980210
Noms XML
World Wide Web Consortium. Namespaces in XML. W3C Recommendation. Voir http://www.w3.org/TR/REC-xml-names
XPath
World Wide Web Consortium. XML Path Language. W3C Recommendation. Voir http://xmlfr.org/w3c/TR/xpath

A.2 Autres références

CSS2
World Wide Web Consortium. Cascading Style Sheets, level 2 (CSS2). W3C Recommendation. Voir http://www.w3.org/TR/1998/REC-CSS2-19980512
DSSSL
International Organization for Standardization, International Electrotechnical Commission. ISO/IEC 10179:1996. Document Style Semantics and Specification Language (DSSSL). International Standard.
HTML
World Wide Web Consortium. HTML 4.0 specification. W3C Recommendation. Voir http://www.w3.org/TR/REC-html40
IANA
Internet Assigned Numbers Authority. Character Sets. Voir ftp://ftp.isi.edu/in-notes/iana/assignments/character-sets.
RFC2278
N. Freed, J. Postel. IANA Charset Registration Procedures. IETF RFC 2278. Voir http://www.ietf.org/rfc/rfc2278.txt.
RFC2376
E. Whitehead, M. Murata. XML Media Types. IETF RFC 2376. Voir http://www.ietf.org/rfc/rfc2376.txt.
RFC2396
T. Berners-Lee, R. Fielding, and L. Masinter. Uniform Resource Identifiers (URI): Generic Syntax. IETF RFC 2396. Voir http://www.ietf.org/rfc/rfc2396.txt.
UNICODE TR10
Unicode Consortium. Unicode Technical Report #10. Unicode Collation Algorithm. Unicode Technical Report. Voir http://www.unicode.org/unicode/reports/tr10/index.html.
XHTML
World Wide Web Consortium. XHTML 1.0: The Extensible HyperText Markup Language. W3C Proposed Recommendation. Voir http://www.w3.org/TR/xhtml1
XPointer
World Wide Web Consortium. XML Pointer Language (XPointer). W3C Working Draft. Voir http://www.w3.org/TR/xptr
Feuilles de style XML
World Wide Web Consortium. Associating stylesheets with XML documents. W3C Recommendation. Voir http://www.w3.org/TR/xml-stylesheet
XSL
World Wide Web Consortium. Extensible Stylesheet Language (XSL). W3C Working Draft. Voir http://www.w3.org/TR/WD-xsl

B Récapitulatif de la syntaxe des éléments

<!-- Catégorie : instruction-->
<xsl:apply-imports />

<!-- Catégorie : instruction-->
<xsl:apply-templates
  select = node-set-expression
  mode = qname>
  <!-- Contenu : (xsl:sort | xsl:with-param)* -->
</xsl:apply-templates>

<!-- Catégorie : instruction-->
<xsl:attribute
  name = { qname }
  namespace = { uri-reference }>
  <!-- Contenu : modèle -->
</xsl:attribute>

<!-- Catégorie : élémentde haut niveau -->
<xsl:attribute-set
  name = qname
  use-attribute-sets = qnames>
  <!-- Contenu : xsl:attribute*-->
</xsl:attribute-set>

<!-- Catégorie : instruction-->
<xsl:call-template
  name = qname>
  <!-- Contenu : xsl:with-param*-->
</xsl:call-template>

<!-- Catégorie : instruction-->
<xsl:choose>
  <!-- Contenu : (xsl:when+, xsl:otherwise?) -->
</xsl:choose>

<!-- Catégorie : instruction-->
<xsl:comment>
  <!-- Contenu : modèle -->
</xsl:comment>

<!-- Catégorie : instruction-->
<xsl:copy
  use-attribute-sets = qnames>
  <!-- Contenu : modèle -->
</xsl:copy>

<!-- Catégorie : instruction-->
<xsl:copy-of
  select = expression />

<!-- Catégorie : élément de haut niveau -->
<xsl:decimal-format
  name = qname
  decimal-separator = char
  grouping-separator = char
  infinity = string
  minus-sign = char
  NaN = string
  percent = char
  per-mille = char
  zero-digit = char
  digit = char
  pattern-separator = char />

<!-- Catégorie : instruction-->
<xsl:element
  name = { qname }
  namespace = { uri-reference }
  use-attribute-sets = qnames>
  <!-- Contenu : modèle -->
</xsl:element>

<!-- Catégorie : instruction-->
<xsl:fallback>
  <!-- Contenu : modèle -->
</xsl:fallback>

<!-- Catégorie : instruction-->
<xsl:for-each
  select = node-set-expression>
  <!-- Contenu : (xsl:sort*, modèle) -->
</xsl:for-each>

<!-- Catégorie : instruction-->
<xsl:if
  test = boolean-expression>
  <!-- Contenu : modèle -->
</xsl:if>

<xsl:import
  href = uri-reference />

<!-- Catégorie : élément de haut niveau -->
<xsl:include
  href = uri-reference />

<!-- Catégorie : élément de haut niveau -->
<xsl:key
  name = qname
  match = pattern
  use = expression />

<!-- Catégorie : instruction-->
<xsl:message
  terminate = "yes" | "no">
  <!-- Contenu : modèle -->
</xsl:message>

<!-- Catégorie : élément de haut niveau -->
<xsl:namespace-alias
  stylesheet-prefix = prefix | "#default"
  result-prefix = prefix | "#default" />

<!-- Catégorie : instruction-->
<xsl:number
  level = "single" | "multiple" | "any"
  count = pattern
  from = pattern
  value = number-expression
  format = { string }
  lang = { nmtoken }
  letter-value = { "alphabetic" | "traditional" }
  grouping-separator = { char }
  grouping-size = { number } />

<xsl:otherwise>
  <!-- Contenu : modèle -->
</xsl:otherwise>

<!-- Catégorie : élément de haut niveau -->
<xsl:output
  method = "xml" | "html" | "text" | qname-but-not-ncname
  version = nmtoken
  encoding = string
  omit-xml-declaration = "yes" | "no"
  standalone = "yes" | "no"
  doctype-public = string
  doctype-system = string
  cdata-section-elements = qnames
  indent = "yes" | "no"
  media-type = string />

<!-- Catégorie : élément de haut niveau -->
<xsl:param
  name = qname
  select = expression>
  <!-- Contenu : modèle -->
</xsl:param>

<!-- Catégorie : élément de haut niveau -->
<xsl:preserve-space
  elements = tokens />

<!-- Catégorie : instruction-->
<xsl:processing-instruction
  name = { ncname }>
  <!-- Contenu : modèle -->
</xsl:processing-instruction>

<xsl:sort
  select = string-expression
  lang = { nmtoken }
  data-type = { "text" | "number" | qname-but-not-ncname }
  order = { "ascending" | "descending" }
  case-order = { "upper-first" | "lower-first" } />

<!-- Catégorie : élément de haut niveau -->
<xsl:strip-space
  elements = tokens />

<xsl:stylesheet
  id = id
  extension-element-prefixes = tokens
  exclude-result-prefixes = tokens
  version = number>
  <!-- Contenu : (xsl:import*, top-level-elements) -->
</xsl:stylesheet>

<!-- Catégorie : élément de haut niveau -->
<xsl:template
  match = pattern
  name = qname
  priority = number
  mode = qname>
  <!-- Contenu : (xsl:param*, modèle) -->
</xsl:template>

<!-- Catégorie : instruction-->
<xsl:text
  disable-output-escaping = "yes" | "no">
  <!-- Contenu : #PCDATA -->
</xsl:text>

<xsl:transform
  id = id
  extension-element-prefixes = tokens
  exclude-result-prefixes = tokens
  version = number>
  <!-- Contenu : (xsl:import*, top-level-elements) -->
</xsl:transform>

<!-- Catégorie : instruction-->
<xsl:value-of
  select = string-expression
  disable-output-escaping = "yes" | "no" />

<!-- Catégorie : élément de haut niveau -->
<!-- Catégorie : instruction -->
<xsl:variable
  name = qname
  select = expression>
  <!-- Contenu : modèle -->
</xsl:variable>

<xsl:when
  test = boolean-expression>
  <!-- Contenu : modèle -->
</xsl:when>

<xsl:with-param
  name = qname
  select = expression>
  <!-- Contenu : modèle -->
</xsl:with-param>

C Fragment de la DTD des feuilles de style XSLT (Non-Normatif)

NOTE : Ce fragment de DTD n'est pas normatif parce que les DTDs de XML 1.0 ne supportent pas les espaces de noms XML et donc ne peuvent pas décrire correctement la structure autorisée d'une feuille de styles XSLT.

L'entité suivante peut être autorisée pour construire une DTD pour des feuilles de style XSLT qui crée des instances d'une DTD résultat particulière. Avant de référencer l'entité, la DTD de la feuille de styles doit définir une entité paramètre result-elements qui liste les types d'éléments résultat autorisés. Par exemple :

<!ENTITY % result-elements "
  | fo:inline-sequence
  | fo:block
">

De tels éléments résultat doivent être déclarés de manière à pouvoir être qualifiés par les attributs xsl:use-attribute-sets eet xsl:extension-element-prefixes. L'entité suivante déclare le paramètre result-element-atts à cette fin. Le contenu que XSLT autorise pour les éléments résultat est le même que celui autorisé pour les éléments XSLT déclarés dans l'entité suivante et dont le modèle de contenu est %template;. La DTD peut utiliser un modèle de contenu plus restrictif que %template; pour faire apparaître les contraintes de la DTD résultat.

La DTD peut définir l'entité paramètre non-xsl-top-level pour autoriser l'utilisation d'autres éléments de haut niveau que ceux pré-défini dans l'espace de noms XSLT

L'utilisation du préfixe xsl: dans cette DTD n'implique pas que les feuilles de styles XSLT doivent utiliser ce préfixe. Tout élément déclaré dans cette DTD peut avoir des attributs dont le nom commence par xmlns: ou être égal à xmlns en plus des attributs déclarés dans cette DTD.

<!ENTITY % char-instructions "
  | xsl:apply-templates
  | xsl:call-template
  | xsl:apply-imports
  | xsl:for-each
  | xsl:value-of
  | xsl:copy-of
  | xsl:number
  | xsl:choose
  | xsl:if
  | xsl:text
  | xsl:copy
  | xsl:variable
  | xsl:message
  | xsl:fallback
">

<!ENTITY % instructions "
  %char-instructions;
  | xsl:processing-instruction
  | xsl:comment
  | xsl:element
  | xsl:attribute
">

<!ENTITY % char-template "
 (#PCDATA
  %char-instructions;)*
">

<!ENTITY % template "
 (#PCDATA
  %instructions;
  %result-elements;)*
">

<!-- Utilisé pour le type d'un attribut qui est une référence d'URI.-->
<!ENTITY % URI "CDATA">

<!-- Utilisé pour le type d'un attribut qui est un motif.-->
<!ENTITY % pattern "CDATA">

<!-- Utilisé pour le type d'un attribut qui est un modèle de valeur d'attribut.-->
<!ENTITY % avt "CDATA">

<!-- Utilisé pour le type d'un attribut qui est un nom qualifié; le préfixe est expansé par le processeur XSLT. -->
<!ENTITY % qname "NMTOKEN">

<!-- Comme qname mais il s'agit d'une liste de noms qualifiés séparés par des espaces blancs. -->
<!ENTITY % qnames "NMTOKENS">

<!-- Utilisé pour un type de valeur d'attribut qui est une expression.-->
<!ENTITY % expr "CDATA">

<!-- Utilisé pour un type de valeur d'attribut qui est formé d'un seul caractère.-->
<!ENTITY % char "CDATA">

<!-- Utilisé pour un type de valeur d'attribut qui est une priorité. -->
<!ENTITY % priority "NMTOKEN">

<!ENTITY % space-att "xml:space (default|preserve) #IMPLIED">

<!-- Ceci peut être modifié pour personnaliser l'ensemble des éléments de haut niveau autorisés. -->
<!ENTITY % non-xsl-top-level "">

<!ENTITY % top-level "
 (xsl:import*,
  (xsl:include
  | xsl:strip-space
  | xsl:preserve-space
  | xsl:output
  | xsl:key
  | xsl:decimal-format
  | xsl:attribute-set
  | xsl:variable
  | xsl:param
  | xsl:template
  | xsl:namespace-alias
  %non-xsl-top-level;)*) ">

<!ENTITY % top-level-atts '
  extension-element-prefixes CDATA #IMPLIED
  exclude-result-prefixes CDATA #IMPLIED
  id ID #IMPLIED
  version NMTOKEN #REQUIRED
  xmlns:xsl CDATA #FIXED "http://www.w3.org/1999/XSL/Transform"
  %space-att; '>

<!-- Cette entité est définie pour être utilisée dans une déclaration ATTLIST pour les éléments résultat. -->
<!ENTITY % result-element-atts '
  xsl:extension-element-prefixes CDATA #IMPLIED
  xsl:exclude-result-prefixes CDATA #IMPLIED
  xsl:use-attribute-sets %qnames; #IMPLIED
  xsl:version NMTOKEN #IMPLIED '>

<!ELEMENT xsl:stylesheet %top-level;>
<!ATTLIST xsl:stylesheet %top-level-atts;>

<!ELEMENT xsl:transform %top-level;>
<!ATTLIST xsl:transform %top-level-atts;>

<!ELEMENT xsl:import EMPTY>
<!ATTLIST xsl:import href %URI; #REQUIRED>

<!ELEMENT xsl:include EMPTY>
<!ATTLIST xsl:include href %URI; #REQUIRED>

<!ELEMENT xsl:strip-space EMPTY>
<!ATTLIST xsl:strip-space elements CDATA #REQUIRED>

<!ELEMENT xsl:preserve-space EMPTY>
<!ATTLIST xsl:preserve-space elements CDATA #REQUIRED>

<!ELEMENT xsl:output EMPTY>
<!ATTLIST xsl:output
  method %qname; #IMPLIED
  version NMTOKEN #IMPLIED
  encoding CDATA #IMPLIED
  omit-xml-declaration (yes|no) #IMPLIED
  standalone (yes|no) #IMPLIED
  doctype-public CDATA #IMPLIED
  doctype-system CDATA #IMPLIED
  cdata-section-elements %qnames; #IMPLIED
  indent (yes|no) #IMPLIED
  media-type CDATA #IMPLIED >

<!ELEMENT xsl:key EMPTY>
<!ATTLIST xsl:key
  name %qname; #REQUIRED
  match %pattern; #REQUIRED
  use %expr; #REQUIRED >

<!ELEMENT xsl:decimal-format EMPTY>
<!ATTLIST xsl:decimal-format
  name %qname; #IMPLIED
  decimal-separator %char; "."
  grouping-separator %char; ","
  infinity CDATA "Infinity"
  minus-sign %char; "-"
  NaN CDATA "NaN"
  percent %char; "%"
  per-mille %char; "&#x2030;"
  zero-digit %char; "0"
  digit %char; "#"
  pattern-separator %char; ";" >

<!ELEMENT xsl:namespace-alias EMPTY>
<!ATTLIST xsl:namespace-alias
  stylesheet-prefix CDATA #REQUIRED
  result-prefix CDATA #REQUIRED >

<!ELEMENT xsl:template
 (#PCDATA
  %instructions;
  %result-elements;
  | xsl:param)* >
<!ATTLIST xsl:template
  match %pattern; #IMPLIED
  name %qname; #IMPLIED
  priority %priority; #IMPLIED
  mode %qname; #IMPLIED
  %space-att; >

<!ELEMENT xsl:value-of EMPTY>
<!ATTLIST xsl:value-of
  select %expr; #REQUIRED
  disable-output-escaping (yes|no) "no" >

<!ELEMENT xsl:copy-of EMPTY>
<!ATTLIST xsl:copy-of select %expr; #REQUIRED>

<!ELEMENT xsl:number EMPTY>
<!ATTLIST xsl:number

  level (single|multiple|any) "single"
   count %pattern; #IMPLIED
   from %pattern; #IMPLIED
   value %expr; #IMPLIED
   format %avt; '1'
   lang %avt; #IMPLIED
   letter-value %avt; #IMPLIED
   grouping-separator %avt; #IMPLIED
   grouping-size %avt; #IMPLIED >

<!ELEMENT xsl:apply-templates (xsl:sort|xsl:with-param)*>
<!ATTLIST xsl:apply-templates
  select %expr; "node()"
  mode %qname; #IMPLIED >

<!ELEMENT xsl:apply-imports EMPTY>

<!-- xsl:sort ne peut pas apparaître après un quelconque autre élément ou caractère autre qu'un espace blanc -->

<!ELEMENT xsl:for-each
 (#PCDATA
  %instructions;
  %result-elements;
  | xsl:sort)* >
<!ATTLIST xsl:for-each
  select %expr; #REQUIRED
  %space-att; >

<!ELEMENT xsl:sort EMPTY>
<!ATTLIST xsl:sort
  select %expr; "."
  lang %avt; #IMPLIED
  data-type %avt; "text"
  order %avt; "ascending"
  case-order %avt; #IMPLIED >

<!ELEMENT xsl:if %template;>
<!ATTLIST xsl:if
  test %expr; #REQUIRED
  %space-att; >

<!ELEMENT xsl:choose (xsl:when+, xsl:otherwise?)>
<!ATTLIST xsl:choose %space-att;>

<!ELEMENT xsl:when %template;>
<!ATTLIST xsl:when
  test %expr; #REQUIRED
  %space-att; >

<!ELEMENT xsl:otherwise %template;>
<!ATTLIST xsl:otherwise %space-att;>

<!ELEMENT xsl:attribute-set (xsl:attribute)*>
<!ATTLIST xsl:attribute-set
  name %qname; #REQUIRED
  use-attribute-sets %qnames; #IMPLIED >

<!ELEMENT xsl:call-template (xsl:with-param)*>
<!ATTLIST xsl:call-template
  name %qname; #REQUIRED >

<!ELEMENT xsl:with-param %template;>
<!ATTLIST xsl:with-param
  name %qname; #REQUIRED
  select %expr; #IMPLIED >

<!ELEMENT xsl:variable %template;>
<!ATTLIST xsl:variable
  name %qname; #REQUIRED
  select %expr; #IMPLIED >

<!ELEMENT xsl:param %template;>
<!ATTLIST xsl:param
  name %qname; #REQUIRED
  select %expr; #IMPLIED >

<!ELEMENT xsl:text (#PCDATA)>
<!ATTLIST xsl:text
  disable-output-escaping (yes|no) "no" >

<!ELEMENT xsl:processing-instruction %char-template;>
<!ATTLIST xsl:processing-instruction
  name %avt; #REQUIRED
  %space-att; >

<!ELEMENT xsl:element %template;>
<!ATTLIST xsl:element
  name %avt; #REQUIRED
  namespace %avt; #IMPLIED
  use-attribute-sets %qnames; #IMPLIED
  %space-att; >

<!ELEMENT xsl:attribute %char-template;>
<!ATTLIST xsl:attribute
  name %avt; #REQUIRED
  namespace %avt; #IMPLIED
  %space-att; >

<!ELEMENT xsl:comment %char-template;>
<!ATTLIST xsl:comment %space-att;>

<!ELEMENT xsl:copy %template;>
<!ATTLIST xsl:copy
  %space-att;
  use-attribute-sets %qnames; #IMPLIED >

<!ELEMENT xsl:message %template;>
<!ATTLIST xsl:message
  %space-att;
  terminate (yes|no) "no" >

<!ELEMENT xsl:fallback %template;>
<!ATTLIST xsl:fallback %space-att;>

D Exemples (Non-Normatifs)

D.1 Exemple avec un document

Cet exemple est une feuille de style qui transforme des documents conformes à une DTD simple en XHTML [XHTML].

La DTD est :

<!ELEMENT doc (title, chapter*)>
<!ELEMENT chapter (title, (para|note)*, section*)>
<!ELEMENT section (title, (para|note)*)>
<!ELEMENT title (#PCDATA|emph)*>
<!ELEMENT para (#PCDATA|emph)*>
<!ELEMENT note (#PCDATA|emph)*>
<!ELEMENT emph (#PCDATA|emph)*>

La feuille de style est :

<xsl:stylesheet version="1.0"
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                xmlns="http://www.w3.org/TR/xhtml1/strict">
<xsl:strip-space elements="doc chapter section"/>
<xsl:output
   method="xml"
   indent="yes"
   encoding="iso-8859-1"/>
<xsl:template match="doc">
 <html>
   <head>
     <title>
       <xsl:value-of select="title"/>
     </title>
   </head>
   <body>
     <xsl:apply-templates/>
   </body>
 </html>
</xsl:template>
<xsl:template match="doc/title">
  <h1>
    <xsl:apply-templates/>
  </h1>
</xsl:template>
<xsl:template match="chapter/title">
  <h2>
    <xsl:apply-templates/>
  </h2>
</xsl:template>
<xsl:template match="section/title">
  <h3>
    <xsl:apply-templates/>
  </h3>
</xsl:template>
<xsl:template match="para">
  <p>
    <xsl:apply-templates/>
  </p>
</xsl:template>
<xsl:template match="note">
  <p class="note">
    <b>NOTE : </b>
    <xsl:apply-templates/>
  </p>
</xsl:template>
<xsl:template match="emph">
  <em>
    <xsl:apply-templates/>
  </em>
</xsl:template>
</xsl:stylesheet>

Avec comme document d'entrée :

<!DOCTYPE doc SYSTEM "doc.dtd">
<doc>
<title>Document Title</title>
<chapter>
<title>Chapter Title</title>
<section>
<title>Section Title</title>
<para>This is a test.</para>
<note>This is a note.</note>
</section>
<section>
<title>Another Section Title</title>
<para>This is <emph>another</emph> test.</para>
<note>This is another note.</note>
</section>
</chapter>
</doc>

le résultat serait :

<?xml version="1.0" encoding="iso-8859-1"?>
<html xmlns="http://www.w3.org/TR/xhtml1/strict">
<head>
<title>Document Title</title>
</head>
<body>
<h1>Document Title</h1>
<h2>Chapter Title</h2>
<h3>Section Title</h3>
<p>This is a test.</p>
<p class="note">
<b>NOTE : </b>This is a note.</p>
<h3>Another Section Title</h3>
<p>This is <em>another</em> test.</p>
<p class="note">
<b>NOTE : </b>This is another note.</p>
</body>
</html>

D.2 Exemple avec des données

Ceci est un exemple de transformation de données représentées en XML en utilisant 3 feuilles de styles XSLT différentes pour produire 3 représentations des données : en HTML, SVG et VRML.

Les données d'entrée sont :

<sales>
        <division id="North">
                <revenue>10</revenue>
                <growth>9</growth>
                <bonus>7</bonus>
        </division>
        <division id="South">
                <revenue>4</revenue>
                <growth>3</growth>
                <bonus>4</bonus>
        </division>
        <division id="West">
                <revenue>6</revenue>
                <growth>-1.5</growth>
                <bonus>2</bonus>
        </division>
</sales>

La feuille de style suivante, qui utilise la syntaxe simplifiée décrite en [2.3 Feuille de style sous la forme d'un élément littéral résultat], transforme les données en HTML :

<html xsl:version="1.0"
      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
      lang="en">
    <head>
        <title>Sales Results By Division</title>
    </head>
    <body>
        <table border="1">
            <tr>
                <th>Division</th>
                <th>Revenue</th>
                <th>Growth</th>
                <th>Bonus</th>
            </tr>
            <xsl:for-each select="sales/division">
                <!-- order the result by revenue -->
                <xsl:sort select="revenue"
                          data-type="number"
                          order="descending"/>
                <tr>
                    <td>
                        <em><xsl:value-of select="@id"/></em>
                    </td>
                    <td>
                        <xsl:value-of select="revenue"/>
                    </td>
                    <td>
                        <!-- met en valeur par du rouge la croissance négative -->
                        <xsl:if test="growth &lt; 0">
                             <xsl:attribute name="style">
                                 <xsl:text>color:red</xsl:text>
                             </xsl:attribute>
                        </xsl:if>
                        <xsl:value-of select="growth"/>
                    </td>
                    <td>
                        <xsl:value-of select="bonus"/>
                    </td>
                </tr>
            </xsl:for-each>
        </table>
    </body>
</html>

La sortie HTML est :

<html lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<title>Sales Results By Division</title>
</head>
<body>
<table border="1">
<tr>
<th>Division</th><th>Revenue</th><th>Growth</th><th>Bonus</th>
</tr>
<tr>
<td><em>North</em></td><td>10</td><td>9</td><td>7</td>
</tr>
<tr>
<td><em>West</em></td><td>6</td><td style="color:red">-1.5</td><td>2</td>
</tr>
<tr>
<td><em>South</em></td><td>4</td><td>3</td><td>4</td>
</tr>
</table>
</body>
</html>

La feuille de style suivante transforme les données en SVG :

<xsl:stylesheet version="1.0"
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                xmlns="http://www.w3.org/Graphics/SVG/SVG-19990812.dtd">
<xsl:output method="xml" indent="yes" media-type="image/svg"/>
<xsl:template match="/">
<svg width = "3in" height="3in">
    <g style = "stroke: #000000">
        <!-- draw the axes -->
        <line x1="0" x2="150" y1="150" y2="150"/>
        <line x1="0" x2="0" y1="0" y2="150"/>
        <text x="0" y="10">Revenue</text>
        <text x="150" y="165">Division</text>
        <xsl:for-each select="sales/division">
            <!-- define some useful variables -->
            <!-- the bar's x position -->
            <xsl:variable name="pos"
                          select="(position()*40)-30"/>
            <!-- the bar's height -->
            <xsl:variable name="height"
                          select="revenue*10"/>
            <!-- the rectangle -->
            <rect x="{$pos}" y="{150-$height}"
                  width="20" height="{$height}"/>
            <!-- the text label -->
            <text x="{$pos}" y="165">
                <xsl:value-of select="@id"/>
            </text>
            <!-- the bar value -->
            <text x="{$pos}" y="{145-$height}">
                <xsl:value-of select="revenue"/>
            </text>
        </xsl:for-each>
    </g>
</svg>
</xsl:template>
</xsl:stylesheet>

La sortie SVG est :

<svg width="3in" height="3in"
     xmlns="http://www.w3.org/Graphics/SVG/svg-19990412.dtd">
    <g style="stroke: #000000">
        <line x1="0" x2="150" y1="150" y2="150"/>
        <line x1="0" x2="0" y1="0" y2="150"/>
        <text x="0" y="10">Revenue</text>
        <text x="150" y="165">Division</text>
        <rect x="10" y="50" width="20" height="100"/>
        <text x="10" y="165">North</text>
        <text x="10" y="45">10</text>
        <rect x="50" y="110" width="20" height="40"/>
        <text x="50" y="165">South</text>
        <text x="50" y="105">4</text>
        <rect x="90" y="90" width="20" height="60"/>
        <text x="90" y="165">West</text>
        <text x="90" y="85">6</text>
    </g>
</svg>

La feuille de style suivante produit les données en VRML :

<xsl:stylesheet version="1.0"
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<!-- gébère le texte en sortie avec l'extensoin mime model/vrml, en utilisant un jeu de caractères par défaut -->
<xsl:output method="text" encoding="UTF-8" media-type="model/vrml"/>
        <xsl:template match="/">#VRML V2.0 utf8
  # externproto definition d'un élément barre  EXTERNPROTO bar [
  field SFInt32 x
  field SFInt32 y
  field SFInt32 z
  field SFString name
  ]
  "http://www.vrml.org/WorkingGroups/dbwork/barProto.wrl"
  # inline contenant les axes du graphique  Inline {
        url "http://www.vrml.org/WorkingGroups/dbwork/barAxes.wrl"
        }

                <xsl:for-each select="sales/division"> bar {
        x <xsl:value-of select="revenue"/>
        y <xsl:value-of select="growth"/>
        z <xsl:value-of select="bonus"/>
        name "<xsl:value-of select="@id"/>"
        }
                </xsl:for-each>
        </xsl:template>
</xsl:stylesheet>

La sortie VRML est :

#VRML V2.0 utf8
  # externproto definition d'un élément barre  EXTERNPROTO bar [
  field SFInt32 x
  field SFInt32 y
  field SFInt32 z
  field SFString name
  ]
  "http://www.vrml.org/WorkingGroups/dbwork/barProto.wrl"
  # inline contenant les axes du graphique  Inline {
        url "http://www.vrml.org/WorkingGroups/dbwork/barAxes.wrl"
        }

                 bar {
        x 10
        y 9
        z 7
        name "North"
        }
                 bar {
        x 4
        y 3
        z 4
        name "South"
        }
                 bar {
        x 6
        y -1.5
        z 2
        name "West"
        }

E Avertissements (Non-Normatif)

Les personnes suivantes ont contribué à la rédaction de cette épreuve :

Cette spécification a été développée et approuvée pour publication par le groupe de travail du W3C sur XSL (W3C XSL Working Group). L'approbation de cette spécification par le groupe de travail n'implique pas nécessairement que tous les membres du groupe de travail aient votés en faveur de cette approbation. Les membres actuels de ce groupe de travail sont :
Sharon Adler, IBM (Co-Chair); Anders Berglund, IBM; Perin Blanchard, Novell; Scott Boag, Lotus; Larry Cable, Sun; Jeff Caruso, Bitstream; James Clark; Peter Danielsen, Bell Labs; Don Day, IBM; Stephen Deach, Adobe; Dwayne Dicks, SoftQuad; Andrew Greene, Bitstream; Paul Grosso, Arbortext; Eduardo Gutentag, Sun; Juliane Harbarth, Software AG; Mickey Kimchi, Enigma; Chris Lilley, W3C; Chris Maden, Exemplary Technologies; Jonathan Marsh, Microsoft; Alex Milowski, Lexica; Steve Muench, Oracle; Scott Parnell, Xerox; Vincent Quint, W3C; Dan Rapp, Novell; Gregg Reynolds, Datalogics; Jonathan Robie, Software AG; Mark Scardina, Oracle; Henry Thompson, University of Edinburgh; Philip Wadler, Bell Labs; Norman Walsh, Arbortext; Sanjiva Weerawarana, IBM; Steve Zilles, Adobe (Co-Chair)

F Changements depuis la recommandation proposée (Non-Normatif)

Les points suivants sont les changements faits depuis la recommandation proposée :

L'attribut xsl:version est requis sur un élément résultat littéral utilisé comme feuille de style (voir [2.3 Feuille de style sous la forme d'un élément littéral résultat]).

L'attribut data-type de l'élément xsl:sort peut utiliser un nom préfixé pour spécifier un type de données non spécifié par XSLT (voir [10 Ordonnancement]).

G Fonctionalités à l'étude pour une future version de XSLT (Non-Normatif)

Les fonctionalités suivantes sont en cours d'évaluation pour les versions de XSLT au delà de la verison 1.0 :

une expression conditionnelle;

le support des types de données et des archétypes des schémas XML;

le support de quelquechose équivalent aux règles qui étaient présentes dans la première version soumise de XSL;

un attribut pour contrôler l'espace de noms par défaut pour les noms apparaîssants dans les attributs XSLT;

le support des références d'entités;

le support des DTD dans le modèle de données;

le support des notations dans le modèle de données;

un moyen pour obtenir d'un élément la liste des éléments qui le référencent (par exemple par un attribut IDREF);

un moyen plus facile pour obtenir un ID ou une clé d'un autre document;

le support des expressions régulières pour établir des correspondances avec tout ou partie des noeuds textuels, valeurs d'attributs, noms d'attributs et les noms des types d'éléments;

les comparaisons indépendantes de la casse;

la normalisation des chaînes de caractères avant leur comparaison, par exemple pour la compatibilité des caractères;

une fonction string resolve(node-set) dont l'argument sera une URI relative que la fonction trasformera en URI absolue en s'appuyant sur l'URI de base du noeud;

les documents résultat multiples;

l'utilisation du noeud courant comme valeur par défaut de l'attribut select de l'élément xsl:value-of ;

un attribut sur l'élément xsl:attributepour contrôler comment la valeur d'attribut est normalisée;

des attributs additionels sur l'élément xsl:sort pour fournir plus de contrôles sur les tris, comme par exemple les scripts d'ordonnancements relatifs;

un moyen de mettre un texte identifié par une URI dans l'arbre résultat;

autoriser les unions dans les étapes de localisation (par exemple foo/(bar|baz));

autoriser sur les fragments de l'arbre résultat toutes les opérations qui sont autorisées sur les ensembles de noeuds;

un moyen pour regrouper ensemble les noeuds consécutifs ayant des sous-éléments ou des attributs dupliqués;

des fonctions pour manipuler l'attribut style de HTML plus facilement.