|
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 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. |
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.
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.
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.
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
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)
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é.
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.
<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.
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.
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.
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')
< 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.
XSLT fournit deux mécanismes pour combiner des 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'.
<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.
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 :
xsl:stylesheet peut
survenir dans un document XML autrement que comme élément
racine.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.
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.
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.
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.
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].
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.
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.
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.
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.
| [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.
<!--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.
<!--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.
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.
<!--
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>
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.
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.
<!--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.
Cette section décrit les instructions qui créent directement des noeuds dans l'arbre résultant.
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.
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.
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:
xsl:attribute ; les implémentations
peuvent signaler l'erreur ou ignorer l'attribut.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
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.
<!--
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 &