Académique Documents
Professionnel Documents
Culture Documents
Support PDF
Support PDF
Cours XML
Olivier Carton
L'essentiel de XML: Cours XML
Olivier Carton
Version du 13/10/2015
Copyright 2007-2014 Olivier Carton
Rsum
Ce document est le support d'un cours XML donn en M2 Pro l'Universit Paris Diderot. L'objectif est de
prsenter les aspects essentiels de XML de manire concise et illustre par de nombreux exemples. Les principaux
thmes abords sont la syntaxe de XML, la validation de documents par des DTD, des schmas et des schematrons,
le langage XPath, la transformation de document par XSLT ainsi que la programmation.
Ce support de cours est actuellement en cours de rdaction. Il contient encore beaucoup d'erreurs et d'omissions.
Certaines parties mritent d'tre dveloppes et/ou reprises. Une certaine indulgence est donc demande au lecteur.
Toutes les corrections, mme les plus mineures, suggestions et encouragements sont les bienvenus. Ils participent
l'amlioration de ce document pour le bien de tous.
Table des matires
1. Prsentation de XML .................................................................................................................. 1
1.1. Historique ...................................................................................................................... 1
1.2. Intrts .......................................................................................................................... 1
1.3. Langages apparents ........................................................................................................ 3
1.4. Dialectes ........................................................................................................................ 4
1.5. DocBook ........................................................................................................................ 5
1.6. Conventions .................................................................................................................... 5
2. Syntaxe de XML ....................................................................................................................... 7
2.1. Premier exemple ............................................................................................................. 7
2.2. Caractres ...................................................................................................................... 7
2.3. URI, URL et URN ......................................................................................................... 12
2.4. Syntaxe et structure ........................................................................................................ 14
2.5. Composition globale d'un document .................................................................................. 14
2.6. Prologue ....................................................................................................................... 15
2.7. Corps du document ........................................................................................................ 16
2.8. Exemples minimaux ....................................................................................................... 22
2.9. XInclude ...................................................................................................................... 23
3. DTD ...................................................................................................................................... 25
3.1. Un premier exemple ....................................................................................................... 25
3.2. Dclaration de la DTD ................................................................................................... 25
3.3. Contenu de la DTD ........................................................................................................ 28
3.4. Commentaires ............................................................................................................... 28
3.5. Entits ......................................................................................................................... 29
3.6. Dclaration d'lment ..................................................................................................... 32
3.7. Dclaration d'attribut ...................................................................................................... 35
3.8. Outils de validation ........................................................................................................ 40
4. Espaces de noms ...................................................................................................................... 41
4.1. Introduction .................................................................................................................. 41
4.2. Identification d'un espace de noms .................................................................................... 42
4.3. Dclaration d'un espace de noms ...................................................................................... 42
4.4. Porte d'une dclaration .................................................................................................. 43
4.5. Espace de noms par dfaut .............................................................................................. 43
4.6. Attributs ....................................................................................................................... 45
4.7. Espace de noms XML .................................................................................................... 45
4.8. Espaces de noms et DTD ................................................................................................ 45
4.9. Quelques espaces de noms classiques ................................................................................ 46
5. Schmas XML ......................................................................................................................... 48
5.1. Introduction .................................................................................................................. 48
5.2. Un premier exemple ....................................................................................................... 49
5.3. Structure globale d'un schma .......................................................................................... 50
5.4. Dclarations d'lments ................................................................................................... 52
5.5. Dfinitions de types ....................................................................................................... 54
5.6. Constructions de types .................................................................................................... 61
5.7. Dclarations d'attributs .................................................................................................... 68
5.8. Extension de types ......................................................................................................... 72
5.9. Restriction de types ........................................................................................................ 74
5.10. Substitutions ................................................................................................................ 82
5.11. Groupes d'lments et d'attributs ..................................................................................... 96
5.12. Contraintes de cohrence ............................................................................................... 99
5.13. Espaces de noms ........................................................................................................ 105
5.14. Imports d'autres schmas ............................................................................................. 108
5.15. Expressions rationnelles ............................................................................................... 109
6. XPath ................................................................................................................................... 112
6.1. Donnes et environnement ............................................................................................. 112
6.2. Expressions de chemins ................................................................................................. 120
iii
L'essentiel de XML
iv
Chapitre 1. Prsentation de XML
Le langage XML (eXtended Markup Language) est un format gnral de documents orient texte. Il s'est impos
comme un standard incontournable de l'informatique. Il est aussi bien utilis pour le stockage de documents que
pour la transmission de donnes entre applications. Sa simplicit, sa flexibilit et ses possibilits d'extension ont
permis de l'adapter de multiples domaines allant des donnes gographiques au dessin vectoriel en passant par
les changes commerciaux. De nombreuses technologies se sont dveloppes autour de XML et enrichissent ainsi
son environnement.
Le langage XML drive de SGML (Standard Generalized Markup Language) et de HTML (HyperText Markup
Language). Comme ces derniers, il s'agit d'un langage orient texte et form de balises qui permettent d'organiser
les donnes de manire structure.
1.1. Historique
L'historique suivant retrace les grandes tapes qui ont conduit la naissance de XML. L'anctre de XML est le
langage SGML qui a t introduit en 1986 par C. Goldfarb. SGML a t conu pour des documentations techniques
de grande ampleur. Sa grande complexit a frein son utilisation en dehors des projets de grande envergure. En
1991, T. Berners-Lee a dfini le langage HTML pour le WEB. Ce langage est une version simplifie l'extrme
de SGML, destine une utilisation trs cible. XML est, en quelque sorte, intermdiaire entre SGML et HTML.
Il vite les aspects les plus complexes de SGML tout en gardant suffisamment de souplesse pour une utilisation
gnraliste. La version 1.0 de XML a t publie en 1998 par le consortium W3C (World Wide Web Consortium).
Une redfinition XHTML de HTML 4.0 travers XML a t donne en 1999. Une seconde version 1.1, qui est
simplement une mise jour pour les caractres spciaux en lien avec Unicode, a, ensuite, t publie en 2004.
1.2. Intrts
XML est devenu omniprsent dans le monde de l'informatique. De nombreux standards sont apparus et permettent
des applications diffrentes de stocker mais surtout de partager des documents. L'exemple le plus emblmatique
et le plus connu est le format OpenDocument qui est utilis par OpenOffice, maintenant appel LibreOffice, mais
aussi par d'autres suites bureautiques comme KOffice. Un autre exemple est le format de dessins vectoriels SVG
[Chapitre 11] utilis par Inkscape. Ce succs de XML est en grande partie d ses qualits. Nous allons d'abord
numrer ces caractristiques essentielles qui ont conduit ce dveloppement puis nous allons les dtailler plus
en profondeur.
Structuration forte
Format libre
Une des ides directrices de XML est la sparation entre contenu et prsentation. Il faut bien distinguer le contenu
d'un document et la prsentation qui en est donne. Un mme contenu peut tre rendu de faons trs diffrentes.
Cet ouvrage peut, par exemple, se prsenter comme un livre imprim ou comme une collections de pages WEB. Le
contenu est constitu, au dpart, de textes et d'illustrations mais aussi de liens entre ces lments. L'organisation du
texte en chapitres, sections et sous-sections ainsi que les renvois entre chapitres font partie intgrante du contenu du
document. La prsentation est au contraire la faon de prsenter ce contenu au lecteur. Un des premiers principes
de XML est d'organiser le contenu de manire indpendante de la prsentation. Ce principe de sparation est
dj prsent dans HTML. Le rendu d'une page HTML est globalement confi au navigateur. Les paragraphes
des documents HTML sont, par exemple, crits au kilomtre, sans indication de fins de lignes. Il appartient au
navigateur de les dcouper en lignes en fonction de la taille de la page. C'est trs diffrent d'un document PDF
1
Prsentation de XML
o le dcoupage en pages et en lignes est fige par le document. La sparation n'est cependant pas totale en
HTML. Certaines balises comme <ul> et <li> sont destines la structuration du document. Pour ces deux
balises, il s'agit d'crire une numration. La prsentation de cette numration (marges, symbole marquant chaque
entre, ) est dlgue au navigateur. D'autre balises comme <i> ou <b> donnent davantage des indications
de prsentation. Cette sparation entre contenu et prsentation a t accrue en HTML par l'introduction de CSS
[Chapitre 10]. Une feuille de style CSS est charge de donner au navigateur toutes les informations relatives la
prsentation. Le document HTML peut alors se recentrer sur la structuration du contenu de faon indpendante
de la prsentation.
Cette sparation entre contenu et prsentation est difficile obtenir. Le rdacteur d'un document a souvent une
prsentation en tte et il est tentant pour lui d'essayer de l'imposer.
La sparation est encore plus marque en XML car la signification des balises n'est pas fige comme en HTML. La
rgle est alors de choisir les balises pour organiser le document en privilgiant la structure de celui-ci par rapport
une ventuelle prsentation.
Un second principe de XML est une structuration forte du document. Pour illustrer ce principe, la mme adresse
est donne ci-dessous dans un style HTML puis dans un style XML.
Olivier Carton<br/>
175, rue du Chevaleret<br/>
75013 Paris<br/>
<tt>Olivier.Carton@liafa.univ-paris-diderot.fr</tt>
<address>
<personname>
<firstname>Olivier</firstname> <surname>Carton</surname>
</personname>
<street>
<streetnumber>175</streetnumber> <streetname>rue du Chevaleret</streetname>
</street>
<zipcode>75013</zipcode><city>Paris</city>
<email>Olivier.Carton@liafa.univ-paris-diderot.fr</email>
</address>
Les deux adresses contiennent les mmes informations purement textuelles. La suppression des balises comme
<br/> ou <firstname> donne le mme rsultat pour les deux adresses. Les balises <br/> prsentes dans la
premire adresse permettent le dcoupage en ligne et la balise <tt> indique une police de caractres approprie
pour l'adresse lectronique. Le rle de ces balises est seulement d'assurer un rendu correct de l'adresse. Les
balises dans la premire adresse relvent de la prsentation alors que les balises dans la seconde adresse comme
<firstname> ont un rle smantique. Ces dernires structurent les donnes textuelles et ajoutent ainsi de
l'information. Le nom est, par exemple, dcompos en prnom et nom. Cette information supplmentaire facilite
le traitement des donnes. Il devient, par exemple, trs facile de mettre le nom en majuscule. En revanche, le rendu
exact de l'adresse lectronique est la charge de l'application traitant l'adresse. L'adresse lectronique peut, par
exemple, tre supprime si l'adresse est utilise pour une lettre.
Une des caractristiques essentielles de XML est son extensibilit et sa flexibilit. Contrairement HTML, le
vocabulaire, c'est--dire l'ensemble des balises autorises, n'est pas fig. La norme HTML fixe les balises pouvant
apparatre dans un document ainsi que leur imbrication possible. titre d'exemple, la balise <li> peut uniquement
apparatre dans le contenu d'une balise <ul> ou <ol>. En revanche, les noms des balises XML sont libres.
Il appartient aux auteurs de documents de fixer les balises utilises. Il est seulement ncessaire que les auteurs
s'entendent sur le vocabulaire, c'est--dire la liste des balises utilises, lorsque des documents sont changs. Cette
libert dans les noms de balises permet de dfinir des vocabulaires particuliers adapts aux diffrentes applications.
Il existe ainsi des vocabulaires pour dcrire des dessins vectoriels, des changes commerciaux ou des programmes
de tlvision. Ces vocabulaires particuliers sont appels dialectes XML. Il en existe des centaines voire des milliers
pour couvrir tous les champs d'application de XML.
La libert dans le choix des noms de balises implique une contrepartie. Il devient ncessaire de fixer des rgles
que doivent respecter les documents. Sans ces rgles, il n'est pas possible d'changer et de traiter de manire
automatique ces documents. Ces rgles doivent d'abord fixer le vocabulaire mais aussi les relations entre les
2
Prsentation de XML
balises. Les rgles peuvent, par exemple, imposer qu'une balise <address> (cf. exemple ci-dessus) contiennent
exactement une balise <zipcode> et une balise <city> sans pour autant fixer l'ordre de ces deux balises.
Ces ensembles de rgles portant sur les documents XML sont appels modles de documents. Plusieurs langages
ont t dvelopps pour dcrire ces modles. Le premier de ces langages est celui des DTD (Document Type
Definition) qui est hrit de SGML. Des langages plus puissants, parmi lesquels les schmas ou relax NG, ont t
introduits depuis pour remplacer les DTD. L'intrt principal de ces modles de documents est de pouvoir dcrire
explicitement les rgles respecter pour un document et de pouvoir vrifier si un document donn les respecte
effectivement. Avant ces modles de documents, il n'tait pas rare que les donnes fournir un logiciel ne fussent
pas dcrites de faon trs prcise. Il n'tait alors pas toujours facile de prvoir si des donnes seraient acceptes
par le logiciel, et si ce n'tait pas le cas de dterminer lequel des donnes ou du logiciel tait en cause.
Les modles de document tels que les DTD ou les schmas peuvent servir une vrification automatique des
documents. Il existe plusieurs implmentations de ces modles. Cela autorise la vrification qu'un document donn
satisfait ou non les contraintes spcifies par une DTD ou un schma. Lorsque les entres possibles d'un logiciel
sont dcrites par un tel modle, il est possible de vrifier de faon indpendante du logiciel que les donnes sont
correctes. Cette possibilit est particulirement intressante lors d'changes de documents.
Bien que les donnes prsentes dans un document XML soient fortement structures, le format XML est un format
bas sur du texte. Il est ainsi possible de manipuler un document XML l'aide d'un simple diteur de texte. Il n'est
pas ncessaire d'utiliser un logiciel spcialis. Il existe bien sr des logiciels spcialement conus pour l'dition
de documents XML. Ceux-ci peuvent grandement faciliter la tche de l'auteur mais ils ne sont pas indispensables.
Cet ouvrage a, par exemple, t rdig avec l'diteur Emacs.
Un des atouts d'XML est sa prise en charge native des caractres spciaux grce Unicode. De plus, il est possible
d'utiliser les diffrents codages (UTF-8, Latin-1, ) possibles puisque l'entte d'un document spcifie le codage.
De nombreuses technologies se sont dveloppes autour de XML et en facilitent l'utilisation. Un des champs
d'application est la manipulation et la transformation de documents XML. Il s'agit, par exemple, de rorganiser un
document ou d'en extraire des fragments ou de le transformer compltement dans un autre format comme PDF.
Comme tous les documents XML partagent la mme syntaxe quel que soit leur vocabulaire, des outils permettent
de manipuler ces documents de manire gnrale en s'affranchissant des aspects syntaxiques. Des langages de haut
niveau comme XSLT [Chapitre 8] autorisent la description simple et concise de transformations. Le grand intrt
de ces langages est qu'ils sont indpendants du vocabulaire utilis et qu'ils s'adaptent tous les dialectes XML.
Le langage XSLT manipule chaque document XML sous la forme d'un arbre issu de la structure des donnes. Les
transformations sont dcrites en XSLT par des rgles qui s'appliquent aux fragments dlimits par les balises. Ce
langage XSLT est doublement intressant. D'une part, il constitue un outil la fois pratique et puissant et donc
d'une grande utilit face de nombreux problmes concrets. D'autre part, il reprsente une approche originale de
la programmation car il n'est pas bas sur la programmation imprative ou fonctionnelle de la grande majorit des
langages. ce titre, il est digne d'intrt en soi. Le langage XSLT est lui-mme un dialecte XML car il utilise
la syntaxe XML. Des programmes XSLT peuvent tre eux-mmes manipuls et crs par d'autres programmes
XSLT. Ce mcanisme est d'ailleurs mis en uvre par les schematrons [Chapitre 7].
Le langage XML est totalement libre car il est dvelopp par le W3C. Chacun peut l'utiliser sans devoir acheter
une quelconque licence. Cette absence de droits favorise le dveloppement de logiciels libres mis disposition
de la communaut. Il existe ainsi une trs grande varit de logiciels libres autour de XML qui en couvrent les
diffrents aspects.
XML contient dj un mcanisme pour matrialiser des liens entre des lments d'un document. XLink
et XPointer permettent d'tablir des liens entre documents et plus particulirement entre un lment d'un
document et un fragment d'un autre document. Ils gnralisent les liens hypertextes des documents HTML
en autorisant des liens entre plusieurs documents.
3
Prsentation de XML
XPath est un langage d'expressions permettant de slectionner des lments dans un document XML. Il est
la pierre angulaire du langage XSLT pour la transformation de documents. Il est abord au chapitre 6 de cet
ouvrage.
XQuery est un langage permettant d'extraire des informations partir d'un ou plusieurs documents XML et
de synthtiser de nouvelles informations partir de celles extraites. Il s'apparente un langage d'interrogation
de bases de donnes et joue le rle de SQL pour les documents XML.
1.4. Dialectes
De trs nombreux dialectes ont t dfinis pour appliquer XML des domaines trs varis. Le grand avantage est
que ces diffrents dialectes partagent la mme syntaxe de base et que tous les outils XML peuvent tre utiliss
pour spcifier et manipuler ces documents. Il n'y a nul besoin de dvelopper des outils spcifiques ces diffrents
dialectes. La liste ci-dessous numre quelques uns de ces dialectes.
OpenStreetMap [ ]
Cartes libres
XML Signature [ ]
Format pour les signatures lectroniques
4
Prsentation de XML
OpenDocument [ ]
Format de document pour les applications bureautiques dvelopp au dpart pour OpenOffice mais aussi
utilis par d'autres logiciels libres comme Calligra
DocBook [ ]
De nombreux projets informatiques, comme Ant ou Android utilisent XML pour le stockage de donnes et en
particulier pour les fichiers de configuration.
1.5. DocBook
DocBook est un exemple typique d'utilisation de XML. Il s'agit d'un format pour crire des documents techniques.
Il est particulirement adapt la rdaction de documentations de logiciels. Il est d'ailleurs utilis par de nombreux
projets de logiciels libres, ventuellement de grande ampleur, comme le projet KDE. Cet ouvrage a t rdig
en utilisant DocBook. L'intgralit du texte est rpartie en plusieurs fichiers XML. Afin d'obtenir une mise en
page de qualit, les documents XML sont convertis, avec le langage XSLT, en un document LaTeX qui peut alors
produire un document PDF.
DocBook tait au dpart bas sur SGML mais il s'appuie maintenant sur XML dont il est un des dialectes. Il
contient de nombreuses balises permettant de dcrire et de structurer le contenu de faon trs prcise. Il existe
ensuite diffrents outils permettant de traduire un document DocBook, en une seule page HTML, en plusieurs
pages HTML avec des liens ou encore en un document PDF.
DocBook met l'accent sur l'organisation et la structure du document. Son vocabulaire contient de trs nombreuses
balises permettant de transcrire trs finement la smantique de chaque fragment, la manire de la seconde adresse
donne au dbut de cette introduction. Cet exemple est, en fait, trs inspir de DocBook. En revanche, DocBook ne
permet pas de spcifier le rendu du document. Il n'est pas possible de donner, par exemple, la couleur ou la police
de caractres utiliser pour le texte. L'ide directrice est qu'un document DocBook doit permettre la production
de plusieurs documents finaux partir d'un mme document original : document PDF, pages WEB. Comme les
contraintes de ces diffrents mdia sont trs diverses, il est impossible de pouvoir les spcifier dans le document.
Le choix de DocBook est de donner suffisamment d'indications sur le contenu aux applications qui ralisent les
transformations pour obtenir un rsultat de qualit. Les documents DocBook font souvent partie d'un ensemble de
documentations, comme celle de KDE, dont la prsentation est uniforme et donc dtermine de manire globale.
1.6. Conventions
Certaines conventions sont utilises tout au long de cet ouvrage afin d'en faciliter la lecture. Tous les exemples et
plus gnralement, tous les fragments de texte pouvant apparatre dans un document XML sont crits en utilisant
une police de caractres fixe comme l'exemple d'entte ci-dessous. Les noms des balises sont en particulier crits
avec cette police.
Lorsqu'un fragment de texte comporte des parties gnriques qui doivent tre remplaces pour obtenir un vritable
exemple, ces parties sont crites avec une police de caractres fixe et italique. L'exemple de dclaration de DTD
ci-dessous signifie qu'une telle dclaration doit commencer par <!DOCTYPE suivi du nom de l'lment racine du
document qui peut tre un nom quelconque, diffrent de root-element.
5
Prsentation de XML
L'criture ... signifie qu'une partie sans importance a t omise pour rendre la description plus concise et plus
claire. Un exemple concret est obtenu en remplaant root-element par simple et en compltant la partie
omise.
<!DOCTYPE simple [
<!ELEMENT simple (#PCDATA)>
]>
Les rfrences croises entre les diffrents chapitres et sections de cet ouvrage jouent un rle important. chaque
fois qu'un concept important est mentionn, le numro de section o celui-ci est introduit est indiqu entre crochets
de cette faon [Section 2.2]. Ces indications de navigation facilitent la comprhension des liens entre les diffrentes
notions. La libert a quelques fois t prise de mentionner des liens avec des concepts introduits plus tard dans
l'ouvrage. Ces indications peuvent tre ignores dans une premire lecture.
Les nombres sont gnralement crits en base dcimale comme 123 ou 8364. Lorsque l'criture d'un nombre est
en base hexadcimale, celle-ci commence par x ou 0x comme 0x231 ou x20AC. L'exception cette rgle est
l'criture des points de code des caractres Unicode [Section 2.2] qui sont toujours crits en hexadcimal prcds
de U+ comme U+2023 ou U+20AC.
6
Chapitre 2. Syntaxe de XML
La syntaxe de XML est relativement simple. Elle est constitue de quelques rgles pour l'criture d'une entte et
des balises pour structurer les donnes. Ces rgles sont trs similaires celles du langage HTML utilis pour les
pages WEB mais elles sont, en mme temps, plus gnrales et plus strictes. Elles sont plus gnrales car les noms
des balises sont libres. Elles sont aussi plus strictes car elles imposent qu' toute balise ouvrante corresponde une
balise fermante.
On commence par donner un premier exemple de document XML comme il peut tre crit dans un fichier
bibliography.xml. Ce document reprsente une bibliographie de livres sur XML. Il a t tronqu ci-dessous
pour rduire l'espace occup. Ce document contient une liste de livres avec pour chaque livre, le titre, l'auteur,
l'diteur (publisher en anglais), l'anne de parution, le numro ISBN et ventuellement une URL.
2.2. Caractres
Un document XML est une suite de caractres. Les caractres qui peuvent tre utiliss sont ceux dfinis par la
norme Unicode ISO 10646 [ ] aussi appele UCS pour Universal Character Set. Cette norme recense tous les
7
Syntaxe de XML
caractres des langues connues et tous les symboles utiliss dans les diffrentes disciplines. Elle nomme tous ces
caractres et symboles et leur attribue un code sur 32 bits (4 octets) appel simplement code Unicode ou point de
code dans la terminologie Unicode. Dans la pratique, tous les points de code attribus des caractres se situent
dans l'intervalle de 0 0x10FFFF et ils utilisent donc au plus 21 bits. Cette longueur maximale ne sera pas dpasse
avant longtemps car il reste encore de nombreux points de code non attribus dans cet intervalle pour des usages
futurs. Unicode peut tre vu comme un catalogue de tous les caractres disponibles. Un caractre dont le point
de code est n est dsign par U+n o le nombre n est crit en hexadcimal. L'criture hexadcimale de n n'est
pas prfixe du caractre 'x' car c'est implicite aprs les deux caractres 'U+'. Le caractre Euro '' est, par
exemple, dsign par U+20AC car son point de code est 8364 = 0x20AC. Le sous-ensemble des caractres Unicode
dont les points de code tiennent sur 16 bits (2 octets), c'est--dire entre 0 et 65535 = 0xFFFF est appel BMP
pour Basic Multilingual Plane. Il couvre largement la trs grande majorit des langues usuelles et les symboles
les plus courants.
Les fins de lignes sont normalises par l'analyseur lexical (parser en anglais). Ceci signifie que les diffrentes
combinaisons de fin de ligne sont remplaces par un seul caractre U+0A avant d'tre transmises l'application.
Cette transformation garantit une indpendance vis vis des diffrents systmes d'exploitation. Les combinaisons
remplaces par cette normalisation sont les suivantes.
Les deux caractres U+85 et U+2028 ne peuvent tre correctement dcods qu'aprs la dclaration de l'encodage
des caractres par l'entte [Section 2.6.1]. Leur usage dans l'entte est donc dconseill.
Les caractres autoriss dans les identificateurs sont tous les caractres alphanumriques, c'est--dire les lettres
minuscules [a-z], majuscules [A-Z] et les chiffres [0-9] ainsi que le tiret '-' U+2D, le point '.' U+2E,
les deux points ':' U+3A et le tiret soulign '_' U+5F. Un jeton est une suite quelconque de ces caractres. Un
nom XML est un jeton qui, en outre, commence par une lettre [a-zA-Z], le caractre ':' ou le caractre '_'.
8
Syntaxe de XML
Les deux caractres '-' et '.' ainsi que les chiffres ne peuvent pas apparatre au dbut des noms. Il n'y a pas, a
priori, de limite la taille des identificateurs mais certains logiciels peuvent en imposer une dans la pratique.
Le caractre ':' est rserv l'utilisation des espaces de noms [Chapitre 4]. De fait, il ne peut apparatre qu'une
seule fois pour sparer un prfixe du nom local dans les noms des lments et des attributs. Les espaces de noms
amnent distinguer les noms ayant un caractre ':', appels noms qualifis et les autres, appels par opposition
noms non qualifis.
Les noms commenant par les trois lettres xml en minuscule ou majuscule, c'est--dire par une chane de
[xX][mM][lL] sont rservs aux usages internes de XML. Ils ne peuvent pas tre utiliss librement dans les
documents mais ils peuvent cependant apparatre pour des utilisations spcifiques prvues par la norme. Les noms
commenant par xml: comme xml:base font partie de l'espace de noms XML [Section 4.7].
Noms rservs :
xml:id et xml-stylesheet
La norme XML 1.1 prvoit que tout caractre Unicode de catgorie lettre peut apparatre dans les identificateurs.
Il est, par exemple, possible d'avoir des noms d'lments avec des caractres accentus. Il est cependant conseill
de se limiter aux caractres ASCII de [a-zA-Z] pour assurer une meilleure compatibilit. Beaucoup de logiciels
ne grent pas les autres caractres dans les identificateurs.
2.2.4. Codage
Chaque caractre possde un point de code sur 32 bits mais un document ne contient pas directement ces points de
code des caractres. Ce codage serait inefficace puisque chaque caractre occuperait 4 octets. Chaque document
utilise un codage pour crire les points de code des caractres. Il existe diffrents codages dont le codage par dfaut
UTF-8. Certains codages permettent d'crire tous les points de code alors que d'autres permettent seulement d'crire
un sous-ensemble comme le BMP. Le codage utilis par un document est indiqu dans l'entte [Section 2.6.1] de
celui-ci. Les principaux codages utiliss par les documents XML sont dcrits ci-dessous.
US-ASCII
Ce codage permet uniquement de coder les points de code de 0 0x7F des caractres ASCII.
UCS-4 ou UTF-32 [ ]
Chaque caractre est cod directement par son point de code sur quatre octets. Ce codage permet donc de
coder tous les caractres Unicode.
UCS-2 [ ]
Chaque caractre est cod par son point de code sur deux octets. Ce codage permet donc uniquement de coder
les caractres du BMP.
UTF-16 [ ]
Ce codage concide essentiellement avec UCS-2 l'exception de la plage de 2048 positions de 0xD800
0xDFFF qui permet de coder des caractres en dehors du BMP dont le point de code utilise au plus 20 bits.
L'exclusion de cette plage ne pose aucun problme car elle ne contient aucun point de code attribu un
caractre. Un point de code ayant entre 17 et 20 bits est scind en deux blocs de 10 bits rpartis sur une paire
de mots de 16 bits. Le premier bloc de 10 bits est prfix des 6 bits 110110 pour former un premier mot de
16 bits et le second bloc de 10 bits est prfix des 6 bits 110111 pour former un second mot de 16 bits.
9
Syntaxe de XML
UTF-8 [ ]
Ce codage est le codage par dfaut de XML. Chaque caractre est cod sur un nombre variable de 1 4 octets.
Les caractres de l'ASCII sont cods sur un seul octet dont le bit de poids fort est 0. Les caractres en dehors
de l'ASCII utilisent au moins deux octets. Le premier octet commence par autant de 1 que d'octets dans la
squence suivis par un 0. Les autres octets commencent par 10. Ce codage peut uniquement coder des points
de code ayant au maximum 21 bits mais tous les points de code attribus ne dpassent pas cette longueur.
Le symbole de l'Euro '' U+20AC, est, par exemple, cod par les trois octets xE2 x82 xAC = 11100010
10000010 10101100. Le symbole de la croche '##' U+1D160 est, quant lui, cod par les 4 octets
xF0 x9D x85 xA0 = 11110000 10011101 10000101 10100000. Ce codage a l'avantage d'tre
relativement efficace pour les langues europennes qui comportent beaucoup de caractres ASCII. Il est, en
revanche, peu adapt aux langues asiatiques dont les caractres ncessitent 3 octets alors que 2 octets sont
suffisants avec UTF-16.
Chaque caractre est cod sur un seul octet. Ce codage concide avec l'ASCII pour les points de code de 0
0x7F. Les codes de 0x80 0xFF sont utiliss pour d'autres caractres (caractres accentus, cdilles, )
des langues d'Europe de l'ouest.
Ce codage est une mise jour du codage ISO-8859-1 dont il diffre uniquement en 8 positions. Les caractres
'', '', '', '', '', '', '' et '' remplacent les caractres '' U+A4, '' U+A6, '' U+A8, '' U+B4,
'' U+B8, '' U+BC, '' U+BD et '' U+BE moins utiles pour l'criture des langues europennes. Le
symbole de l'Euro '' U+20AC, est, par exemple, cod par l'unique octet xA4 = 10100100.
Le tableau suivant donne la suite d'octets pour le mot Htrogne pour quelques codages classiques. Comme
les points de code de x00 xFF d'Unicode concident avec le codage des caractres de ISO-8859-1, le codage en
UTF-16 est obtenu en insrant un octet nul 00 avant chaque octet du codage en ISO-8859-1. Le codage en UTF-32
est obtenu en insrant dans le codage en UTF-16 deux octets nuls avant chaque paire d'octets.
10
Syntaxe de XML
Bien que certains codages ne permettent pas de coder tous les points de code, il est nanmoins possible d'insrer
n'importe quel caractre Unicode en donnant explicitement son point de code avec une des deux syntaxes suivantes.
Ces syntaxes peuvent tre utilises pour n'importe quel point de code mme si celui-ci peut tre crit avec le
codage du document. Elles sont, en particulier, pratiques lorsque les diteurs de texte affichent mal certains
caractres. Les deux syntaxes prennent les formes &#point de code dcimal; ou &#xpoint de code
hexadcimal;. Le caractre Euro '' peut par exemple tre insr par € ou €. Pour ces deux
syntaxes, c'est le point de code du caractre qui est crit en dcimal ou en hexadcimal et non pas sa transcription
dans le codage du document.
Afin de savoir quel est le mode utilis dans un document XML, le document commence par le caractre U+FEFF.
Ce caractre est appel espace inscable de largeur nulle (zero-width no-break space en anglais) mais il a t
remplac, pour cet emploi, par le caractre U+2060. Il est maintenant uniquement utilis comme marque d'ordre
des octets (Byte order mark ou BOM en anglais). Cette marque est sans ambigut car il n'existe pas de caractre de
point de code 0xFFFE. Le tableau suivant rcapitule les squences des premiers octets d'un document en fonction
du codage et du mode gros-boutiste ou petit-boutiste. Les valeurs 0x3C, 0x3F et 0x78 sont les points de code des
trois premiers caractres '<', '?' et 'x' de l'entte [Section 2.6.1].
2.2.5. Collations
Certaines ligatures comme le caractre '' U+153 sont considres par Unicode comme un seul caractre plutt
que comme la fusion des deux caractres 'oe'. Il s'ensuit que les deux mots cur et coeur sont, a priori,
considrs comme distincts. Ce problme est rsolu par l'utilisation de collations lors du traitement des documents.
Une collation est une collection de rgles qui tablissent des quivalences entre des caractres ou des suites
de caractres. Une collation peut, par exemple, dclarer que le caractre '' U+153 est quivalent aux deux
caractres 'oe' ou que la lettre '' U+DF est quivalente aux deux lettres 'ss'. Une collation tablit aussi
11
Syntaxe de XML
l'ordre des caractres utilis pour l'ordre lexicographique. Elle peut, par exemple, dclarer que le caractre ''
se place entre les caractres 'e' et 'f'. La collation par dfaut est base sur les points de code des caractres.
Le caractre '' U+E9 se trouve, pour cette collation, aprs le caractre 'z' U+7A et le mot zbre est donc
avant le mot talon dans l'ordre lexicographique.
2.2.6. Normalisation
Le mme caractre peut avoir plusieurs points de code. Cette ambigut provient du fait qu'Unicode a t construit
en fusionnant plusieurs codages et qu'il tente de rester compatible avec chacun d'eux. Le caractre '' est en
mme temps le caractre U+B5 qui provient de Latin-1 et le caractre U+3BC qui provient du bloc des caractres
grecs. D'autres caractres peuvent avoir un point de code mais peuvent, en mme temps, correspondre une suite
de plusieurs points de code. Le caractre '' est, par exemple, le caractre U+F6 mais il correspond galement
la suite U+6F U+308 forme du caractre 'o' suivi du caractre spcial trma '' U+308. Ce codage
multiple conduit des problmes, en particulier pour la comparaison des chanes de caractres. Pour palier ce
problme, Unicode introduit des normalisations qui transforment les diffrents codages en un codage canonique.
La normalisation la plus standard est la normalisation C. Celle-ci transforme, par exemple, la suite de caractres
U+6F U+308 en le caractre '' U+F6. La normalisation d'une chane de caractres peut tre obtenue avec la
fonction XPath normalize-unicode() [Section 6.3.3].
URI
Uniform Resource Identifier
URL
Uniform Resource Locator
URN
Uniform Resource Name
URI
URL URN
La notion la plus gnrale est celle d'URI. Les URI comprennent les URL et les URN mme si certains URI
peuvent tre simultanment des URL et des URN. Les liens entre ces diffrents termes sont illustrs la figure. Un
URI est un identifiant qui permet de dsigner sans ambigut un document ou plus gnralement une ressource.
Cet identifiant doit donc tre unique de manire universelle. Une URL identifie un document en spcifiant un
mcanisme pour le retrouver. Elle est compose d'un protocole suivi d'une adresse permettant de rcuprer le
document avec le protocole. Un URN est, au contraire, un nom donn un document indpendamment de la faon
d'accder au document. Un exemple typique d'URN est l'URN form partir du numro ISBN d'un livre comme
urn:isbn:978-2-7117-2077-4. Cet URN identifie le livre Langages formels, calculabilit et complexit
mais n'indique pas comment l'obtenir.
La syntaxe gnrale des URI prend la forme scheme:ident o scheme est un schma d'URI et o ident est
un identifiant obissant une syntaxe propre au schma scheme. Chaque schma dfinit un sous-espace des URI.
12
Syntaxe de XML
Dans le cas d'une URL, le schma est un protocole d'accs au document comme http, sip, imap ou ldap.
Le schma utilis pour tous les URN est urn. Il est gnralement suivi de l'identificateur d'un espace de noms
comme isbn. Des exemples d'URI sont donns ci-dessous. Les deux derniers URI de la liste sont des URN.
http://www.omega-one.org/~carton/
sftp://carton@omega-one.org
tel:+33-1-57-27-92-54
sip:0957279254@freephonie.net
file://home/carton/Enseignement/XML/Cours/XSLT
urn:oasis:names:tc:docbook:dtd:xml:docbook:5.1
urn:publicid:-:W3C:DTD+HTML+4.0:EN
Dans la pratique, la plupart des URI utilises sont des URL et les deux termes peuvent pratiquement tre considrs
comme synonymes.
Pour comprendre comment une URL de base se combine avec une URL, il faut d'abord comprendre la structure
d'une URL. La description donne ci-dessous se limite aux aspects indispensables pour apprhender la rsolution
des URL. Chaque URL se dcompose en trois parties.
Protocole d'accs
Une URL commence obligatoirement par le nom d'un protocole d'accs suivi du caractre ':'. Les principaux
protocoles sont http, https, ftp et file.
Adresse Internet
Le protocole est suivi d'une adresse Internet qui commence par les deux caractres '//'. Cette adresse est
absente dans le cas du protocole file.
Chemin d'accs
L'URL se termine par un chemin d'accs dans l'arborescence des fichiers. Ce chemin se dcompose lui-mme
en le nom du rpertoire et le nom du fichier. Ce dernier est form de tous les caractres aprs le dernier
caractre '/'.
1. Si l'URL url est elle-mme une URL complte qui commence par un protocole, le rsultat de la combinaison
est l'URL url sans tenir compte de l'URL base.
13
Syntaxe de XML
2. Si l'URL url est un chemin absolu commenant par le caractre '/', le rsultat est obtenu en remplaant la
partie chemin de l'URL base par l'URL url. L'URL url est donc ajoute aprs la partie adresse Internet
de l'URL base.
3. Si l'URL url est un chemin relatif ne commenant pas par le caractre '/', le rsultat est obtenu en remplaant
le nom du fichier de l'URL base par l'URL url. Le chemin relatif est donc concatn avec le nom du
rpertoire.
Les exemples ci-dessous illustrent les diffrents cas. On suppose que l'URL base est fixe gale l'URL
http://www.somewhere.org/Teaching/index.html. Pour chacune des valeurs de l'URL url, on
donne la valeur de l'URL obtenue par combinaison de l'URL base avec l'URL url.
Un document XML est gnralement contenu dans un fichier texte dont l'extension est .xml. Il peut aussi tre
rparti en plusieurs fichiers en utilisant les entits externes [Section 3.5.1.4] ou XInclude [Section 2.9]. Les fichiers
contenant des documents dans un dialecte XML peuvent avoir une autre extension qui prcise le format. Les
extensions pour les schmas XML [Chapitre 5], les feuilles de style XSLT [Chapitre 8], les dessins en SVG
[Chapitre 11] sont, par exemple, .xsd, .xsl et .svg.
Un document XML est, la plupart du temps, stock dans un fichier mais il peut aussi tre dmatrialis et exister
indpendamment de tout fichier. Il peut, par exemple, exister au sein d'une application qui l'a construit. Une
chane de traitement de documents XML peut produire des documents intermdiaires qui sont dtruits la fin. Ces
documents existent uniquement pendant le traitement et sont jamais mis dans un fichier.
14
Syntaxe de XML
Prologue
Il contient des dclarations facultatives.
Corps du document
C'est le contenu mme du document.
Le document se dcoupe en fait en deux parties conscutives qui sont le prologue et le corps. Les commentaires
et les instructions de traitement sont ensuite librement insrs avant, aprs et l'intrieur du prologue et du corps.
La structure globale d'un document XML est la suivante.
Dans l'exemple donn au dbut de ce chapitre, le prologue comprend les trois premires lignes du fichier. La
premire ligne est l'entte XML et la deuxime est simplement un commentaire utilis par Emacs pour mmoriser
le nom du fichier et sa date de dernire modification. La troisime ligne est la dclaration d'une DTD externe
contenue dans le fichier bibliography.dtd. Le corps du document commence la quatrime ligne du fichier
avec la balise ouvrante <bibliography>. Il se termine la dernire ligne de celui-ci avec la balise fermante
</bibliography>.
2.6. Prologue
Le prologue contient deux dclarations facultatives mais fortement conseilles ainsi que des commentaires
[Section 2.7.5] et des instructions de traitement [Section 2.7.6]. La premire dclaration est l'entte XML qui
prcise entre autre la version de XML et le codage du fichier. La seconde dclaration est la dclaration du type
du document (DTD) qui dfinit la structure du document. La dclaration de type de document est omise lorsqu'on
utilise des schmas XML [Chapitre 5] ou d'autres types de modles qui remplacent les DTD. La structure globale du
prologue est la suivante. Dans le prologue, tous les caractres d'espacement [Section 2.2.2] sont interchangeables
mais l'entte est gnralement place, seule, sur la premire ligne du fichier.
Les diffrentes parties du prologue sont dtailles dans les sections suivantes.
L'entte doit se trouver au tout dbut du document. Ceci signifie que les trois caractres '<?xml' doivent tre les
cinq premiers caractres du document, ventuellement prcds d'une marque d'ordre des octets [Section 2.2.4.1].
Cette entte peut contenir trois attributs version, encoding et standalone. Il ne s'agit pas vritablement
d'attributs [Section 2.7.3] car ceux-ci sont rservs aux lments mais la syntaxe identique justifie ce petit abus de
langage. Chaque attribut a une valeur dlimite par une paire d'apostrophes ''' ou une paire de guillemets '"'.
15
Syntaxe de XML
L'attribut version prcise la version d'XML utilise. Les valeurs possibles actuellement sont 1.0 ou 1.1.
L'attribut encoding prcise le codage des caractres [Section 2.2.4] utilis dans le fichier. Les principales valeurs
possibles sont US-ASCII, ISO-8859-1, UTF-8, et UTF-16. Ces noms de codage peuvent aussi tre crits en
minuscule comme iso-8859-1 ou utf-8. L'attribut standalone prcise si le fichier est autonome, c'est--
dire s'il existe des dclarations externes qui affectent le document. La valeur de cet attribut peut tre yes ou no
et sa valeur par dfaut est no. Les dclarations externes peuvent provenir d'une DTD externe [Section 3.2.2] o
d'entits paramtres [Section 3.5.2]. Elles peuvent affecter le contenu du document en donnant, par exemple, des
valeurs par dfaut [Section 3.7.3] des attributs. La valeur de l'attribut standalone influence galement la prise
en compte des caractres d'espacement dans les contenus purs [Section 3.6.1.1] lors de la validation par une DTD.
L'attribut version est obligatoire et l'attribut encoding l'est aussi ds que le codage des caractres n'est pas le
codage par dfaut UTF-8. Quelques exemples d'entte XML sont donns ci-dessous.
<?xml version="1.0"?>
<?xml version='1.0' encoding='UTF-8'?>
<?xml version="1.1" encoding="iso-8859-1" standalone="no"?>
Lorsqu'un document est scind en plusieurs fragments dans diffrents fichiers inclus par des entits externes
[Section 3.5.1.4] ou par XInclude [Section 2.9], chacun des fragments peut commencer par une entte. L'intrt
est de pouvoir spcifier un codage des caractres diffrent.
La forme prcise de cette dclaration est explicite au chapitre consacr aux DTD [Chapitre 3].
Comme dans une arborescence de fichiers, il y a un lment appel lment racine qui contient l'intgralit du
document.
2.7.1. lments
Un lment est form d'une balise ouvrante, d'un contenu et de la balise fermante correspondante. La balise
ouvrante prend la forme <name> forme du caractre '<' U+3C, du nom name de l'lment et du caractre
'>' U+3E. Des attributs [Section 2.7.3] peuvent ventuellement tre ajouts entre le nom et le caractre '>'. La
balise fermante prend la forme </name> forme des deux caractres '</' U+3C et U+2F, du nom name de
l'lment et du caractre '>'. Les noms des lments sont des noms XML [Section 2.2.3] quelconques. Ils ne sont
pas limits un ensemble fix de noms prdfinis comme en HTML. Le contenu d'un lment est form de tout
ce qui se trouve entre la balise ouvrante et la balise fermante (cf. figure). Il peut tre constitu de texte, d'autres
lments, de commentaires [Section 2.7.5] et d'instructions de traitement [Section 2.7.6].
16
Syntaxe de XML
Dans la balise ouvrante, le caractre '<' doit tre immdiatement suivi du nom de l'lment. En revanche, il peut
y avoir des espaces entre le nom et le caractre '>'. La balise fermante ne peut pas contenir d'espace.
ou
Lorsque le contenu est vide, c'est--dire lorsque la balise fermante suit immdiatement la balise ouvrante, les deux
balises peuvent ventuellement se contracter en une seule balise de la forme <name/> forme du caractre '<',
du nom name et des deux caractres '/>'. Cette contraction est privilgier lorsque l'lment est dclar vide
par une DTD [Section 3.6.4].
< t ag1> < /t ag1> < t ag2> < /t ag2> < t ag1> < t ag2> < /t ag2> < /t ag1> < t ag1> < t ag2> < /t ag1> < /t ag2>
<parent>
<sibling1> ... </sibling1>
<sibling2> ... </sibling2>
<self>
<child1> ... <desc1></desc1> ... <desc2></desc2> ... </child1>
<child2> ... </child2>
<child3> ... <desc3><desc4> ... </desc4></desc3> ... </child3>
</self>
<sibling3> ... </sibling3>
</parent>
parent
desc4
17
Syntaxe de XML
Dans l'exemple ci-dessus, le contenu de l'lment self s'tend de la balise ouvrante <child1> jusqu' la
balise fermante </child3>. Ce contenu comprend tous les lments child1, child2 et child3 ainsi que
les lments desc1, desc2, desc3 et desc4. Tous les lments qu'il contient sont appels descendants de
l'lment self. Parmi ces descendants, les lments child1, child2 et child3 qui sont directement inclus
dans self sans lment intermdiaire sont appels les enfants de l'lment self. Inversement, l'lment parent
qui contient directement self est appel le parent de l'lment self. Les autres lments qui contiennent
l'lment self sont appels les anctres de l'lment self. Les autres enfants sibling1, sibling2 et
sibling3 de l'lment parent sont appels les frres de l'lment self. Ces relations de parent entre les
lments peuvent tre visualises comme un arbre gnalogique (cf. figure).
Tout le corps du document doit tre compris dans le contenu d'un unique lment appel lment racine. Le nom de
cet lment racine est donn par la dclaration de type de document [Section 3.2] si celle-ci est prsente. L'lment
bibliography est l'lment racine de l'exemple donn au dbut du chapitre.
Il est souvent fastidieux d'inclure beaucoup de caractres spciaux l'aide des entits. Les sections littrales,
appeles aussi sections CDATA en raison de leur syntaxe, permettent d'inclure des caractres qui sont recopis
l'identique. Une section littrale commence par la chane de caractres '<![CDATA[' et se termine par la chane
']]>'. Tous les caractres qui se trouvent entre ces deux chanes font partie du contenu du document, y compris
les caractres spciaux.
Une section CDATA ne peut pas contenir la chane de caractres ']]>' qui permet l'analyseur lexical de
dtecter la fin de la section. Il est en particulier impossible d'imbriquer des sections CDATA.
2.7.3. Attributs
Les balises ouvrantes peuvent contenir des attributs associs des valeurs. L'association de la valeur l'attribut
prend la forme attribute='value' ou la forme attribute="value" o attribute et value sont
respectivement le nom et la valeur de l'attribut. Chaque balise ouvrante peut contenir zro, une ou plusieurs
associations de valeurs des attributs comme dans les exemples gnriques suivants.
Voici ci-dessous d'autres exemples concrets de balises ouvrantes avec des attributs. Ces exemples sont
respectivement tirs d'un document XHTML, d'un schma XML [Chapitre 5] et d'une feuille de style XSLT
[Chapitre 8].
<body background='yellow'>
<xsd:element name="bibliography" type="Bibliography">
<a href="#{$node/@idref}">
18
Syntaxe de XML
Lorsque le contenu de l'lment est vide et que la balise ouvrante et la balise fermante sont contractes en une
seule balise [Section 2.7.1], celle-ci peut contenir des attributs comme la balise ouvrante.
Le nom de chaque attribut doit tre un nom XML [Section 2.2.3]. La valeur d'un attribut peut tre une chane
quelconque de caractres dlimite par une paire d'apostrophes ''' ou une paire de guillemets '"'. Elle peut
contenir les caractres spciaux '<', '>', '&', ''' et '"' mais ceux-ci doivent ncessairement tre introduits
par les entits prdfinies [Section 3.5.1.2]. Si la valeur de l'attribut est dlimite par des apostrophes ''', les
guillemets '"' peuvent tre introduits directement sans entit et inversement.
Comme des espaces peuvent tre prsents dans la balise aprs le nom de l'lment et entre les attributs, l'indentation
est libre pour crire les attributs d'une balise ouvrante. Aucun espace ne peut cependant sparer le caractre '='
du nom de l'attribut et de sa valeur. Il est ainsi possible d'crire l'exemple gnrique suivant.
<tag attribute1="value1"
attribute2="value2"
...
attributeN="valueN">
...
</tag>
L'ordre des attributs n'a pas d'importance. Les attributs d'un lment doivent avoir des noms distincts. Il est donc
impossible d'avoir deux occurrences du mme attribut dans une mme balise ouvrante.
Le bon usage des attributs est pour les meta-donnes plutt que les donnes elles-mmes. Ces dernires doivent
tre places de prfrence dans le contenu des lments. Dans l'exemple suivant, la date proprement dite est place
dans le contenu alors que l'attribut format prcise son format. La norme ISO 8601 [ ] spcifie la reprsentation
numrique de la date et de l'heure.
<date format="ISO-8601">2009-01-08</date>
C'est une question de style de mettre les donnes dans les attributs ou dans les contenus des lments. Le nom
complet d'un individu peut, par exemple, tre rparti entre des lments firstname et surname regroups dans
un lment personname comme dans l'exemple ci-dessous.
<personname id="I666">
<firstname>Gaston</firstname>
<surname>Lagaffe</surname>
</personname>
Les lments firstname et surname peuvent tre remplacs par des attributs de l'lment personname
comme dans l'exemple ci-dessous. Les deux solutions sont possibles mais la premire est prfrable.
Contrairement l'attribut xml:id, les trois autres attributs xml:lang, xml:space et xml:base s'appliquent
au contenu de l'lment. Pour cette raison, la valeur de cet attribut est hrite par les enfants et, plus gnralement,
les descendants. Ceci ne signifie pas qu'un lment dont le pre a, par exemple, un attribut xml:lang a galement
un attribut xml:lang. Cela veut dire qu'une application doit prendre en compte la valeur de l'attribut xml:lang
19
Syntaxe de XML
pour le traitement l'lment mais aussi de ses descendants l'exception, bien sr, de ceux qui donnent une nouvelle
valeur cet attribut. Autrement dit, la valeur de l'attribut xml:lang prendre en compte pour le traitement d'un
lment est celle donne cet attribut par l'anctre (y compris l'lment lui-mme) le plus proche. Pour illustrer
le propos, le document suivant contient plusieurs occurrences de l'attribut xml:lang. La langue du texte est,
chaque fois, donne par la valeur de l'attribut xml:lang le plus proche.
Ce qui a t expliqu pour l'attribut xml:lang vaut galement pour deux autres attributs xml:space et
xml:base. C'est cependant un peu diffrent pour l'attribut xml:base car la valeur prendre en compte doit
tre calcule partir de toutes les valeurs des attributs xml:base des anctres.
<p xml:lang="fr">Bonjour</p>
<p xml:lang="en-GB">Hello</p>
<p xml:lang="en-US">Hi</p>
Dans le document donn en exemple au dbut du chapitre, chaque lment book a un attribut lang. Ce n'est pas
l'attribut xml:lang qui a t utilis car celui-ci dcrit la langue des donnes contenues dans l'lment alors que
l'attribut lang dcrit la langue du livre rfrenc.
L'analyseur lexical transmet les caractres d'espacement aux applications sans les modifier. La seule
transformation effectue est la normalisation des fins de lignes. Il appartient ensuite aux applications de traiter ces
caractres de faon approprie. La plupart d'entre elles considrent de faon quivalente les diffrents caractres
d'espacement. Ceci signifie qu'une fin de ligne est vue comme un simple espace. Plusieurs espaces conscutifs sont
aussi considrs comme un seul espace. Ce traitement est gnralement le traitement par dfaut des applications.
Si l'attribut xml:space a la valeur preserve, l'application doit, au contraire, respecter les diffrents caractres
d'espacement. Les fins de ligne sont prserves et les espaces conscutifs ne sont pas confondus. L'attribut
xml:space intervient, en particulier, dans le traitement des espaces par XSLT [Section 8.4.1].
20
Syntaxe de XML
multimdia (images, sons, vidos). Dans le fragment de document XHTML ci-dessous, l'lment img rfrence
un fichier image element.png par son attribut src.
L'attribut de xml:base permet de prciser l'URI de base d'un lment. Par dfaut, l'URI de base d'un lment
est hrit de son parent. L'URI de base de la racine du document est appele URI de base du document. Elle
est souvent fixe par l'application qui traite le document mais elle peut aussi provenir d'un attribut xml:base
de l'lment racine. Lorsque le document provient d'un fichier local, c'est souvent le chemin d'accs celui-ci
dans l'arborescence des fichiers, comme file:/home/carton/Teaching/XML/index.html. Lorsque
le document est, au contraire, tlcharg, l'URI de base du document est l'adresse Internet de celui-ci comme
http://www.omega-one.org/~carton/index.html.
Pour chaque lment, l'attribut xml:base permet de fixer une URI de base de faon absolue ou, au contraire, de
la construire partir de l'URI de base du parent. Le comportement dpend de la forme de la valeur de l'attribut. La
valeur est combine avec l'URI de base du parent en suivant les rgles de combinaison de celles-ci [Section 2.3.1].
L'attribut xml:base est de type xsd:anyURI [Section 5.5.1.2].
L'attribut xml:base est indispensable pour raliser des inclusions de fichiers externes avec XInclude
[Section 2.9] lorsque ces fichiers sont situs dans un rpertoire diffrent de celui ralisant l'inclusion.
Le document suivant illustre les diffrents cas pour la combinaison d'une URI avec une adresse. Pour chacun des
lments, l'URI de base est donne.
http://www.somewhere.org/Teaching/index.html
http://www.somewhere.org/Teaching/XML/chapter.html
http://www.somewhere.org/Teaching/XML/XPath/section.html
http://www.somewhere.org/Course/section.html
http://www.elsewhere.org/section.html
L'URI de base d'un lment est retourne par la fonction XPath base-uri().
Comme les applications qui traitent les documents XML ne prennent pas en compte les modles de document,
sous forme de DTD ou de schma, elles ne peuvent pas dterminer le type des attributs. Il leur est en particulier
impossible de connatre les attributs de type ID qui permettent d'identifier et de rfrencer les lments. L'attribut
xml:id rsout ce problme puisqu'il est toujours du type xsd:ID [Section 5.5.1.4] qui remplace le type ID
dans les schmas XML.
2.7.5. Commentaires
Les commentaires sont dlimits par les chanes de caractres '<!--' et '-->' comme en HTML. Ils ne peuvent
pas contenir la chane '--' forme de deux tirets '-' et ils ne peuvent donc pas tre imbriqus. Ils peuvent tre
prsents dans le prologue et en particulier dans la DTD [Section 3.4]. Ils peuvent aussi tre placs dans le contenu
de n'importe quel lment et aprs l'lment racine. En revanche, ils ne peuvent jamais apparatre l'intrieur
21
Syntaxe de XML
d'une balise ouvrante ou fermante. Un exemple de document XML avec des commentaires partout o ils peuvent
apparatre est donn ci-dessous.
Les caractres spciaux '<', '>' et '&' peuvent apparatre dans les commentaires. Il est en particulier possible
de mettre en commentaire des lments avec leurs balises comme dans l'exemple ci-dessous.
Les instructions de traitement sont dlimites par les chanes de caractres '<?' et '?>'. Les deux caractres
'<?' sont immdiatement suivis du nom XML [Section 2.2.3] de l'instruction. Le nom de l'instruction est ensuite
suivi du contenu. Ce contenu est une chane quelconque de caractres ne contenant pas la chane '?>' utilise
par l'analyseur lexical pour dterminer la fin de l'instruction. Le nom de l'instruction permet l'application de
dterminer si l'instruction lui est destine.
Bien que le contenu d'une instruction puisse tre quelconque, il est souvent organis en une suite de paires
param="value" avec une syntaxe imitant celle des attributs [Section 2.7.3]. Il incombe cependant
l'application traitant l'instruction de parser le contenu de celle-ci pour en extraire la liste des paires.
Les fichiers sources DocBook [http://www.docbook.org] de cet ouvrage contiennent des instructions de traitement
de la forme suivante. Ces instructions indiquent le nom du fichier cible utiliser par les feuilles de styles pour
la conversion en HTML.
<?dbhtml filename="index.html"?>
Une feuille de style XSLT [Chapitre 8] peut tre attache un document XML par l'intermdiaire d'une instruction
de traitement de nom xml-stylesheet comme ci-dessous.
L'entte XML [Section 2.6.1] <?xml version=... ?> ressemble une instruction de traitement de nom
xml avec des paramtres version, encoding et standalone. Elle utilise en effet la mme syntaxe. Elle
n'est pourtant pas une instruction de traitement et elle ne fait pas partie du document.
22
Syntaxe de XML
<?xml version="1.0"?>
<tag/>
L'exemple aurait pu encore tre rduit en supprimant l'entte XML [Section 2.6.1] mais celle-ci est fortement
conseille. Le retour la ligne aprs l'entte aurait aussi pu tre supprim sans changer le contenu du document.
2.9. XInclude
Il est possible de rpartir un gros document en plusieurs fichiers afin d'en rendre la gestion plus aise. Il existe
essentiellement deux mthodes pour atteindre cet objectif. Le point commun de ces mthodes est de scinder le
document en diffrents fichiers qui sont inclus par un fichier principal. Les deux mthodes se diffrencient par
leurs faons de raliser l'inclusion.
La mthode la plus ancienne est hrite de SGML et elle est base sur les entits externes [Section 3.5.1.4]. La
mthode, plus rcente, base sur XInclude [ ] est utiliser de prfrence aux entits externes. XInclude dfinit un
lment xi:include dans un espace de noms [Chapitre 4] associ l'URL http://www.w3.org/2001/
XInclude. Cet lment a un attribut href qui contient le nom du fichier inclure et un attribut parse qui
prcise le type des donnes. Cet attribut peut prendre les valeurs xml ou text. Le fichier source principal de
cet ouvrage inclut, par exemple, les fichiers contenant les diffrents chapitres grce des lments include
comme ci-dessous.
<book version="5.0"
xmlns="http://docbook.org/ns/docbook"
xmlns:xi="http://www.w3.org/2001/XInclude">
...
<!-- Inclusion des diffrents chapitres -->
<xi:include href="introduction.xml" parse="xml"/>
<xi:include href="Syntax/chapter.xml" parse="xml"/>
...
</book>
Le fragment de document contenu dans un fichier inclus doit tre bien form. Il doit, en outre, tre entirement
contenu dans un seul lment qui est l'lment racine du fragment.
Il faut prendre garde au fait que certaines applications ne grent pas XInclude. La solution est d'ajouter la chane
de traitement une tape consistant construire un document global entirement contenu dans un seul fichier. Le
logiciel xmllint peut, par exemple, raliser cette opration. Avec l'option --xinclude, il crit sur la sortie
standard un document o les lments xi:include sont remplacs par le contenu des fichiers rfrencs. Cette
option peut tre combine avec l'option --noent pour supprimer les entits [Section 3.5] dfinies dans la DTD.
L'opration consistant remplacer un lment xi:include par le contenu du fichier doit mettre jour l'attribut
xml:base [Section 2.7.4.3] de l'lment racine du document dans le fichier. Cet attribut contient une URL qui
23
Syntaxe de XML
permet de rsoudre les liens relatifs. Le chemin d'accs au fichier doit donc tre ajout la valeur de l'attribut
xml:base. Il faut, en particulier, ajouter cet attribut s'il est absent et si le chemin d'accs est non vide. Le chemin
d'accs au fichier est rcupr dans l'attribut href de l'lment xi:include.
La mise jour des attributs xml:base garde une trace des inclusions et permet aux liens relatifs de rester valides.
La prise en compte des valeurs de ces attributs xml:base incombe en revanche aux applications qui traitent le
document et utilisent ces liens.
<book version="5.0"
xmlns="http://docbook.org/ns/docbook"
xmlns:xi="http://www.w3.org/2001/XInclude">
...
<!-- Inclusion des diffrents chapitres -->
<chapter xml:id="chap.introduction" xml:base="introduction.xml">
...
</chapter>
<chapter xml:id="chap.syntax" xml:base="Syntax/chapter.xml">
...
</chapter>
...
</book>
24
Chapitre 3. DTD
Le rle d'une DTD (Document Type Definition) est de dfinir prcisment la structure d'un document. Il s'agit d'un
certain nombre de contraintes que doit respecter un document pour tre valide. Ces contraintes spcifient quels sont
les lments qui peuvent apparatre dans le contenu d'un lment, l'ordre ventuel de ces lments et la prsence
de texte brut. Elles dfinissent aussi, pour chaque lment, les attributs autoriss et les attributs obligatoires.
Les DTD ont l'avantage d'tre relativement simples utiliser mais elles sont parfois aussi un peu limites. Les
schmas XML [Chapitre 5] permettent de dcrire de faon plus prcise encore la structure d'un document. Ils sont
plus sophistiqus mais plus difficiles mettre en uvre. Les DTD sont donc particulirement adaptes pour des
petits modles de documents. En revanche, leur manque de modularit les rend plus difficiles utiliser pour des
modles plus consquents.
Dclaration de l'lment bibliography devant contenir une suite non vide d'lments book.
Dclaration de l'lment book devant contenir les lments title, author, , isbn et url.
Dclarations des attributs obligatoires key et lang de l'lment book.
Dclaration de l'lment title devant contenir uniquement du texte.
Une DTD est gnralement prvue pour tre utilise pour de multiples documents. Elle est alors utilise
comme DTD externe. En revanche, il est pratique d'inclure directement la DTD dans le document en phase de
dveloppement. La dclaration de la DTD est introduite par le mot cl DOCTYPE et a la forme gnrale suivante
o root-element est le nom de l'lment racine du document.
25
DTD
Le nom de l'lment racine est suivi du contenu de la DTD dans le cas d'une DTD interne ou de l'URL du fichier
contenant la DTD dans le cas d'une DTD externe.
Les dclarations declarations constituent la dfinition du type du document. Dans l'exemple suivant de DTD,
le nom de l'lment racine est simple. La DTD dclare en outre que cet lment ne peut contenir que du texte
(Parsed Characters DATA) et pas d'autre lment.
<!DOCTYPE simple [
<!ELEMENT simple (#PCDATA)>
]>
type//owner//desc//lang
Le premier caractre type du FPI est soit le caractre '+' si le propritaire est enregistr selon la norme ISO
9070 soit le caractre '-' sinon. Le FPI continue avec le propritaire owner et la description desc du document.
Cette description est forme d'un mot cl suivi d'un texte libre. Ce mot cl est DTD pour les DTD mais il peut
aussi tre DOCUMENT, ELEMENTS ou ENTITIES. Le FPI se termine par un code de langue lang de la norme
ISO 639 [Section 2.7.4.1]. Lorsque le document appartient une norme ISO, le premier caractre '+' ainsi que
la chane '//' suivante sont supprims. Des exemples de FPI sont donns ci-dessous.
Un FPI peut tre converti en URI en utilisant l'espace de noms publicid des URN et en remplaant chaque
chane '//' par le caractre ':' et chaque espace par le caractre '+' comme dans l'exemple ci-dessous.
urn:publicid:-:W3C:DTD+XHTML+1.0+Strict:EN
26
DTD
La dclaration d'une DTD externe peut utiliser un FPI pour dsigner la DTD. La rfrence un FPI est introduite
par le mot cl PUBLIC suivi du FPI et d'une URL dlimite par des apostrophes ''' ou des guillemets '"'.
L'URL est utilise dans le cas o le FPI ne permet pas l'application de retrouver la DTD.
L'exemple suivant est la dclaration typique d'une page HTML qui utilise une des DTD de XHTML.
L'URL url peut tre soit une URL complte commenant par http:// ou ftp:// soit plus simplement le
nom d'un fichier local comme dans les exemples suivants.
Il n'est pas possible de dclarer plusieurs fois le mme lment dans une DTD. Lorsque la DTD est mixte, tout
lment doit tre dclar dans la partie interne ou dans la partie externe mais pas dans les deux. En revanche, il
est possible de dclarer plusieurs fois le mme attribut. La premire dclaration a priorit. Il est ainsi possible
de donner une nouvelle dclaration d'un attribut dans la partie interne puisque celle-ci est place avant la partie
externe.
Les entits paramtres [Section 3.5.2] peuvent galement tre dclares plusieurs fois dans une mme DTD et
c'est encore la premire dclaration qui l'emporte. La DTD suivante dclare l'entit paramtre book.entries
gale la chane vide. Cette entit est ensuite utilise dans la dclaration de l'lment book. Cette dclaration
laisse la possibilit au document principal d'ajouter des enfants l'lment book en donnant une nouvelle valeur
l'entit book.entries. La premire ligne de cette DTD est une entte XML [Section 2.6.1] qui permet de
dclarer le codage des caractres.
27
DTD
Le document suivant a une DTD mixte dont la partie externe est la DTD prcdente. La partie interne de la DTD
contient la dclaration de l'lment url. Elle contient galement des nouvelles dclarations de l'entit paramtre
book.entries et de l'attribut lang de l'lment book, qui devient ainsi obligatoire.
Comme la valeur donne l'entit paramtre book.entries est la chane ", url?" (sans les guillemets
'"'), la dclaration de l'lment book dans le fichier mixed.dtd devient quivalente la dclaration suivante
qui autorise un enfant url optionnel.
3.4. Commentaires
Une DTD peut contenir des commentaires qui utilisent la syntaxe des commentaires XML [Section 2.7.5] dlimits
par les chanes de caractres '<!--' et '-->'. Ceux-ci sont placs au mme niveau que les dclarations
d'lments, d'attributs et d'entits. Ils ne peuvent pas apparatre l'intrieur d'une dclaration.
28
DTD
<!-- Dclaration de l'lment book avec des enfants title, ..., isbn et url -->
<!ELEMENT book (title, author, year, publisher, isbn, url?)>
...
3.5. Entits
Les entits constituent un mcanisme hrit de SGML. Elles sont des macros semblables aux #define du
langage C. Elles permettent galement de raliser des inclusions de documents comme la directive #include du
langage C. Les entits sont dfinies dans la DTD du document. Il existe deux types d'entits. Les entits gnrales,
appeles simplement entits dans cet ouvrage, sont destines tre utilises dans le corps du document. Les entits
paramtres sont destines tre utilises au sein de la DTD.
Une entit est, en quelque sorte, un nom donn un fragment de document. Ce fragment peut tre donn
explicitement la dfinition de l'entit dans la DTD. Il peut galement provenir d'un fichier externe. Dans ce cas,
la dfinition de l'entit donne un FPI et/ou une URL permettant d'accder au document. Le fragment de document
peut tre insr dans le document en utilisant simplement le nom de l'entit. Lorsque le fragment provient d'un
autre fichier, l'utilisation de l'entit provoque l'inclusion du fichier en question. Le nom de chaque entit gnrale
ou paramtre doit tre un nom XML [Section 2.2.3].
Lorsque l'entit est dclare avec la premire syntaxe, elle est dite interne car le fragment est explicitement donn
dans la DTD du document. Lorsqu'elle est dclare avec une des deux dernires syntaxes, elle est dite externe
car le fragment provient d'un autre document. Ces deux dernires syntaxes sont semblables la dclaration d'une
DTD externe [Section 3.2.2] dans un document XML. Les rgles pour l'utilisation des apostrophes ''' et des
guillemets '"' sont identiques celles pour les valeurs d'attributs [Section 2.7.3]. Le fragment, le FPI et l'URL
doivent tre dlimits par une paire d'apostrophes ou de guillemets. Si le fragment est dlimit par des apostrophes,
les guillemets peuvent tre introduits directement sans entit et inversement.
Une entit de nom name est rfrence, c'est--dire utilise, par &name; o le nom name de l'entit est encadr
par les caractres '&' et ';'. Lorsque le document est trait, la rfrence une entit est remplace par le
fragment de document correspondant. Une entit interne peut tre rfrence dans les contenus d'lments et dans
les valeurs d'attribut alors qu'une entit externe peut seulement tre rfrence dans les contenus d'lments.
Entit Caractre
< <
29
DTD
Entit Caractre
> >
& &
' '
" "
Les nombreuses entits prdfinies en XHTML comme € pour le symbole '' n'existent pas en XML. La
seule faon d'inclure ce caractre est d'utiliser les notations &#point de code dcimal; ou &#xpoint
de code hexadcimal;. Il est cependant possible de dfinir ces propres entits (cf. ci-dessous).
Si la DTD contient les dclarations d'entits ci-dessus, Il est possible d'inclure le texte also known as
en crivant seulement &aka; ou d'inclure un symbole en crivant €. Les entits internes peuvent tre
rfrences dans les contenus d'lments mais aussi dans les valeurs d'attributs.
Il est possible d'utiliser des entits dans la dfinition d'une autre entit pourvu que ces entits soient galement
dfinies. L'ordre de ces dfinitions est sans importance car les substitutions sont ralises au moment o le
document est lu par l'analyseur de l'application. Les dfinitions rcursives sont bien sr interdites.
<!DOCTYPE book [
<!-- Entits internes -->
<!ENTITY mci "Michel Colucci &aka; 'Coluche'">
<!ENTITY aka "also known as">
]>
<book>&mci;</book>
Il faut faire attention au fait que certaines applications ne grent pas ou grent mal les entits dfinies. La solution
est d'ajouter la chane de traitement une premire tape consistant substituer les entits par leurs valeurs pour
obtenir un document intermdiaire sans entits. Le logiciel xmllint peut par exemple raliser cette opration.
Avec l'option --noent, il crit sur la sortie standard le document en remplaant chaque entit par sa valeur.
30
DTD
Les entits externes peuvent tres utilises pour scinder un document en plusieurs fichiers. Le fichier principal
inclut les diffrentes parties en dfinissant une entit externe pour chacune de ces parties. Les entits sont alors
utilises pour raliser l'inclusion comme dans l'exemple ci-dessous.
Chacun des fichiers contenant une entit externe peut avoir une entte [Section 2.6.1]. Celle-ci permet par exemple
de dclarer un encodage des caractres diffrents du fichier principal. Ce mcanisme pour rpartir un document
en plusieurs fichiers est abandonner au profit de XInclude [Section 2.9] qui est plus pratique.
La seule diffrence avec la dclaration d'une entit gnrale est la prsence du caractre '%' entre le mot cl
ENTITY et le nom de l'entit dclare. Comme pour les entits gnrales, l'entit est dite interne lorsqu'elle
est dclare avec la premire syntaxe. Elle est dite externe lorsqu'elle est dclare avec une des deux dernires
syntaxes. Les rgles pour l'utilisation des apostrophes ''' et des guillemets '"' sont identiques celles pour les
valeurs d'attributs [Section 2.7.3] ou les entits gnrales [Section 3.5.1].
L'entit name ainsi dclare peut tre rfrence, c'est--dire utilise, par %name; o le nom de l'entit est
encadr les caractres '%' et ';'. Les entits paramtres peuvent uniquement tre utilises au sein de la DTD.
Lorsque l'entit est interne, elle peut tre utilise dans les dclarations d'lments, d'attributs et d'autres entits.
Cette utilisation est limite la partie externe de la DTD. Lorsque l'entit est externe, elle est utilise en dehors des
dclarations pour inclure des dclarations provenant du document rfrenc par l'entit. L'exemple suivant dfinit
deux entits paramtres idatt et langatt permettant de dclarer des attributs id et xml:lang facilement.
31
DTD
Les entits paramtres ajoutent de la modularit qui est surtout ncessaire dans l'criture de DTD de grande
taille. Dans l'exemple prcdent, l'attribut id pourrait tre remplac partout par un attribut xml:id en changeant
uniquement la dfinition de l'entit paramtre idatt. Un autre exemple d'utilisation des entits paramtres est
donn avec les DTD mixtes [Section 3.2.3]. Les entits externes permettent d'inclure une partie de DTD provenant
d'un document externe comme dans l'exemple suivant.
La dclaration d'un lment est ncessaire pour qu'il puisse apparatre dans un document. Cette dclaration prcise
le nom et le type de l'lment. Le nom de l'lment doit tre un nom XML [Section 2.2.3] et le type dtermine
les contenus valides de l'lment. On distingue les contenus purs uniquement constitus d'autres lments, les
contenus textuels uniquement constitus de texte et les contenus mixtes qui mlangent lments et texte.
De manire gnrale, la dclaration d'un lment prend la forme suivante o element et type sont
respectivement le nom et le type de l'lment. Le type de l'lment dtermine quels sont ses contenus autoriss.
Le nom de l'lment est donn par l'identifiant element. L'expression rationnelle regexp dcrit les suites
autorises d'enfants dans le contenu de l'lment. Cette expression rationnelle est construite partir des noms
d'lments en utilisant les oprateurs ',', '|', '?', '*' et '+' ainsi que les parenthses '(' et ')' pour
former des groupes. Les oprateurs ',' et '|' sont binaires alors que les oprateurs '?', '*' et '+' sont
unaires et postfixs. Ils se placent juste aprs leur oprande, c'est--dire derrire le groupe auquel ils s'appliquent.
Le nom d'un lment signifie que cet lment doit apparatre dans le contenu. Les oprateurs principaux sont
les deux oprateurs ',' et '|' qui expriment la mise en squence et le choix. Un contenu est valide pour une
expression de la forme block-1, block-2 s'il est form d'un contenu valide pour block-1 suivi d'un contenu
valide pour block-2. Un contenu est valide pour une expression de la forme block-1 | block-2 s'il est
form d'un contenu valide pour block-1 ou d'un contenu valide pour block-2. Les trois oprateurs '?', '*'
et '+' permettent d'exprimer des rptitions. Un contenu est valide pour une expression de la forme block?
s'il est vide ou form d'un contenu valide pour block. Un contenu est valide pour une expression de la forme
block* (respectivement block+) s'il est form d'une suite ventuellement vide (respectivement suite non vide)
de contenus valides pour block. La signification des cinq oprateurs est rcapitule par la table suivante.
Oprateur Signification
, Mise en squence
32
DTD
Oprateur Signification
| Choix
? 0 ou 1 occurrence
* Rptition d'un nombre quelconque d'occurrences
+ Rptition d'un nombre non nul d'occurrences
La DTD suivante dclare un lment list de contenu pur. Il contient une suite non vide d'lments item
contenant chacun du texte.
Le document suivant est valide pour la DTD prcdente car la valeur de l'attribut standalone de l'entte est no.
Si cette valeur tait yes, le document ne serait plus valide car l'lment list contient des caractres d'espacement
entre ses enfants item.
33
DTD
Lors de l'analyse du contenu de l'lment item, le validateur ne peut pas dterminer en lisant l'lment item1 si
celui-ci provient de la premire alternative (item1, item2) ou de la seconde alternative (item1, item3).
L'expression prcdente peut, cependant, tre remplace par l'expression quivalente suivante qui a l'avantage
d'tre dterministe.
Le non-dterminisme d'une expression peut aussi provenir d'un des deux oprateurs '?' ou '*'. L'expression
(item1?, item1) n'est pas dterministe car il n'est pas possible de dterminer immdiatement si un lment
item1 correspond la premire ou la seconde occurrence de item1 dans l'expression. Cette expression est
quivalente l'expression (item1, item1?) qui est dterministe. Il existe toutefois des expressions sans
expression dterministe quivalente comme l'expression suivante.
34
DTD
Dans l'exemple suivant, l'lment book possde un contenu mixte. Il peut contenir du texte et des lments em
et cite en nombre quelconque et dans n'importe quel ordre.
Des exemples d'utilisation d'lments de contenu vide sont donns la section traitant des attributs de type ID,
IDREF et IDREFS [Section 3.7.2].
Dans un souci de portabilit, il est conseill de contracter les balises ouvrante et fermante lorsqu'un lment est
dclar de contenu vide et de le faire uniquement dans ce cas.
Il est possible de dclarer simultanment plusieurs attributs pour un mme lment. Cette dclaration prend alors
la forme suivante o l'indentation est bien sr facultative.
Les diffrents types possibles pour un attribut ainsi que les valeurs par dfaut autorises sont dtaills dans les
sections suivantes.
35
DTD
CDATA
Ce type est le plus gnral. Il n'impose aucune contrainte la valeur de l'attribut. Celle-ci peut tre une chane
quelconque de caractres.
La valeur de l'attribut doit tre un des jetons [Section 2.2.3] value-1, value-2, value-N. Comme
ces valeurs sont des jetons, celles-ci ne sont pas dlimites par des apostrophes ''' ou des guillemets '"'.
NMTOKEN
La valeur de l'attribut est un jeton [Section 2.2.3].
NMTOKENS
La valeur de l'attribut est une liste de jetons spars par des espaces.
ID
La valeur de l'attribut est un nom XML [Section 2.2.3]. Un lment peut avoir un seul attribut de ce type.
IDREF
La valeur de l'attribut est une rfrence un lment identifi par la valeur de son attribut de type ID.
IDREFS
La valeur de l'attribut est une liste de rfrences spares par des espaces.
NOTATION
La valeur de l'attribut est une notation
ENTITY
La valeur de l'attribut une entit externe non XML
ENTITIES
La valeur de l'attribut une liste d'entits externes non XML
Le type le plus gnral est CDATA puisque toutes les valeurs correctes d'un point de vue syntaxique sont permises.
Cet type est trs souvent utilis car il est appropri ds qu'il n'y a aucune contrainte sur la valeur de l'attribut.
Les types NMTOKEN et NMTOKENS imposent respectivement que la valeur de l'attribut soit un jeton [Section 2.2.3]
ou une suite de jetons spars par des espaces. Il est aussi possible d'imposer que la valeur de l'attribut soit dans
une liste fixe de jetons. Il est impossible, avec une DTD, de restreindre les valeurs d'un attribut une liste fixe
de valeurs qui ne sont pas des jetons.
L'utilisation des trois types NOTATION, ENTITY et ENTITIES est rserve l'usage des entits externes non
XML et elle n'est pas dtaille dans cet ouvrage. L'utilisation des trois types ID, IDREF et IDREFS est dveloppe
la section suivante.
36
DTD
La valeur d'un attribut de type ID doit tre un nom XML [Section 2.2.3]. La valeur de cet attribut doit tre unique
dans tout le document. Ceci signifie qu'un autre attribut de type ID d'un autre lment ne peut pas avoir la mme
valeur pour que le document soit valide. Un lment ne peut avoir qu'un seul attribut de type ID.
Les attributs de type ID sont utiliss par la fonction XPath id() [Section 6.1.1.2] qui retourne les nuds identifis
par la valeur de leur attribut de type ID.
La valeur d'un attribut de type IDREF doit tre un nom XML. Ce nom doit, en outre, tre la valeur d'un attribut
de type ID d'un (autre) lment pour que le document soit valide. La valeur d'un attribut de type IDREFS doit
tre une suite de noms spars par des espaces. Chacun de ces noms doit, en outre, tre la valeur d'un attribut de
type ID d'un lment pour que le document soit valide.
Le document suivant illustre l'utilisation des attributs de type ID, IDREF et IDREFS qui est faite par DocBook
pour les rfrences internes. Son contenu est scind en sections dlimites par les lments section. Chacun de
ces lments a un attribut id de type ID. Le contenu des lments section est constitu de texte et d'lments
ref et refs ayant respectivement un attribut idref de type IDREF et un attribut idrefs de type IDREFS.
Ces lments permettent, dans le contenu d'une section, de rfrencer une (par ref) ou plusieurs (par refs)
autres sections. Il faut remarquer que les lments ref et refs n'ont jamais de contenu. Ils sont dclars vides
en utilisant le mot cl EMPTY. Il appartient l'application qui gnre le document final d'ajouter du contenu qui
peut tre, par exemple, le numro ou le titre de la section rfrence.
Les attributs de type ID et IDREF permettent galement de structurer un document. Si l'adresse et d'autres
informations sont ajoutes l'diteur dans le document bibliography.xml, celles-ci sont recopies dans
chaque livre publi par l'diteur. Cette duplication de l'information est bien sr trs mauvaise. Une meilleure
approche consiste scinder la bibliographie en deux parties. Une premire partie contient les livres et une seconde
partie les diteurs avec les informations associes. Ensuite, chaque livre se contente d'avoir une rfrence sur son
diteur. Un attribut id de type ID est ajout chaque lment publisher de la seconde partie. Chaque lment
publisher contenu dans un lment book est remplac par un lment published ayant un attribut by de
type IDREF.
37
DTD
Beaucoup d'applications ne prennent pas en compte la DTD pour traiter un document. Il leur est alors impossible de
savoir quels attributs sont de type ID, IDREF ou IDREFS. Elles utilisent souvent la convention qu'un attribut de
nom id est implicitement de type ID. Une meilleure solution consiste utiliser l'attribut xml:id [Section 2.7.4.4]
qui est toujours de type ID (de type xsd:ID [Section 5.5.1.4] en fait).
"value" ou 'value'
La valeur value est une chane quelconque de caractres dlimite par des apostrophes ''' ou des
guillemets '"'. Si l'attribut est absent pour un lment du document, sa valeur est implicitement la chane
value. Cette valeur doit, bien sr, tre du type donn l'attribut.
#IMPLIED
L'attribut est optionnel et il n'a pas de valeur par dfaut. Si l'attribut est absent, il n'a pas de valeur.
#REQUIRED
L'attribut est obligatoire et il n'a pas de valeur par dfaut.
Beaucoup d'applications ne prennent pas en compte la DTD pour traiter un document XML. Ce comportement
pose problme avec les valeurs par dfaut et les valeurs fixes (utilisation de #FIXED) des attributs. Si l'attribut est
absent pour un lment du document, l'application va considrer que l'attribut n'a pas de valeur bien que la DTD
dclare une valeur par dfaut. L'utilisation des valeurs par dfaut est donc viter pour une portabilit maximale.
3.7.4. Exemples
Voici quelques exemples de dclarations d'attributs avec, pour chacune d'entre elles, des valeurs valides et non
valides pour l'attribut.
38
DTD
39
DTD
L'inconvnient majeur de ces sites WEB est la difficult de les intgrer une chane de traitement automatique
puisqu'ils requirent l'intervention de l'utilisateur. Dans ce cas, il est prfrable d'utiliser un logiciel comme
xmllint. Avec l'option --valid, il ralise la validation du document pass en paramtre. Avec cette option,
la DTD soit tre prcise par une dclaration de DTD [Section 2.6.2] dans le prologue du document. Sinon, il faut
donner explicitement la DTD aprs l'option --dtdvalid. La DTD peut tre donne par le nom d'un fichier local
ou par une URL qui permet xmllint d'accder celle-ci.
40
Chapitre 4. Espaces de noms
4.1. Introduction
Les espaces de noms ont t introduits en XML afin de pouvoir mlanger plusieurs vocabulaires au sein d'un mme
document. De nombreux dialectes XML ont t dfinis pour des utilisations diverses et il est prfrable de les
rutiliser au maximum. Il est, en effet, fastidieux de redfinir plusieurs fois les mmes vocabulaires. Le recyclage
des dialectes fait d'ailleurs partie des objectifs de XML.
Le mlange de plusieurs vocabulaires au sein d'un mme document ne doit pas empcher la validation de celui-
ci. Il devient indispensable d'identifier la provenance de chaque lment et de chaque attribut afin de le valider
correctement. Les espaces de noms jouent justement ce rle. Chaque lment ou attribut appartient un espace de
noms qui dtermine le vocabulaire dont il est issu. Cette appartenance est marque par la prsence dans le nom
d'un prfixe associ l'espace de noms.
Le mlange de plusieurs vocabulaires est illustr par l'exemple suivant. Afin d'insrer des mtadonnes dans des
documents, il est ncessaire de disposer d'lments pour prsenter celles-ci. Il existe dj un standard, appel
Dublin Core, pour organiser ces mtadonnes. Il comprend une quinzaine d'lments dont title, creator,
subject et date qui permettent de dcrire les caractristiques principales d'un document. Il est prfrable
d'utiliser le vocabulaire Dublin Core, qui est un standard international, plutt que d'introduire un nouveau
vocabulaire. Le document suivant est le document principal d'un livre au format DocBook. Les mtadonnes
sont contenues dans un lment metadata. Celui-ci contient plusieurs lments du Dublin Core dont les noms
commencent par le prfixe dc. L'lment include de XInclude fait partie d'un autre espace de noms marqu
par le prfixe xi.
Comme en C++, les espaces de noms vitent les conflits de noms entre diffrents vocabulaires. Le dialecte
DocBook dispose d'un lment title de mme nom que l'lment title du Dublin Core. Ces deux lments
ne sont pas confondus dans le document prcdent, car l'lment title du Dublin Core a le prfixe dc.
41
Espaces de noms
Un nom qualifi d'lment prend la forme prefix:local o prefix est un prfixe associ un espace de
noms et local est le nom local de l'lment. Ce nom local est galement un nom XML ne contenant pas le
caractre ':'. Dans la terminologie XML, les noms sans caractre ':' sont appels NCNAME qui est l'abrviation
de No Colon Name et les noms qualifis sont appels QNAME qui est, bien sr, l'abrviation de Qualified Name.
Dans l'exemple suivant, on associe le prfixe hns l'espace de noms de XHTML identifi par l'URI http://
www.w3.org/1999/xhtml. Ensuite, tous les lments de cet espace de noms sont prfixs par hns:.
<hns:html xmlns:hns="http://www.w3.org/1999/xhtml">
<hns:head>
<hns:title>Espaces de noms</hns:title>
</hns:head>
<hns:body>
...
</hns:body>
</hns:html>
Il est habituel d'associer l'espace de noms XHTML au prfixe html plutt qu' hns. L'exemple precdent devient
alors l'exemple suivant qui est un document quivalent.
<html:html xmlns:html="http://www.w3.org/1999/xhtml">
<html:head>
<html:title>Espaces de noms</html:title>
</html:head>
<html:body>
...
</html:body>
</html:html>
Le choix du prfixe est compltement arbitraire. Dans l'exemple prcdent, on aurait pu utiliser foo ou bar la
place du prfixe html. La seul contrainte est d'tre cohrent entre la dclaration du prfixe et son utilisation. Mme
si les prfixes peuvent tre librement choisis, il est d'usage d'utiliser certains prfixes particuliers pour certains
espaces de noms. Ainsi, on prend souvent html pour XHTML, xsd ou xs pour les schmas XML [Chapitre 5]
et xsl les feuilles de style XSLT [Chapitre 8].
Il est bien sr possible de dclarer plusieurs espaces de noms en utilisant plusieurs attributs de la forme
xmlns:prefix. Dans l'exemple suivant, on dclare galement l'espace de noms de MathML et on l'associe au
prfixe mml.
<html:html xmlns:html="http://www.w3.org/1999/xhtml"
xmlns:mml="http://www.w3.org/1998/Math/MathML">
42
Espaces de noms
<html:head>
<html:title>Espaces de noms</html:title>
</html:head>
<html:body>
...
<mml:math>
<mml:apply>
<mml:eq/>
...
</mml:apply>
</mml:math>
...
</html:body>
</html:html>
C'est l'URI associ au prfixe qui dtermine l'espace de noms. Le prfixe est juste une abrviation pour l'URI. Deux
prfixes associs au mme URI dterminent le mme espace de noms. Dans l'exemple suivant, les deux lments
firstname et surname font partie du mme espace de noms. L'exemple suivant est uniquement donn pour
illustrer le propos mais il n'est pas suivre. C'est une mauvaise pratique d'associer deux prfixes au mme URI.
<name xmlns:foo="http://www.somewhere.org/uri"
xmlns:bar="http://www.somewhere.org/uri">
<!-- Les deux lments firstname et surname
appartiennent au mme espace de noms. -->
<foo:firstname>Gaston<foo:firstname>
<bar:surname>Lagaffe<bar:surname>
</name>
<html:html xmlns:html="http://www.w3.org/1999/xhtml">
<html:head>
<html:title>Espaces de noms</html:title>
</html:head>
<html:body>
...
<mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML">
<mml:apply>
<mml:eq/>
...
</mml:apply>
</mml:math>
<!-- L'espace de noms MathML n'est maintenant plus disponible -->
...
</html:body>
</html:html>
43
Espaces de noms
le plus utilis. Dans le cas des schmas [Section 5.13], il est souvent pratique de prendre pour espace de noms
par dfaut l'espace de noms cible.
L'espace de noms par dfaut peut tre spcifi par un pseudo attribut de nom xmlns dont la valeur est l'URI de
l'espace de noms. Lorsque celui a t spcifi, les lments dont le nom n'est pas qualifi font partie de l'espace
de noms par dfaut. L'exemple prcdent aurait pu tre simplifi de la faon suivante.
<html xmlns="http://www.w3.org/1999/xhtml">
<!-- L'espace de noms par defaut est celui de XHTML -->
<head>
<title>Espaces de noms</title>
</head>
<body>
...
<mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML">
<mml:apply>
<mml:eq/>
...
</mml:apply>
</mml:math>
<!-- L'espace de noms MathML n'est maintenant plus disponible -->
...
</body>
</html>
Comme la dclaration de l'espace de noms est locale l'lment, l'exemple prcdent aurait pu tre crit de faon
encore plus simplifie en changeant localement dans l'lment math l'espace de noms par dfaut.
<html xmlns="http://www.w3.org/1999/xhtml">
<!-- L'espace de noms par defaut est celui de XHTML -->
<head>
<title>Espaces de noms</title>
</head>
<body>
...
<math xmlns="http://www.w3.org/1998/Math/MathML">
<!-- L'espace de noms par defaut est maintenant celui de MathML -->
<apply>
<eq/>
...
</apply>
</math>
<!-- L'espace de noms par dfaut est nouveau celui de XHTML -->
...
</body>
</html>
Tant que l'espace de noms par dfaut n'a pas t spcifi, les lments dont le nom n'est pas qualifi ne font partie
d'aucun espace de noms. Leur proprit espace de noms n'a pas de valeur. Il est possible de revenir l'espace de
noms par dfaut non spcifi en affectant la chane vide l'attribut xmlns comme dans l'exemple suivant.
<html xmlns="http://www.w3.org/1999/xhtml">
<!-- L'espace de noms par dfaut est maitenant l'espace de noms XHTML -->
<!-- Tous les lments html, head, title, body, ... appartiennent
l'espace de noms XHTML qui est l'espace de noms par dfaut. -->
<head>
<title>Espaces de noms</title>
</head>
<body>
44
Espaces de noms
...
<name xmlns="">
<!-- L'espace de noms par dfaut n'est plus spcifi -->
<!-- Les trois lments name, firstname et surname
n'appartiennent aucun espace de noms. -->
<firstname>Gaston<firstname>
<surname>Lagaffe<surname>
</name>
...
</body>
</html>
Une consquence de la remarque prcdente est que dans un document XML sans dclaration d'espace de
noms, tous les lments ne font partie d'aucun espace de noms. Ce comportement assure une compatibilit des
applications avec les documents sans espace de noms.
4.6. Attributs
Les attributs peuvent galement avoir des noms qualifis forms d'un prfixe et d'un nom local. Ils
font alors partie de l'espace de noms auquel est associ le prfixe. Dans l'exemple suivant, l'attribut
noNamespaceSchemaLocation fait partie de l'espace de noms des instances de schmas. Cet espace de
noms est identifi par l'URI http://www.w3.org/2001/XMLSchema-instance. Le nom de l'attribut
noNamespaceSchemaLocation doit donc avoir un prfixe associ cet URI. La dclaration de l'espace de
noms peut avoir lieu dans le mme lment, comme dans l'exemple ci-dessous, puisque la porte de celle-ci est
l'lment tout entier.
En revanche, les attributs dont le nom n'est pas qualifi n'appartiennent aucun espace de noms. Ils ne font jamais
partie de l'espace de noms par dfaut. Cette rgle s'applique que l'espace de noms par dfaut soit spcifi ou non.
Dans l'exemple ci-dessous, l'lment book appartient l'espace de noms DocBook puisque celui-ci est dclar
comme l'espace de noms par dfaut. L'attribut id appartient l'espace de noms XML et l'attribut version
n'appartient aucun espace de noms.
<book version="5.0"
xml:id="course.xml"
xmlns="http://docbook.org/ns/docbook">
Ces quatre attributs sont dclars par le schma XML [Chapitre 5] qui se trouve l'URL http://
www.w3.org/2001/xml.xsd. Ce schma peut tre import [Section 5.14] par un autre schma pour ajouter
certains de ces attributs des lments.
45
Espaces de noms
par xmlns:. Il est donc ncessaire de le dclarer comme tout autre attribut. D'autre part, les noms qualifis des
lments sont considrs comme des noms contenant le caractre ':'. Il faut donc dclarer les lments avec
leur nom qualifi.
Les lments du document suivant font partie de l'espace de noms identifi par l'URI http://www.omega-
one.org/~carton/ qui est associ au prfixe tns.
La DTD suivante valide le document prcdent. Elle dclare un attribut xmlns:tns pour la dclaration d'espace
de noms. De plus, les lments sont dclars avec leurs noms qualifis tns:list et tns:item.
En revanche, le document suivant n'est pas valide pour la DTD prcdent alors qu'il est quivalent au document
prcdent. Le prfixe tns a simplement t remplac par le prfixe ons.
http://www.w3.org/2001/XInclude
XLink
http://www.w3.org/1999/xlink
MathML
http://www.w3.org/1998/Math/MathML
XHTML
http://www.w3.org/1999/xhtml
Schmas [Chapitre 5]
http://www.w3.org/2001/XMLSchema
46
Espaces de noms
Schematron [Chapitre 7]
http://purl.oclc.org/dsdl/schematron
XSLT [Chapitre 8]
http://www.w3.org/1999/XSL/Transform
XSL-FO [Chapitre 9]
http://www.w3.org/1999/XSL/Format
http://docbook.org/ns/docbook
Dublin Core
http://purl.org/dc/elements/1.1/
47
Chapitre 5. Schmas XML
5.1. Introduction
Les schmas XML permettent, comme les DTD [Chapitre 3], de dfinir des modles de documents. Il est ensuite
possible de vrifier qu'un document donn est valide pour un schma, c'est--dire respecte les contraintes donnes
par le schma. Les schmas ont t introduits pour combler certaines lacunes des DTD.
Les DTD manquent cruellement de prcision dans la description des contenus des lments. Cette lacune se
manifeste surtout au niveau des contenus textuels et des contenus mixtes. Il est, par exemple, impossible d'imposer
des contraintes sur les contenus textuels [Section 3.6.2] des lments. Le seul type possible pour les contenus
textuels est #PCDATA qui autorise toutes les chanes de caractres. Les types pour les attributs sont un peu plus
nombreux mais ils restent encore trs limits. l'inverse, les schmas possdent une multitude de types prdfinis
[Section 5.5.1] pour les contenus textuels. Ces types couvrent les chanes de caractres, les nombres comme les
entiers et les flottants ainsi que les heures et les dates. Ces types peuvent, en outre, tre affins par des mcanismes
de restriction et d'union. Il est possible de dfinir, titre d'exemple, des types pour les entiers entre 1 et 12, les
flottants avec deux dcimales ou les chanes d'au plus 16 caractres ne comportant que des chiffres et des tirets '-'.
Les DTD sont encore plus limites dans la description des contenus mixtes [Section 3.6.3]. La seule possibilit est
d'exprimer que le contenu d'un lment est un mlange, sans aucune contrainte, de texte et de certains lments.
Les schmas comblent cette lacune en permettant d'avoir des contenus mixtes [Section 5.5.4] aussi prcis que les
contenus purs qui dcrivent l'ordre et les nombres d'occurrences des enfants d'un lment.
Dans une DTD, le contenu pur d'un lment est dcrit directement par une expression rationnelle. Les schmas
procdent en deux tapes. Ils dfinissent des types qui sont ensuite associs aux lments. Les schmas se
distinguent des DTD par leurs possibilits de dfinir de nouveaux types. Il est d'abord possible de construire des
types [Section 5.6] explicitement la manire des DTD. Il existe ensuite des mcanismes permettant de dfinir un
nouveau type partir d'un autre type, soit prdfini, soit dj dfini dans le schma. Ce nouveau type est obtenu
soit par extension [Section 5.8] soit par restriction [Section 5.9] du type de dpart. L'extension consiste enrichir
le type en ajoutant du contenu et des attributs. La restriction consiste, l'inverse, ajouter des contraintes pour
restreindre les contenus valides. Ces deux mcanismes permettent ainsi de construire une vritable hirarchie de
types semblable l'approche oriente objet des langages comme Java ou C++.
Les schmas autorisent des facilits impossibles avec les DTD. La premire est la possibilit d'avoir plusieurs
lments locaux [Section 5.4.5] avec des noms identiques mais avec des types et donc des contenus diffrents. Dans
une DTD, un lment a une seule dclaration qui dcrit ses contenus possibles pour toutes ses occurrences dans un
document. Une deuxime facilit est forme des mcanismes de substitution de types et d'lments [Section 5.10].
titre d'exemple, un schma peut prvoir qu'un lment puisse se substituer un autre lment. Ces substitutions
fonctionnent de pair avec la hirarchie des types.
Les DTD ont une modularit trs limite et l'criture de DTD d'envergure est un exercice difficile. Les seuls
dispositifs mis disposition des auteurs de DTD sont l'import de DTD externes [Section 3.2.2] et les entits
paramtres [Section 3.5.2]. Les schmas possdent plusieurs mcanismes destins une plus grande modularit.
Le premier d'entre eux est la possibilit, pour les schmas, de dfinir des types par extension et restriction. Il existe
galement les groupes d'lments et les groupes d'attributs [Section 5.11].
Les DTD proviennent de SGML et sont antrieures aux espaces de noms. Pour cette raison, elles ne les prennent
pas en compte. La dclaration d'un lment se fait en donnant le nom qualifi de l'lment avec le prfixe et le
nom local. Ceci impose, dans les documents, d'associer l'espace de noms ce mme prfixe. Ceci est contraire
48
Schmas XML
l'esprit des espaces de noms o le prfixe est juste une abrviation interchangeable pour l'URI de l'espace de noms.
Les schmas, au contraire, prennent en compte les espaces de noms [Section 5.13]. Un schma dclare d'abord
un espace de noms cible. Les lments et les attributs sont ensuite dclars, dans le schma, avec leur nom local.
Un document qui mlange des lments et des attributs provenant d'espaces de noms diffrents peut encore tre
valid l'aide des diffrents schmas pour les espaces de noms.
<xsd:complexType name="Bibliography">
<xsd:sequence>
<xsd:element name="book" minOccurs="1" maxOccurs="unbounded">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="title" type="xsd:string"/>
<xsd:element name="author" type="xsd:string"/>
<xsd:element name="year" type="xsd:string"/>
<xsd:element name="publisher" type="xsd:string"/>
<xsd:element name="isbn" type="xsd:string"/>
<xsd:element name="url" type="xsd:string" minOccurs="0"/>
</xsd:sequence>
<xsd:attribute name="key" type="xsd:NMTOKEN" use="required"/>
<xsd:attribute name="lang" type="xsd:NMTOKEN" use="required"/>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
</xsd:schema>
lment racine xsd:schema avec la dclaration de l'espace de noms des schmas associ au prfixe xsd.
Documentation du schma.
Dclaration de l'lment bibliography avec le type Bibliography.
Dbut de la dfinition du type Bibliography.
Dclaration de l'lment book dans le contenu du type Bibliography.
Dclaration des attributs key et lang de l'lment book avec le type xsd:NMTOKEN.
Ce schma dclare l'lment bibliography du type Bibliography qui est ensuite introduit par l'lment
xsd:complexType. Ce type est alors dfini comme une suite d'autres lments introduite par le constructeur
xsd:sequence. Les deux attributs key et lang de l'lment book sont introduits par les dclarations
xsd:attribute.
Dans tout ce chapitre, la convention suivante est applique. Les noms des lments sont en minuscules alors que
les noms des types commencent par une majuscule comme les classes du langage Java. Les noms de l'lment et
de son type ne se diffrencient souvent que par la premire lettre comme bibliography et Bibliography
dans l'exemple prcdent.
49
Schmas XML
Comme pour les DTD, il existe des sites WEB permettant de valider un document vis vis d'un schma. Cette
validation peut galement tre effectue avec le logiciel xmllint. L'option --schema permet de passer en
paramtre un schma en plus du document XML.
L'espace de noms [Chapitre 4] des schmas XML est identifi par l'URI http://www.w3.org/2001/
XMLSchema. Il est gnralement associ, comme dans l'exemple prcdent au prfixe xsd ou xs. Tout le
schma est inclus dans l'lment xsd:schema. La structure globale d'un schma est donc la suivante.
Les lments, attributs et les types peuvent tre globaux ou locaux. Ils sont globaux lorsque leur dclaration ou leur
dfinition est un enfant direct de l'lment racine xsd:schema. Sinon, ils sont locaux. Seuls les objets globaux
peuvent tre rfrencs dans tout le schma pour tre utiliss. Dans le premier exemple de schma donn ci-dessus,
l'lment bibliography est global alors que l'lment title est local. La dclaration de ce dernier intervient
au sein de la dfinition du type Bibliography qui est global. Seuls les types globaux d'un schma sont nomms.
Les types locaux sont anonymes et n'ont pas de nom. Dans le schma ci-dessus, le type de l'lment book est, par
exemple, anonyme. Les lments et attributs sont toujours nomms, qu'ils soient globaux ou locaux. Ils doivent,
bien sr, avoir un nom pour apparatre dans un document.
Les objets globaux et locaux se comportent diffrement vis vis de l'espace de noms cible du schma
[Section 5.13]. Les objets globaux appartiennent toujours cet espace de noms. Les objets locaux, au
contraire, appartiennent ou n'appartiennent pas l'espace de noms cible suivant les valeurs des attributs form,
elementFormDefault et attributeFormDefault.
Les lments sont dclars par l'lment xsd:element et les attributs par l'lment xsd:attribute. Les
types sont dfinis par les lments xsd:simpleType et xsd:complexType.
targetNamespace
La valeur de cet attribut est l'URI qui identifie l'espace de noms cible [Section 5.13], c'est-a-dire l'espace de
noms des lments et types dfinis par le schma. Si cet attribut est absent, les lements et types dfinis n'ont
pas d'espace de noms.
elementFormDefault et attributeFormDefault
Ces deux attributs donnent la valeur par dfaut de l'attribut form [Section 5.13] pour respectivement les
lments et les attributs. Les valeurs possibles sont qualified et unqualified. La valeur par dfaut
est unqualified.
blockDefault et finalDefault
50
Schmas XML
Ces deux attributs donnent la valeur par dfaut des attributs block et final [Section 5.10.4]. Les
valeurs possibles pour blockDefault sont #all ou une liste de valeurs parmi les valeurs extension,
restriction et substitution. Les valeurs possibles pour finalDefault sont #all ou une liste
de valeurs parmi les valeurs extension, restriction, list et union.
Dans l'exemple suivant, le schma dclare que l'espace de noms cible est identifi par l'URI http://
www.omega-one.org/~carton et que tous les lments doivent tre qualifis dans les documents valides.
L'espace de noms par dfaut est dclar gal l'espace de noms cible afin de simplifier l'criture du schma.
La valeur de l'attribut schemaLocation est une suite d'URI spars par des espaces. Ces URI vont par paires
et le nombre d'URI doit donc tre pair. Le premier URI de chaque paire identifie un espace de noms et le second
donne l'adresse du schma utiliser pour les lments et attributs dans cet espace de noms. L'espace de noms
identifi par le premier URI doit donc tre l'espace de noms cible du schma donn par le second. La valeur de
l'attribut schemaLocation prend donc la forme gnrale suivante
Le logiciel qui effectue la validation se base sur la valeur de l'attribut schemaLocation pour chercher la
dfinition de chaque lment ou attribut dans le schma correspondant son espace de noms.
La valeur de l'attribut noNamespaceSchemaLocation est simplement l'URL d'un unique schma qui doit
permettre de valider l'intgralit du document. Il n'est, en effet, pas possible de distinguer les lments qui n'ont
pas d'espace de noms.
Dans l'exemple suivant, le document dclare que le schma se trouve dans le fichier local bibliography.xsd
et que l'espace de noms cible de ce schma est identifi par l'URI http://www.omega-one.org/~carton/
.
5.3.3. Documentation
L'lment xsd:annotation permet d'ajouter des commentaires dans un schma. Il peut tre enfant
de l'lment xsd:schema pour des commentaires globaux. Il peut galement tre enfant des lments
xsd:element, xsd:attribute pour ajouter des commentaires aux dclarations d'lments et d'atttributs
ainsi que de xsd:simpleType et xsd:complexType pour ajouter des commentaires aux dfinitions de type.
Contrairement aux commentaires XML [Section 2.7.5], ces commentaires font partie part entire du schma
XML et constituent sa documentation.
51
Schmas XML
<xsd:annotation>
<xsd:documentation xml:lang="fr">
Commentaire en franais
</xsd:documentation>
<xsd:appInfo>
Information destine aux applications
</xsd:appInfo>
</xsd:annotation>
Le type donn un lment peut tre soit un type nomm soit un type anonyme. Dans le premier cas, le type est
soit un type prdfini dont le nom fait partie de l'espace de noms des schmas soit un type dfini globalement dans
le schma. Dans le second cas, le type est dfini explicitement la dclaration de l'lment.
o element et type sont respectivement le nom et le type de l'lment. Ce type peut tre un des types prdfinis
comme xsd:string ou xsd:integer ou encore un type dfini dans le schma. L'exemple suivant dclare
l'lment title de type xsd:string. Le nom du type doit tre un nom qualifi comme ici par le prfixe xsd
associ l'espace de noms des schmas. Cette rgle s'applique aussi lorsque le type est dfini dans le schma.
<xsd:element name="element">
<xsd:simpleType>
...
</xsd:simpleType>
</xsd:element>
<xsd:element name="element">
52
Schmas XML
<xsd:complexType>
...
</xsd:complexType>
</xsd:element>
Les deux attributs name et ref ne peuvent pas tre prsents simultanment dans l'lment xsd:element. Par
contre, l'un des deux doit toujours tre prsent soit pour donner le nom de l'lment dfini soit pour rfrencer
un lment dj dfini.
53
Schmas XML
D'autres exemples de schmas dclarant plusieurs lments de mme nom mais de types diffrents sont donns
pour les restrictions de types complexes contenu complexe [Section 5.9.3].
Les schmas permettent de dfinir une hirarchie de types qui sont obtenus par extension ou restriction de types
dj dfinis. L'extension de type est similaire l'hritage des langages de programmation orients objet comme
Java ou C++. Elle permet de dfinir un nouveau type en ajoutant des lments et/ou des attributs un type. La
restriction permet au contraire d'imposer des contraintes supplmentaires au contenu et aux attributs.
Tous les types prdfinis ou dfinis dans un schma sont drivs du type xsd:anyType. Ce type est aussi le
type par dfaut lorsqu'une dclaration d'lment ne spcifie pas le type comme la dclaration suivante.
x s d : a n y Ty p e
x s d : s i mp l e Ty p e x s d : c o mp l e x Ty p e
x s d : a n y At o mi c Ty p e xs d: l i s t xs d: e xt e ns i on xs d: s e que nc e xs d: e xt e ns i on
xs d: uni on xs d: r e s t r i c t i on xs d: c hoi c e xs d: r e s t r i c t i on
xs d: a l l
54
Schmas XML
Les schmas possdent de nombreux types prdfinis. Certains, comme xsd:int et xsd:float, proviennent
des langages de programmation, certains, comme xsd:date et xsd:time, sont inspirs de normes ISO (ISO
8601 dans ce cas) et d'autres encore, comme xsd:ID, sont hrits des DTD. Ces types autorisent l'criture de
schmas concis et trs prcis. Beaucoup d'entre eux pourraient tre redfinis par restriction [Section 5.9] de types
de base mais leur prsence comme types de base simplifie le travail.
xsd:boolean
xsd:byte
xsd:unsignedByte
xsd:short
xsd:unsignedShort
xsd:int
xsd:unsignedInt
xsd:long
xsd:unsignedLong
xsd:integer
Nombre entier sans limite de prcision. Ce type n'est pas primitif et drive du type xsd:decimal.
xsd:positiveInteger
xsd:negativeInteger
xsd:nonPositiveInteger
55
Schmas XML
xsd:nonNegativeInteger
xsd:float
xsd:double
xsd:decimal
xsd:string
xsd:normalizedString
Chane de caractres normalise, c'est--dire ne contenant pas de tabulation U+09, de saut de ligne U+0A ou
de retour chariot U+0D [Section 2.2.2].
xsd:token
Chane de caractres normalise (comme ci-dessus) et ne contenant pas en outre des espaces en dbut ou en
fin ou des espaces conscutifs
xsd:Name
xsd:QName
xsd:NCName
xsd:language
Code de langue sur deux lettres de la norme ISO 639 comme fr ou en ventuellement suivi d'un code de
pays de la norme ISO 3166 comme en-GB. C'est le type de l'attribut particulier xml:lang [Section 2.7.4.1]
auquel il est spcialement destin.
xsd:anyURI
xsd:base64Binary
56
Schmas XML
xsd:hexBinary
Les deux types xsd:normalizedString et xsd:token mritent quelques explications. D'une part, il faut
bien distinguer le type xsd:token du type xsd:NMTOKEN. Le type xsd:token accepte des valeurs contenant
ventuellement des espaces alors que le type xsd:NMTOKEN accepte uniquement un jeton [Section 2.2.3] qui ne
contient jamais d'espace. D'autre part, les deux types xsd:normalizedString et xsd:token ne restreignent
pas les valeurs possibles pour un document valide mais modifient le traitement des caractres d'espacement
[Section 2.2.2] l'analyse lexicale. Le type xsd:normalizedString n'interdit pas de mettre des caractres
d'espacement autres que des espaces. En revanche, tous les caractres d'espacement sont convertis en espaces par
l'analyseur lexical. De la mme faon, le type xsd:token n'interdit pas de mettre des caractres d'espacement en
dbut ou en fin ou des caractres d'espacement conscutifs. En revanche, les caractres d'espacement en dbut ou
en fin sont supprims et les suites de caractres d'espacement sont remplaces par un seul espace par l'analyseur
lexical.
xsd:time
Heure au format hh:mm:ss[.sss][TZ], par exemple 14:07:23. La partie fractionnaire .sss des
secondes est optionnelle. Tous les autres champs sont obligatoires. Les nombres d'heures, minutes et de
secondes doivent tre crits avec deux chiffres en compltant avec 0. L'heure peut tre suivie d'un dcalage
horaire TZ qui est soit Z pour le temps universel soit un dcalage commenant par + ou - comme -07:00.
xsd:date
Date au format YYYY-MM-DD, par exemple 2008-01-16. Tous les champs sont obligatoires.
xsd:dateTime
xsd:duration
xsd:dayTimeDuration
xsd:yearMonthDuration
xsd:gYear
xsd:gYearMonth
Anne et mois du calendrier grgorien au format YYYY-MM comme 1966-06 pour juin 1966.
xsd:gMonth
57
Schmas XML
xsd:gMonthDay
Jour et mois du calendrier grgorien au format MM-DD comme 12-25 pour le jour de Nol.
xsd:gDay
Jour (dans le mois) du calendrier grgorien au format DD comme 01 pour le premier de chaque mois.
x s d : a n y At o mi c Ty p e
x s d : n o r ma l i z e d St r i n g x s d : y e a r Mo n t h Du r a t i o n
xs d: i nt e ge r
xs d: t oke n x s d : d a y Ti me Du r a t i o n
x s d : n o n Po s i t i v e I n t e g e r
xs d: l a ngua ge
xs d: ne ga t i ve I nt e ge r
x s d : NMTOKEN
x s d : n o n Ne g a t i v e I n t e g e r
x s d : Na me
xs d: pos i t i ve I nt e ge r
x s d : NCNa me
x s d : u n s i g n e d Lo n g
xs d: I D
xs d: uns i gne dI nt
x s d : I DREF
x s d : u n s i g n e d Sh o r t
xs d: l ong x s d : u n s i g n e d By t e
xs d: i nt
xs d: s hor t
xs d: byt e
x s d : a n y At o mi c Ty p e
x s d : a n y URI x s d : QNa me x s d : b a s e 6 4 Bi n a r y x s d : h e x Bi n a r y
x s d : g Ye a r x s d : g Ye a r Mo n t h x s d : g Mo n t h x s d : g Mo n t h Da y x s d : g Da y
58
Schmas XML
xsd:ID
xsd:IDREF
xsd:IDREFS
xsd:NMTOKEN
xsd:NMTOKENS
xsd:ENTITY
xsd:ENTITIES
xsd:NOTATION
notation
<xsd:simpleType ...>
...
</xsd:simpleType>
L'lment xsd:simpleType peut avoir un attribut name si la dclaration est globale. La dclaration du type
se fait ensuite dans le contenu de l'lment xsd:simpleType comme dans l'exemple suivant.
<xsd:simpleType name="Byte">
<xsd:restriction base="xsd:nonNegativeInteger">
<xsd:maxInclusive value="255"/>
</xsd:restriction>
</xsd:simpleType>
59
Schmas XML
tre utiliss pour les lments. Ils sont introduits par l'lment xsd:complexType. Un type complexe peut tre
construit explicitement ou tre driv d'un autre type par extension [Section 5.8] ou restriction [Section 5.9].
La construction explicite d'un type se fait en utilisant les oprateurs de squence xsd:sequence, de choix
xsd:choice ou d'ensemble xsd:all. La construction du type se fait directement dans le contenu de l'lment
xsd:complexType et prend donc la forme suivante.
Si le type est obtenu par extension ou restriction d'un autre type, l'lment xsd:complexType doit contenir un
lment xsd:simpleContent ou xsd:complexContent qui prcise si le contenu est purement textuel ou
non. La dclaration d'un type complexe prend alors une des deux formes suivantes.
Le contenu d'un lment est valide pour un type dclar mixte si le contenu devient valide pour le type non mixte
correspondant lorsque tout le texte en dehors des enfants est supprim. Dans l'exemple suivant, l'lment person
doit contenir, un lment firstname et un lment lastname dans cet ordre. Puisque son type est dclar
mixte, il peut en outre contenir du texte comme ci-dessous.
<xsd:element name="person">
<xsd:complexType mixed="true">
<xsd:sequence>
<xsd:element name="firstname" type="xsd:string"/>
<xsd:element name="lastname" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
Le document suivant est valide pour le schma prcdent. En revanche, il ne le serait pas sans la valeur true
donne l'attribut mixed dans le schma. Le contenu de l'lment person est valide car si on retire le texte en
dehors de ses enfants firstname et lastname (texte en gras ci-dessous), on obtient un contenu valide pour
60
Schmas XML
le type sans mixed="true". Il serait, par exemple, impossible de changer l'ordre des enfants firstname et
lastname car ce type spcifie qu'ils doivent apparatre dans cet ordre.
Le schma prcdent n'a pas d'quivalent dans les DTD. Ds que le contenu d'un lment est dclar mixte dans
une DTD [Section 3.6.3], il n'y a plus aucun contrle sur l'ordre et le nombre d'occurrences de ses enfants. Le
schma suivant donne un exemple de contenu mixte quivalent un contenu mixte d'une DTD.
<xsd:element name="book">
<xsd:complexType mixed="true">
<xsd:choice minOccurs="0" maxOccurs="unbounded">
<xsd:element ref="em"/>
<xsd:element ref="cite"/>
</xsd:choice>
</xsd:complexType>
</xsd:element>
<link ref="id-42"/>
<xsd:element name="book">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="title" type="xsd:string"/>
<xsd:element name="author" type="xsd:string"/>
61
Schmas XML
<book>
<title>XML langage et applications</title>
<author>Alain Michard</author>
<year>2001</year>
<publisher>Eyrolles</publisher>
</book>
Un autre exemple de type construit avec l'oprateur xsd:sequence est donn comme exemple de type mixte
[Section 5.5.4]. Le nombre d'occurences de chaque lment dans la squence est 1 par dfaut mais il peut tre
modifi par les attributs minOccurs et maxOccurs [Section 5.6.7].
<xsd:element name="publication">
<xsd:complexType>
<xsd:choice>
<xsd:element ref="book"/>
<xsd:element ref="article"/>
<xsd:element ref="report"/>
</xsd:choice>
</xsd:complexType>
</xsd:element>
Un autre exemple de type construit avec l'oprateur xsd:choice est donn comme exemple de type mixte
[Section 5.5.4]. Il est bien sr possible d'imbriquer les oprateurs xsd:sequence et xsd:choice. Dans
l'exemple suivant, l'lment book contient soit un seul lment author soit un lment authors contenant
au moins deux lments author. Cette dernire contrainte est impose par la valeur 2 de l'attribut minOccurs
[Section 5.6.7].
62
Schmas XML
minOccurs="2" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:choice>
<xsd:element name="year" type="xsd:string"/>
...
</xsd:sequence>
<xsd:element name="book">
<xsd:complexType>
<xsd:all>
<xsd:element name="title" type="xsd:string"/>
<xsd:element name="author" type="xsd:string"/>
<xsd:element name="year" type="xsd:string"/>
<xsd:element name="publisher" type="xsd:string"/>
</xsd:all>
</xsd:complexType>
</xsd:element>
Le document suivant est un document valide o l'lment book a la dclaration prcdente. L'ordre des enfants
de l'lment book peut tre variable.
63
Schmas XML
</book>
<book key="Zeldman03" lang="en">
<title>Designing with web standards</title>
<author>Jeffrey Zeldman</author>
<year>2003</year>
<publisher>New Riders</publisher>
</book>
...
</bibliography>
L'utilisation de l'lment xsd:all doit respecter quelques contraintes qui limitent fortement son intrt. Un
oprateur xsd:all ne peut pas tre imbriqu avec d'autres constructeurs xsd:sequence, xsd:choice ou
mme xsd:all. D'une part, les seuls enfants possibles de xsd:all sont des lments xsd:element. D'autre
part, l'lment xsd:all est toujours enfant de xsd:complexType ou xsd:complexContent.
Les attributs minOccurs et maxOccurs des lments apparaissant sous l'oprateur xsd:all ne peuvent pas
avoir des valeurs quelconques. La valeur de l'attribut minOccurs doit tre 0 ou 1 et la valeur de l'attribut
maxOccurs doit tre 1 qui est la valeur par dfaut. Les attributs minOccurs et maxOccurs peuvent
aussi apparatre comme attribut de xsd:all. Dans ce cas, leurs valeurs s'appliquent tous les lments
xsd:element enfants de xsd:all. Les valeurs autorises pour minOccurs sont 0 et 1 et la seule valeur
autorise pour maxOccurs est 1.
Dans la dclaration suivante de l'lment book, ses enfants peuvent apparatre dans n'importe quel ordre et chacun
d'eux peut avoir 0 ou 1 occurrence.
<xsd:element name="book">
<xsd:complexType>
<xsd:all minOccurs="0">
<xsd:element name="title" type="xsd:string"/>
<xsd:element name="author" type="xsd:string"/>
<xsd:element name="year" type="xsd:string"/>
<xsd:element name="publisher" type="xsd:string"/>
</xsd:all>
</xsd:complexType>
</xsd:element>
Le type IntegerOrUnbounded dfini ci-dessous pourrait tre le type de l'attribut maxOccurs tel qu'il pourrait
apparatre dans un schma pour les schmas. Les valeurs de ce type sont soit un entier positif ou nul du type
xsd:nonNegativeInteger soit l'unique chane unbounded du type Unbounded. Ce dernier type est
obtenu par restriction du type xsd:string.
Les types paramtres de l'oprateur d'union peuvent aussi tre anonymes. Ils sont alors explicits directement dans
le contenu de l'lment xsd:union comme dans l'exemple suivant qui conduit une dfinition quivalence
celle de l'exemple prcdent.
64
Schmas XML
<xsd:simpleType name="IntegerOrUnbounded">
<xsd:union memberTypes="xsd:nonNegativeInteger">
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:enumeration value="unbounded"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:union>
</xsd:simpleType>
5.6.7. Rptitions
Les attributs minOccurs et maxOccurs permettent de prciser le nombre minimal ou maximal d'occurrences
d'un lment ou d'un groupe. Ils sont l'quivalent des oprateurs ?, * et + des DTD. Ils peuvent apparatre comme
attribut des lments xsd:element, xsd:sequence, xsd:choice et xsd:all. L'attribut minOccurs
prend un entier comme valeur. L'attribut maxOccurs prend un entier ou la chane unbounded comme valeur
pour indiquer qu'il n'y a pas de nombre maximal. La valeur par dfaut de ces deux attributs est la valeur 1.
L'utilisation des attributs minOccurs et maxOccurs est illustre par l'quivalent en schma de quelques
fragments de DTD
<xsd:element name="elem">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="elem1"/>
<xsd:element ref="elem2" minOccurs="0"/>
<xsd:element ref="elem3" minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="elem">
<xsd:complexType>
<xsd:sequence>
65
Schmas XML
<xsd:element ref="elem1"/>
<xsd:choice minOccurs="0">
<xsd:element ref="elem2"/>
<xsd:element ref="elem3"/>
</xsd:choice>
<xsd:element ref="elem4"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="elem">
<xsd:complexType>
<xsd:sequence minOccurs="0" maxOccurs="unbounded">
<xsd:element ref="elem1"/>
<xsd:element ref="elem2"/>
<xsd:element ref="elem3"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="elem">
<xsd:complexType>
<xsd:choice minOccurs="0" maxOccurs="unbounded">
<xsd:element ref="elem1"/>
<xsd:element ref="elem2"/>
<xsd:element ref="elem3"/>
</xsd:choice>
</xsd:complexType>
</xsd:element>
<xsd:element name="elem">
<xsd:complexType>
<xsd:sequence minOccurs="1" maxOccurs="unbounded">
<xsd:element ref="elem1"/>
<xsd:element ref="elem2"/>
<xsd:element ref="elem3"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
Le schma suivant autorise zro ou un lment externe dans le contenu de l'lment person aprs l'lment
lastname.
66
Schmas XML
L'attribut namespace de l'lment xsd:any permet de prciser les espaces de noms auxquels doivent appartenir
les lments externes. Sa valeur doit tre une suite d'URI identifiant des espaces de noms spars par des espaces.
Les valeurs particulires ##any, ##other, ##local et ##targetNamepspace peuvent aussi apparatre
dans la liste des espaces de noms. La valeur par dfaut ##any n'impose aucune restriction sur l'espace de noms des
lments externes. Les valeurs ##targetNamepspace et ##other autorisent respectivement des lments
dont l'espace de noms est gal ou diffrent de l'espace de noms cible du schma. La valeur ##local autorise des
lments ayant des noms non qualifis et n'appartenant donc aucun espace de noms.
Dans le schma suivant, l'lment externe ajout dans le contenu de l'lment person doit appartenir l'espace
de noms XHTML.
67
Schmas XML
Il existe galement un lment xsd:anyAttribute [Section 5.7.4] pour autoriser des attributs externes au
schma.
5.6.9. Validation
Cette section aborde deux aspects techniques de la validation du contenu d'lments purs. Ces deux aspects sont
la prsence des caractres d'espacement [Section 2.2.2] et le dterminisme des contenus. Ils ont dj t abords
pour les DTD [Section 3.6.1.1].
Lorsque le contenu d'un lment d'un lment pur est valid, les caractres d'espacement qui se trouvent hors de
ses enfants sont ignors. Ceci autorise l'indentation des documents XML sans perturber la validation.
Le contenu des lments purs et mixtes doit tre dterministe. Ceci signifie que la prsence d'une balise ouvrante
dans le contenu doit compltement dterminer d'o provient celle-ci dans la dfinition du type. Cette restriction
est identique celle portant sur les expressions dfinissant le contenu d'un lment pur dans une DTD. Le schma
suivant n'est pas valable car le contenu de l'lment item n'est pas dterministe. Une balise ouvrante <item1>
peut provenir de la premire ou de la seconde dclaration d'lment item1.
Comme pour un lment, le type d'un attribut peut tre anonyme. Il est alors dfini dans le contenu de l'lment
xsd:attribute. Cette possibilit est illustre par l'exemple suivant. La valeur de l'attribut lang dclar ci-
dessous peut tre la chane en ou la chane fr.
<xsd:attribute name="lang">
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:enumeration value="en"/>
<xsd:enumeration value="fr"/>
</xsd:restriction>
68
Schmas XML
</xsd:simpleType>
</xsd:attribute>
5.7.1. Localisation
Les dclarations d'attributs se placent normalement dans les dfinitions de types complexes qui peuvent tre
globaux ou locaux. Les types simples ne peuvent pas avoir d'attributs. La dfinition d'un type complexe se compose
de la description du contenu suivie de la dclaration des attributs. L'ordre de dclarations des attributs est sans
importance puisque l'ordre des attributs dans une balise n'est pas fixe.
Dans l'exemple suivant, le type complexe List dclare deux attributs form et lang. Les dclarations de ces
deux attributs se situent aprs la description du contenu du type List constitu d'une suite d'lments item. Le
type de l'attribut form est le type prdfini xsd:string alors que le type de l'attribut lang est le type global
et simple Lang dfini dans la suite du schma.
Un attribut peut aussi tre global lorsque sa dclaration par xsd:attribute est enfant direct de l'lment
xsd:schema. Cet attribut peut alors tre ajout diffrents types complexes. La dfinition du type utilise
l'lment xsd:attribute avec un attribut ref qui remplace les deux attributs name et type. Cet attribut
ref contient le nom de l'attribut global ajouter. La dclaration globale d'un attribut est justifie lorsque celui-
ci a des occurrences multiples. Elle accrot la modularit des schmas en vitant de rpter la mme dclaration
dans plusieurs types.
Le schma suivant dclare un attribut global lang de type xsd:language. Cet attribut est ajout deux reprises
dans le type global Texts et dans le type anonyme de l'lment text.
69
Schmas XML
Lorsqu'un schma dclare un espace de noms cible [Section 5.13], les attributs globaux appartiennent
automatiquement cet espace de noms. Ceci signifie d'abord qu'ils doivent tre rfrencs par leur nom qualifi
dans le schma. L'ajout d'un attribut de nom name un type complexe prend alors la forme suivante o le prfixe
tns est associ l'espace de noms cible du schma.
<xsd:attribute ref="tns:name"/>
Cela signifie aussi qu'ils doivent avoir un nom qualifi dans les documents instance comme dans l'exemple suivant.
Les valeurs optional et required de l'attribut use sont donc quivalentes #IMPLIED et #REQUIRED
utiliss dans les dclarations d'attributs des DTD [Section 3.7]. Dans l'exemple suivant, les attributs lang,
xml:id et dummy sont respecivement optionnel, obligatoire et interdit.
Le schma suivant donne une utilisation raliste de la valeur prohibited pour l'attribut use. Le type Date
dclare un attribut format optionnel. Le type Date-8601 est une restriction [Section 5.9] du type Date.
L'attribut format devient interdit et ne peut plus apparatre.
70
Schmas XML
<xsd:complexType name="Date-8601">
<xsd:simpleContent>
<xsd:restriction base="Date">
<!-- Attribut format interdit dans le type Date-8601 -->
<xsd:attribute name="format" type="xsd:string" use="prohibited"/>
</xsd:restriction>
</xsd:simpleContent>
</xsd:complexType>
<xsd:element name="date" type="Date-8601"/>
</xsd:schema>
Le fragment de document suivant est valide pour ce schma. L'attribut format ne peut pas tre prsent dans
l'lment date.
<date format="iso-8601"/></date>
Dans le schma suivant, l'lment person peut avoir des attributs appartenant l'espace de noms identifi par
l'URI http://www.omega-one.org/~carton/.
71
Schmas XML
L'extension d'un type est introduite par l'lment xsd:extension dont l'attribut base donne le nom du
type de base. Celui-ci peut tre un type prdfini ou un type dfini dans le schma. Le contenu de l'lment
xsd:extension explicite le contenu et les attributs ajouter au type de base. L'lment xsd:extension
est enfant d'un lment xsd:simpleContent ou xsd:complexContent, lui-mme enfant de l'lment
xsd:complexType.
Le fragment de schma suivant dfinit un type Price qui tend le type prdfini xsd:decimal en lui ajoutant
un attribut currency de type xsd:string
<xsd:complexType name="Price">
<xsd:simpleContent>
<xsd:extension base="xsd:decimal">
<!-- Attribut ajout -->
<xsd:attribute name="currency" type="xsd:string"/>
</xsd:extension>
</xsd:simpleContent>
</xsd:complexType>
<xsd:element name="price" type="Price"/>
72
Schmas XML
<price currency="euro">3.14</price>
Dans le schma suivant, le type Price est tendu en un type LocalType qui possde un nouvel attribut
country de type xsd:string.
Le fragment de document suivant est valide pour le schma prcdent. Comme l'ordre des attributs est sans
importance, l'attribut country aurait pu tre plac avant l'attribut currency.
Dans le schma suivant le type Fullname tend le type Name en lui ajoutant un lment title et un attribut id.
73
Schmas XML
<xsd:complexType name="Fullname">
<xsd:complexContent>
<xsd:extension base="Name">
<xsd:sequence>
<!-- Ajout de l'lment title aprs firstname et lastname -->
<xsd:element name="title" type="xsd:string"/>
</xsd:sequence>
<!-- Ajout de l'attribut id -->
<xsd:attribute name="id" type="xsd:ID"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
...
</xsd:schema>
L'lment title est ajout aprs le contenu du type Name qui est constitu des deux lments firstname et
lastname. Le document suivant est valide pour le schma prcdent.
La restriction d'un type est introduite par l'lment xsd:restriction dont l'attribut base donne le nom
du type de base. Celui-ci peut tre un type prdfini ou un type dfini dans le schma. Le contenu de
l'lment xsd:restriction explicite les restrictions au type de base. Dans le cas d'un type simple, l'lment
xsd:restriction est enfant direct de l'lment xsd:simpleType. Dans le cas d'un type complexe, il
est enfant d'un lment xsd:simpleContent ou xsd:complexContent, lui-mme enfant de l'lment
xsd:complexType.
74
Schmas XML
Ces contraintes s'appliquent aux types numriques pour lesquels elles ont un sens. Dans l'exemple suivant, le type
donn l'lment year est un entier entre 1970 et 2050 inclus. Le type utilis dans cet exemple est un type
anonyme.
<xsd:element name="year">
<xsd:simpleType>
<xsd:restriction base="xsd:integer">
<xsd:minInclusive value="1970"/>
<xsd:maxInclusive value="2050"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:element>
<year>1966</year>
La restriction par intervalle peut aussi s'appliquer aux dates et aux heures comme le montre l'exemple suivant.
<xsd:attribute name="date">
<xsd:simpleType>
<xsd:restriction base="xsd:date">
<!-- Date aprs le 31 dcembre 2001 exclus -->
<xsd:minExclusive value="2001-12-31"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
<event date="2006-06-24">...</event>
<language>en</language>
<xsd:simpleType name="ISBN">
<xsd:restriction base="xsd:string">
<xsd:pattern value="\d-\d{2}-\d{6}-[\dX]"/>
75
Schmas XML
<xsd:pattern value="\d-\d{3}-\d{5}-[\dX]"/>
<xsd:pattern value="\d-\d{4}-\d{4}-[\dX]"/>
<xsd:pattern value="\d-\d{5}-\d{3}-[\dX]"/>
</xsd:restriction>
</xsd:simpleType>
Un lement isbn dclar du type ISBN dfini ci-dessus pourrait avoir le contenu suivant qui correspond au
second motif utilis ci-dessus.
<isbn>2-311-01400-6</isbn>
Le type suivant Identifier dfinit un type pour les noms XML [Section 2.2.3]. Il aurait aussi pu tre dcrit
avec l'expression rationnelle \i\c* [Section 5.15.3].
<xsd:simpleType name="Identifier">
<xsd:restriction base="xsd:string">
<xsd:pattern value="[:_A-Za-z][-.:_0-9A-Za-z]*"/>
</xsd:restriction>
</xsd:simpleType>
Un lement identifier dclar du type Identifier dfini ci-dessus pourrait avoir le contenu suivant.
<identifier>tns:id-42</identifier>
Pour que le contenu soit valide, il faut que celui-ci, pris dans son intgralit, soit conforme l'expression
rationnelle. Il ne suffit pas qu'un fragment (une sous-chane) de celui-ci soit conforme. Le contenu abc123xyz
n'est, par exemple, pas conforme l'expression \d{3} bien que le fragment 123 le soit. Les ancres '^' et '$'
[Section 6.3.4] sont implicitement ajoutes l'expression. Pour avoir une expression qui accepte ventuellement
un fragment du contenu, il suffit d'ajouter .* au dbut et la fin de celle-ci. Le contenu abc123xyz est, par
exemple, conforme l'expression .*\d{3}.*.
La liste suivante dcrit toutes les facettes. Pour chacune d'entre elles sont donns les types sur lesquels elle peut
s'appliquer.
xsd:enumeration
Cette facette permet d'numrer explicitement les valeurs autorises. Elle s'applique tous les types simples
y compris les types construits avec xsd:union [Section 5.6.5] et xsd:list [Section 5.6.6].
xsd:pattern
Cette facette permet de donner une expression rationnelle [Section 5.15] pour contraindre les valeurs. Elle ne
s'applique pas uniquement aux types drivs de xsd:string mais tous les types simples y compris les
types numriques et les types contruits avec xsd:union et xsd:list. L'utilisation avec xsd:decimal
permet de restreindre, par exemple, aux nombres ayant 4 chiffres pour la partie entire et 2 pour la partie
fractionnaire. Lorsque cette facette est applique un type construit avec xsd:list, la contrainte porte sur
les items de la liste et non sur la liste elle-mme.
Ces trois facettes donnent respectivement une longueur fixe ou des longueurs minimale et maximale.
Elles s'appliquent aux types drivs de xsd:string [Section 5.5.1.2] ainsi qu'aux types construits avec
l'oprateur xsd:list [Section 5.6.6].
76
Schmas XML
Ces quatre facettes donnent des valeurs minimale et maximale en incluant ou non la borne donne. Ces
facettes s'appliquent tous les types numriques [Section 5.5.1.1] ainsi qu' tous les types de date et d'heure
[Section 5.5.1.3].
xsd:fractionDigits et xsd:totalDigits
Ces deux facettes fixent respectivement le nombre maximal de chiffres de la partie fractionnaire ( droite de
la virgule) et le nombre maximal de chiffres en tout. Il s'agit de valeurs maximales. Il n'est pas possible de
spcifier des valeurs minimales. De mme, il n'est pas possible de spcifier le nombre maximal de chiffres de la
partie entire ( gauche de la virgule). Ces deux facettes s'appliquent uniquement aux types numriques drivs
de xsd:decimal. Ceci inclut tous les types entiers mais exclut les types xsd:float et xsd:double.
xsd:whiteSpace
Cette facette est particulire. Elle ne restreint pas les valeurs valides mais elle modifie le traitement des
caractres d'espacement [Section 2.2.2] l'analyse lexicale. Cette facette peut prendre les trois valeurs
preserve, replace et collapse qui correspondent trois modes de fonctionnement de l'analyseur
lexical.
preserve
Dans ce mode, les caractres d'espacement sont laisss inchangs par l'analyseur lexical.
replace
Dans ce mode, chaque caractre d'espacement est remplac par un espace U+20. Le rsultat est donc du
type prdfini xsd:normalizedString [Section 5.5.1.2].
collapse
Dans ce mode, le traitement du mode prcdent replace est d'abord appliqu puis les espaces en dbut
et en fin sont supprims et les suites d'espaces conscutifs sont remplaces par un seul espace. Le rsultat
est donc du type prdfini xsd:token [Section 5.5.1.2]
Cette facette ne s'applique qu'aux types drivs de xsd:string. Une drivation ne peut que renforcer le
traitement des caractres d'espacement en passant d'un mode un mode plus strict (preserve replace
collapse). Les changements dans l'autre sens sont impossibles.
Par dfaut, le nouveau type complexe dfini est identique au type de base. Pour modifier le type du contenu,
l'lment xsd:restriction contient un lment xsd:simpleType qui donne explicitement le nouveau
type du contenu. Ce type doit tre obtenu par restriction du type qui dfinit le contenu du type de base.
Dans le schma suivant, un type Base est dfini par extension du type simple xsd:string en lui ajoutant un
attribut format. Le type Derived est ensuite obtenu en restreignant le type du contenu aux chanes d'au plus
32 caractres.
77
Schmas XML
</xsd:extension>
</xsd:simpleContent>
</xsd:complexType>
<!-- Restriction du type de base -->
<xsd:complexType name="Derived">
<xsd:simpleContent>
<xsd:restriction base="Base">
<!-- Nouveau type pour le contenu du type Derived -->
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:maxLength value="32"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:restriction>
</xsd:simpleContent>
</xsd:complexType>
<xsd:element name="base" type="Base"/>
<xsd:element name="derived" type="Derived"/>
</xsd:schema>
Dans le fragment de document ci-dessous, les deux lments base et derived ont des contenus valides pour
le schma prcdent.
La restriction peut aussi changer les types des attributs et leur utilisation. Les attributs dont certaines proprits
changent sont redclars dans le nouveau type. Les autres restent implicitement inchangs. Le type d'un attribut
peut tre remplac par un type obtenu par restriction. Ce type peut, bien sr, tre nomm ou anonyme. L'utilisation
des attributs peut aussi tre restreinte. Un attribut optionnel peut devenir interdit avec use="prohibited" ou
obligatoire avec use="required". L'inverse est en revanche interdit. Il est galement impossible d'ajouter de
nouveaux attributs. Si un attribut possde une valeur par dfaut ou une valeur fixe, celle-ci ne peut tre ni modifie
ni supprime.
Dans le schma suivant, le type de base Base possde plusieurs attributs dont le type driv Derived modifie
l'utilisation.
78
Schmas XML
Il est encore possible de changer simultanment le type du contenu et certaines proprits des attributs. Dans le
schma suivant, le type est restreint au chanes d'au plus 32 caractres et le type xsd:decimal de l'attribut
decimal est remplac par le type xsd:integer qui est bien un type driv de xsd:decimal.
Dans le fragment de document ci-dessous, les deux lments base et derived ont des contenus valides pour
le schma prcdent.
79
Schmas XML
Le nouveau type est dfini en crivant sa dfinition comme s'il s'agissait d'une premire dfinition. Dans le schma
suivant, le type Shortname est obtenu par restriction du type Name. La valeur de l'attribut maxOccurs pour
l'lment firstname passe de unbounded 1. L'attribut id devient obligatoire.
80
Schmas XML
<lastname>Windsor</lastname>
</name>
<shortname id="id-42">
<firstname>Bessiewallis</firstname>
<lastname>Warfield</lastname>
</shortname>
</names>
Il est aussi possible de restreindre un type complexe en remplaant le type d'un lment par un type driv. Dans
l'exemple suivant, le type de l'lment integer est xsd:integer dans le type Base. Ce type est remplac par
le type xsd:nonNegativeInteger dans le type Restriction. Le schma suivant dclare deux lments
locaux de mme nom integer mais de types diffrents [Section 5.4.5].
Une restriction d'un type complexe contenu complexe peut aussi supprimer un des choix possibles dans un
lment xsd:choice. Dans l'exemple suivant, le choix integer a t supprim dans le type Float.
81
Schmas XML
Le document suivant est valide pour le schma prcdent. Il utilise une substitution de type [Section 5.10.2] avec
l'attribut xsi:type pour changer le type de l'lment number en Float.
5.10. Substitutions
Les schmas XML prvoient plusieurs mcanismes de substitution au niveau des types et des lments. Dans
la substitution de type, un document peut changer explicitement le type associ un lment afin d'y placer un
contenu diffrent de celui prvu par le schma. La substitution d'lments va encore plus loin. Un document peut
remplacer un lment par un autre lment.
Les substitutions ne sont pas toujours possibles. Une premire condition pour qu'elles puissent s'effectuer est que
les types soient compatibles. Il faut que le type de substitution soit un type driv du type initial. Les substitutions
sont donc troitement lies aux diffrentes faons d'obtenir des types drivs par extension ou restriction.
Une seconde condition pour rendre possible les substitutions est que celles-ci doivent tre autorises par le schma.
Les schmas possdent diffrents outils pour contrler les substitutions [Section 5.10.4].
5.10.1. Annihilation
L'annihilation est un mcanisme qui permet de mettre aucun contenu un lment alors que le type de l'lment
prvoit que le contenu est normalement non vide. Cette notion correspond l'absence de valeur telle qu'elle existe
dans les bases de donnes.
Le schma doit d'abord autoriser le mcanisme en donnant la valeur true l'attribut nillable de l'lment
xsd:element. La valeur par dfaut de cet attribut est false. Le document doit ensuite, explicitement, dclarer
que l'lment n'a pas de valeur en donnant la valeur true l'attribut xsi:nil qui est dans l'espace de noms
[Chapitre 4] des instances de schmas. Le contenu de l'lment doit alors tre vide. Dans le schma suivant,
l'lment item est dclar annihilable.
Le document suivant est valide pour ce schma. L'lment item peut avoir un contenu vide si on lui ajoute un
attribut xsi:nil avec la valeur true.
82
Schmas XML
83
Schmas XML
L'attribut xsi:type peut aussi changer le type d'un lment en un autre type obtenu par restriction
du type original. Dans l'exemple suivant, un type Byte est dclar par restriction du type prdfini
xsd:nonNegativeInteger. Cet type est quivalent au type xsd:byte [Section 5.5.1.1] prdfini dans les
schmas.
Le document suivant est valide pour ce schma. Il est possible de changer le type de l'lment value en
xsd:nonNegativeInteger car ce type prdfini drive du type prdfini xsd:integer. Cet exemple
illustre aussi l'utilisation indispensable des espaces de noms. Il est, en effet, ncessaire de dclarer trois espaces de
noms : celui des lments du document, celui des schmas pour le type xsd:nonNegativeInteger et celui
des instances de schmas pour l'attribut xsi:type.
La substitution d'lment se distingue en plusieurs points de la substitution de type. Elle est videmment beaucoup
plus forte car elle affecte les lments qui peuvent apparatre dans les documents. Pour cette raison, elle doit
explicitement tre prvue par le schma par l'intermdiaire de groupes de substitution qui dcrivent quel lment
peut tre remplac et par quels lments. En revanche, le document ne signale pas la substitution comme il le fait
pour une substitution de type avec l'attribut xsi:type.
Ce mcanisme est mis en uvre en crant un groupe de substitution. Un groupe est form d'un lment chef de
groupe (group head en anglais) et d'autres lments qui se rattachent au chef de groupe. Le chef de groupe peut
tre remplac dans un document instance par n'importe quel autre lment du groupe. Le chef de groupe n'est pas
identifi directement. En revanche, tous les autres lments dclarent leur rattachement au groupe avec l'attribut
substitutionGroup dont la valeur est le nom du chef de groupe. Les groupes de substitution peuvent tre
bloqus par l'attribut final [Section 5.10.4]. Dans l'exemple suivant, le chef de groupe est l'lment integer.
Les lments positive et negative peuvent tre substitus l'lment integer.
84
Schmas XML
Le document suivant est valide pour ce schma. L'lment integers contient des lments positive et
negative remplacent des lments integer.
Depuis la version 1.1 des schmas, l'attribut substitutionGroup de xsd:element peut contenir plusieurs
noms d'lments. Un lment peut ainsi appartenir plusieurs groupes de substitution alors que c'tait impossible
avec la version 1.0.
Les substitutions peuvent tre utilises en cascade. Un lment membre d'un groupe de substitution peut, lui-
mme, tre chef d'un autre groupe de substitution. Les membres de ce dernier groupe peuvent bien sr remplacer
leur chef de groupe mais aussi son chef de groupe. Dans le schma suivant, l'lment head est le chef d'un groupe
comprenant l'lment subs. Cet lment subs est, son tour, chef d'un groupe de substitution comprenant
l'lment subsubs. Cet lment subsubs peut dont remplacer l'lment subs mais aussi l'lment head.
85
Schmas XML
Les dfinitions circulaires de groupes de substitution sont interdites. Un chef de groupe ne peut pas tre membre
d'un groupe dont le chef serait lui mme membre d'un de ses groupes. Les dclarations suivantes ne sont donc
pas valides.
Les groupes de substitution permettent, quelquefois, de compenser les lacunes de l'oprateur xsd:all
[Section 5.6.4]. Il est, en effet, possible de simuler un oprateur xsd:choice [Section 5.6.3] avec un lment
abstrait et un groupe de substitution.
Dans le schma suivant, l'lment number est abstrait. Il doit ncessairement tre remplac, dans un document,
par un lment de son groupe de substitution, c'est--dire par un lment integer ou par un lment double.
Il y a donc le choix entre un lment integer ou un lment double. Le type de l'lment number est
xsd:anyType pour que les types xsd:integer et xsd:double des lments integer et double
puissent en driver.
Les trois attributs abstract, block et final s'appliquent aussi bien aux declarations d'lments qu'aux
dfinitions de types. Il faut prendre garde au fait que leurs significations dans ces deux cas sont proches mais
nanmoins diffrentes.
86
Schmas XML
Le tableau suivant rcapitule les utilisations des trois attributs abstract, block et final pour les types et
les lments.
L'attribut fixed peut tre utilis dans toutes les facettes xsd:minLength, xsd:maxLength,
xsd:minInclusive, . Sa valeur par dfaut est la valeur false. Lorsqu'il prend la valeur true, la valeur
de la facette est bloque et elle ne peut plus tre modifie.
Dans le schma suivant, le type ShortString est obtenu par restriction du type xsd:string. Il impose une
longueur maximale la chane avec la facette xsd:maxLength. Cette facette est fixe avec fixed="true".
Le type VeryShortString est obtenu par restriction du type ShortString. Il ne peut pas donner une
nouvelle valeur xsd:maxLength.
87
Schmas XML
Un type complexe peut tre dclar abstrait en donnant la valeur true l'attribut abstract de l'lment
xsd:complexType. Un type simple dclar avec xsd:simpleType ne peut pas tre abstrait.
Ce mcanisme est assez semblable la notion de classe abstraite des langages de programmation orients objet
comme Java ou C++. Dans ces langages, un type dclar abstrait peut tre utilis pour driver d'autres types mais
il ne peut pas tre instanci. Ceci signifie qu'aucun objet de ce type ne peut tre cr. Il est, en revanche, possible
de crer des objets des types drivs.
Lorsqu'un type est dclar abstrait dans un schma, celui-ci peut encore tre utilis dans la dclaration d'un lment.
En revanche, l'lment ne pourra pas avoir ce type dans un document. Un document valide doit ncessairement
oprer une substitution de type par l'intermdiaire de l'attribut xsi:type [Section 5.10.2] ou une substitution
d'lment par l'intermdiaire d'un groupe de substitution [Section 5.10.3].
Dans l'exemple suivant, on dfinit un type abstrait Price et un type driv InternPrice. L'lment price
est du type Price. Il peut tre substitu par l'lment internprice qui est de type InternPrice.
Le document ci-dessous est valide pour le schma donn ci-dessus. L'lment price n'apparat pas avec le type
Price qui est abstrait. Soit le type Price est remplac par le type driv InternPrice, soit l'lment price
est remplac par l'lment internprice.
88
Schmas XML
<internprice currency="dollar">45.56</internprice>
</prices>
Dans l'exemple suivant, on dfinit un type abstrait AbstractType sans contrainte. Ce type est alors quivalent
au type xsd:anyType. On drive ensuite deux types par extension Derived1 et Derived2. Le premier type
Derived1 dclare un attribut att de type xsd:string et un lment string comme unique contenu. Le
second type Derived2 ne dclare aucun attribut mais il dclare un contenu constitu d'un lment string suivi
d'un lment integer.
Le document suivant est valide pour ce schma. L'lment value apparat deux fois dans le document mais avec
respectivement les types Derived1 et Derived2. Ces types sont dclars l'aide de l'attribut xsi:type.
89
Schmas XML
</tns:value>
</tns:values>
La contrainte impose en rendant un lment abstrait est plus forte que celle impose en rendant un type abstrait.
Il n'est, en effet, plus possible de remplacer le type. Il faut ncessairement remplacer l'lment.
Dans le schma suivant, l'lment value est dclar abstrait. Il est le chef d'un groupe qui comprend uniquement
l'lment other qui peut donc le remplacer.
Le document suivant est valide pour le schma prcdent. L'lment abstrait value n'apparat pas. Il est
systmatiquement remplac par l'lment other.
Lorsque restriction apparat, par exemple, dans la valeur de l'attribut block de la dfinition d'un type
complexe, celui-ci ne peut pas tre remplac dans un document par un type obtenu par restriction. Cette contrainte
s'applique aux substitutions de types et d'lments. Il n'est pas possible de changer le type d'un lment avec
l'attribut xsi:type [Section 5.10.2]. Il n'est pas possible non plus de substituer l'lment par un autre lment
[Section 5.10.3] dont le type est obtenu par restriction.
90
Schmas XML
Dans le schma suivant, les types Extension et Restriction sont respectivement obtenus par extension et
restriction du type Base. La dfinition de ce type Base contient block="#all". Ceci impose que l'lment
value ne peut pas changer son type en le type Restriction ou Restriction avec l'attribut xsi:type.
L'lment subs ne peut pas se substituer l'lment value car son type est Extension. En revanche, l'lment
sametype peut se substituer l'lment value car son type est Base.
91
Schmas XML
Un type driv peut tre contruit partir d'un type de base en utilisant plusieurs drivations successives. Ceci peut
tre, par exemple, une extension, ensuite une restriction puis finalement une nouvelle extension. La substitution
du type de base par le type driv est bloque si l'attribut block, dans la dfinition du type de base, mentionne
une drivation utilise par le type driv. Ceci est vrai que la drivation bloque soit la premire ou non. Dans
l'exemple prcdent, si l'attribut block contient restriction, le type driv ne peut pas remplacer le type de
base car la seconde drivation est une restriction.
Dans le schma suivant, le type List bloque sa substitution par un type obtenu par extension. Le type
ShortList est obtenu par restriction du type List et le type AttrShortList est obtenu par extension du
type ShortList. Le type ShortList peut se substituer au type List. Au contraire, le type AttrShortList
ne peut pas se substituer au type List car il y a une drivation par extension entre le type List et le type
AttrShortList.
92
Schmas XML
<item>Troisime item</item>
</list>
Dans le schma suivant, l'lment integer bloque toutes les substitutions de types dans les documents avec
block="restriction extension". Ce blocage empche de changer le type en un type driv avec
l'attribut xsi:type. Il empche galement l'lment positive de se substituer l'lment integer car son
type est obtenu par restriction du type xsd:integer. En rechanche, l'lment sametype dont le type est aussi
xsd:integer peut rempalcer l'lment integer.
L'attribut block de l'lment xsd:element peut aussi contenir la valeur substitution. Cette valeur a un
effet trs proche de l'attribut final avec la valeur #all. Elle empche les lments du groupe de substitution de
remplacer leur chef de groupe dans les documents instance. Cela anihile l'intrt de crer un groupe de substitution
puisque ses membres ne peuvent pas rellement se substituer leur chef de groupe.
Dans le schma suivant, les lments sametype et positive appartiennent au groupe de substitution de
l'lment integer. En rechanche, ils ne peuvent pas se substituer cet lment en raison de la valeur
substitution de l'attribut block. La substitution de type avec xsi:type [Section 5.10.2] reste toujours
possible.
93
Schmas XML
L'attribut final des lments xsd:simpleType et xsd:complexType permet d'empcher que le type
dfini puisse servir de type de base des constructions ou des drivations de types. Pour un type simple, la valeur
de cet attribut est soit la chane #all soit une liste de valeurs parmi les valeurs restriction, list et union.
Il est donc impossible de bloquer les extensions d'un type simple. Pour un type complexe, la valeur de cet attribut
est soit la chane #all soit une liste de valeurs parmi les valeurs extension, restriction. Les valeurs
numres ou toutes pour #all bloquent les diffrentes faons de dfinir des nouveaux types. La valeur par dfaut
de cet attribut est donne par la valeur de l'attribut finalDefault de l'lment xsd:schema [Section 5.3.1].
Le schma suivant n'est pas correct car les dfinitions des types Extension et Restriction sont impossibles
en raison de la valeur #all de l'attribut final dans la dfinition du type Base. Si la valeur de cet attribut final
est change en restriction, la dfinition du type Restriction reste incorrecte mais la dfinition du type
Extension devient valide.
94
Schmas XML
Le bloquage impos par l'attribut final n'opre que sur la drivation directe de types. Dans le schma suivant, le
type List bloque les extensions avec final="extension". Le type ShortList est driv par restriction
du type List. Ce type peut tre tendu en un type AttrShortList.
La diffrence entre les attributs final et block est que final concerne la dfinition de types drivs alors
que block concerne l'utilisation des types drivs dans les documents instance.
95
Schmas XML
L'attribut final de l'lment xsd:element permet de slectioner quels lments peuvent appartenir au groupe
de substitution de l'lment. La valeur de cet attribut est soit la chane #all soit une liste de valeurs parmi les
valeurs restriction et extension. Les valeurs numres ou toutes pour #all bloquent les lments dont
le type est obtenu par la drivation correspondante.
Dans le schma suivant, l'lment integer empche les lments dont le type est driv par extension de son
type xsd:integer d'appartenir son groupe de substitution. Comme le type xsd:positiveInteger est
obtenu par restriction du type xsd:integer, l'lment positive peut appartenir au groupe de substitution de
integer. En revanche, l'lment attributed ne pourrait pas appartenir ce groupe de substitution car son
type Attributed est obtenu par extension du type xsd:integer.
Le document suivant est valide pour le schma prcdent. L'lment attributed ne peut pas remplacer
l'lment integer.
Les groupes d'lments ne doivent pas tre confondus avec les groupes de substitution [Section 5.10.3] qui
permettent de remplacer un lment par un autre.
96
Schmas XML
Un groupe peut tre employ dans la dfinition d'un type ou la dfinition d'un autre groupe. L'utilisation d'un
groupe est quivalente l'insertion de son contenu. L'intrt d'un groupe est de pouvoir l'utiliser plusieurs reprises
et de factoriser ainsi les parties communes plusieurs types. L'utilisation d'un groupe est introduite par un lment
xsd:group avec un attribut ref qui donne le nom du groupe insrer.
Dans le schma suivant, le groupe FirstLast est dfini puis utilis dans la dfinition du groupe Name et du
type Person ainsi que dans la dfinition du type anonyme de l'lment character.
97
Schmas XML
<characters>
<character>
<firstname>Gaston</firstname>
<lastname>Lagaffe</lastname>
<creator>
<firstname>Andr</firstname>
<lastname>Franquin</lastname>
</creator>
</character>
<character>
<name>Astrix</name>
<creator>
<surname>Al Uderzo</surname>
<firstname>Albert</firstname>
<lastname>Uderzo</lastname>
</creator>
<creator>
<firstname>Ren</firstname>
<lastname>Goscinny</lastname>
</creator>
</character>
Un groupe est en fait un fragment de type qui peut tre utilis l'intrieur de la dfinition de n'importe quel type.
En revanche, il ne peut pas servir comme type dans la dclaration d'un l'lment. l'inverse, un type peut servir
dans la dclaration d'lments mais il ne peut pas tre directement inclus par un autre type.
Les groupes sont en fait un mcanisme d'abrviation. Ils permettent d'accrotre la modularit des schmas en
vitant de recopier plusieurs fois le mme fragment dans les dfinitions de diffrents types.
Dans l'exemple suivant, le groupe d'attributs LangType regroupe les dclaration des deux attributs lang et
type.
<xsd:attributeGroup name="LangType">
<xsd:attribute name="lang" type="xsd:language"/>
<xsd:attribute name="type" type="xsd:string"/>
</xsd:attributeGroup>
Un groupe d'attributs peut tre employ dans la dfinition d'un type ou la dfinition d'un autre groupe d'attributs.
L'utilisation d'un groupe est quivalente l'insertion de son contenu. L'utilisation d'un groupe est introduite par
un lment xsd:attributeGroup avec un attribut ref qui donne le nom du groupe insrer.
Le groupe d'attributs LangType peut tre employ de la faon suivante dans la dfinition d'un type complexe
nomm ou anonyme. Tout lment du type SomeType dfini ci-dessous pourra avoir les attributs lang et type
dclars dans le groupe LangType.
<xsd:complexType name="SomeType">
<!-- Contenu -->
...
<xsd:attributeGroup ref="LangType"/>
</xsd:complexType>
98
Schmas XML
Il est possible d'utiliser successivement plusieurs groupes d'attributs pour dclarer les attributs d'un type mais il
faut une occurrence de xsd:attributeGroup pour chaque groupe utilis.
<xsd:attributeGroup ref="AttrGroup1"/>
<xsd:attributeGroup ref="AttrGroup2"/>
Un groupe d'attributs peut aussi tre utilis dans la dfinition d'un autre groupe d'attributs. Le nouveau groupe
dfini contient tous les attributs du ou des groupes rfrencs en plus des attributs qu'il dclare explicitement. Ce
mcanisme est semblable l'hritage des classes dans les langages de programmation orients objet.
<xsd:attributeGroup name="LangTypeClass">
<xsd:attributeGroup ref="LangType"/>
<xsd:attribute name="class" type="xsd:string"/>
</xsd:attributeGroup>
Ces contraintes sont de deux types. Elles peuvent tre des contraintes d'unicit comme celle des attributs de type
ID des DTD ou des contraintes d'existence comme celle des attributs de type IDREF et IDREFS des DTD. Les
contraintes utilisent des expressions XPath [Chapitre 6] mais une connaissance superficielle de ce langage suffit
pour les utiliser.
Une contrainte d'unicit est donne par un lment xsd:key ou xsd:unique. Les contraintes introduites par
ces deux lments se prsentent de la mme faon et ont des smantiques trs proches. L'lment xsd:key ou
xsd:unique doit tre enfant d'un lment xsd:element qui dclare un lment. Cet lment qui contient la
contrainte dfinit la porte de celle-ci. Les contraintes d'unicit ainsi que les contraintes d'existence doivent tre
places aprs le type de la dclaration.
Chaque lment xsd:key ou xsd:unique possde un attribut name uniquement utilis par les contraintes
d'existence introduites par xsd:keyref et qui peut donc tre ignor pour l'instant. Il contient un lment
xsd:selector et des lments xsd:field possdant chacun un attribut xpath. L'lment xsd:selector
dtermine sur quels lments porte la contrainte. La valeur de son attribut xpath est une expression XPath qui
slectionne des lments concerns. Les lments xsd:field dterminent quelle est la valeur qui doit tre
unique. Cette valeur est constitue de plusieurs champs la manire d'un objet dans les langages de programmation.
La valeur de l'attribut xpath de chacun des lments xsd:field spcifie un champ de la valeur de la cl
d'unicit. La contrainte donne par un lment xsd:key impose que chacun des champs dtermin par les
lments xsd:field soit prsent et que la valeur ainsi constitue soit unique pour les lments slectionns par
xsd:selector dans le contenu de l'lment dfinissant la porte. Au contraire, la contrainte donne par un
99
Schmas XML
lment xsd:key n'impose pas que chacun des champs dtermin par les lments xsd:field soit prsent.
Elle impose seulement que les lments ayant tous les champs aient une valeur unique.
Dans l'exemple, la contrainte est dcrite au niveau de l'lment bibliography pour exprimer que l'attribut key
de book doit tre unique dans le contenu de l'lment bibliography.
Une contrainte dcrite avec xsd:key implique que les champs impliqus soient ncessairement prsents et non
annulables [Section 5.10.1]. Une contrainte dcrite avec xsd:unique est au contraire seulement vrifie pour
les lments dont tous les champs spcifis dans la contrainte sont prsents.
100
Schmas XML
Le document suivant est valide pour le schma prcdent. Deux lments person contenus respectivement dans
le premier et le deuxime lment group ont la mme valeur AC pour l'attribut id.
La contrainte person.names ci-dessous peut remplacer la contrainte person.id du schma prcdent. Elle
impose alors que la valeur forme des contenus des deux lments fitstname et lastname soit diffrente
pour chacun des lments person. Deux lments person contenus dans un mme lment group peuvent
avoir le mme contenu textuel pour l'lment firstname ou pour l'lment lastname mais pas pour les deux
en mme temps.
<xsd:key name="person.names">
<xsd:selector xpath="person"/>
<xsd:field xpath="firstname"/>
<xsd:field xpath="lastname"/>
</xsd:key>
La contrainte ci-dessus illustre aussi que la valeur peut aussi tre donne par des lments et pas seulement par
des attributs. Le document suivant vrifie la contrainte ci-dessus bien que deux lments person dans le mme
lment group aient la mme valeur Albert pour l'lment firstname. Deux lments ayant exactement
la mme valeur pour l'attribut id sont aussi dans le mme lment group mais la contrainte ne porte plus sur
cet attribut.
101
Schmas XML
<groups>
<group num="1">
<person id="AC">
<firstname>Albert</firstname>
<lastname>Cohen</lastname>
</person>
<person id="VH">
<firstname>Victor</firstname>
<lastname>Hugo</lastname>
</person>
<person id="AC">
<firstname>Anders</firstname>
<lastname>Celsius</lastname>
</person>
<person id="AE">
<firstname>Albert</firstname>
<lastname>Einstein</lastname>
</person>
</group>
</groups>
Il est bien sr possible de mettre plusieurs contraintes dans un mme lment. Les deux contraintes person.id
et person.names pourraient tre mises simultanment dans l'lment group comme ci-dessous.
<xsd:key name="person.id">
<xsd:selector xpath="person"/>
<xsd:field xpath="@id"/>
</xsd:key>
<xsd:key name="person.names">
<xsd:selector xpath="person"/>
<xsd:field xpath="firstname"/>
<xsd:field xpath="lastname"/>
</xsd:key>
Avec les contraintes donnes ci-dessus, le document prcdent n'est plus valide car deux lments person ont
la mme valeur AC pour leur attribut id.
Les seuls oprateurs autoriss dans les expressions XPath des attributs xpath de xsd:selector et
xsd:field sont l'oprateur d'union '|' [Section 6.2.4] et l'oprateur de composition de chemins '/'
[Section 6.2.3]. L'oprateur '|' peut apparatre au niveau global mais pas l'intrieur d'une expression de chemins
avec l'oprateur '/'. Les seuls axes [Section 6.2.1.1] autoriss dans ces expressions XPath sont les axes child::
et attribute:: dans leurs syntaxes abrges [Section 6.7] ' ' et '@'. L'axe descendant:: peut, en outre,
102
Schmas XML
apparatre au dbut des expressions de chemins dans sa syntaxe abrge './/'. Les filtres ne sont pas permis
dans ces expressions. La contrainte suivante impose, par exemple, que tous les enfants ainsi que tous les enfants
de ses enfants group aient des valeurs d'attribut id diffrentes.
<xsd:unique name="all.id">
<xsd:selector xpath="* | group/*"/>
<xsd:field xpath="id"/>
</xsd:unique>
Ces contraintes sont introduites par un lment xsd:keyref qui doit tre enfant d'un lment xsd:element.
Comme pour les contraintes d'unicit, cet lment dans lequel se trouve la contrainte dfinit la porte de celle-ci.
Chaque lment xsd:keyref possde des attributs name et refer. L'attribut name donne le nom de la
contrainte. La valeur de l'attribut refer doit tre le nom, c'est--dire la valeur de l'attribut name, d'une
contrainte d'unicit qui est associe cette contrainte d'existence. L'lment xsd:keyref contient un lment
xsd:selector et des lments xsd:field possdant chacun un attribut xpath. L'lment xsd:selector
slectionne sur quels lments porte la contrainte. La valeur de son attribut xpath est une expression XPath qui
slectionne des lments concerns. Les lments xsd:field dterminent les diffrents champs de la valeur
servant de cl. La contrainte donne par un lment xsd:keyref impose que pour chaque lment slectionn,
il existe un lment slectionn par la contrainte d'unicit associe qui a la mme valeur. La contrainte d'unicit
refrence par l'attribut refer doit se trouver dans le mme lment que xsd:keyref ou dans un de ses
descendants.
Dans l'exemple suivant, la contrainte d'unicit idchapter impose que la valeur d'un attribut id d'un lment
chapter soit unique. La contrainte d'existence idref utilise cette contrainte idchapter pour imposer que la
valeur d'un attribut idref de tout lment ref soit aussi la valeur d'un attribut id d'un lment chapter. Ceci
signifie que tout lment ref rfrence, par son attribut idref, un chapitre qui existe bien dans le document.
Dans l'exemple prcdent, la valeur d'un des attributs xpath est l'expression .//ref qui slectionne tous les
descendants de nom ref de l'lment courant. Cette expression est en fait une abrviation [Section 6.7] de
l'expression ./descendant-or-self::node()/ref.
103
Schmas XML
3. Tous les produits rfrencs dans les commandes sont prsents dans le catalogue.
104
Schmas XML
...
Si l'attribut targetNamespace de l'lment xsd:schema est absent, tous les lments et types dfinis dans
le schma sont sans espace de noms. Il faut cependant dclarer l'espace de noms des schmas pour qualifier les
lments des schmas (xsd:element, xsd:complexType, ).
Si la valeur de l'attribut elementFormDefault est qualified, tous les lments sont dans l'espace de noms
cible. Dans le schma suivant, les trois lments name, firstname et lastname sont dans l'espace de noms
http://www.omega-one.org/~carton/.
105
Schmas XML
Le comportement pour les attributs est identique mais il est gouvern par l'attribut attributeFormDefault
de l'lment xsd:schema. La valeur par dfaut de cet attribut est aussi unqualified.
Les lments et attributs dfinis globalement sont toujours dans l'espace de noms cible. Pour les lments
et attributs locaux, il est possible de changer le comportement dict par elementFormDefault et
attributeFormDefault en utilisant l'attribut form des lments xsd:element et xsd:attribute.
Cet attribut peut prendre les valeurs qualified ou unqualified. Le schma suivant spcifie que l'lment
firstname doit tre qualifi. Tous les autres lments locaux comme lastname n'ont pas tre qualifis car
la valeur par dfaut de l'attribut elementFormDefault est unqualified.
106
Schmas XML
Les lments, attributs, groupes et types doivent tre nomms avec un nom non qualifi quand ils sont
dclars ou dfinis. Ils sont ce moment implicitement qualifis par l'espace de nom cible. Ceci signifie
que les noms apparaissant dans l'attribut name de xsd:element, xsd:attribute, xsd:group,
xsd:attributeGroup, xsd:simpleType et xsd:complexType sont toujours des noms locaux, c'est-
-dire sans prfixe.
Dans l'exemple prcdent, le type Name est rfrenc par son nom qualifi dans la dclaration de l'lment name.
De la mme faon, toute rfrence un lment dclar globalement ou un groupe d'lments ou d'attributs
utilise un nom qualifi. Dans l'exemple suivant, l'lment name apparat dans la dfinition d'un autre type Tree
qui pourrait tre ajoute au schma prcdent. La dfinition de ce type est rcursive et la rfrence lui-mme
utilise bien sr le nom qualifi.
L'utilisation de minOccurs avec la valeur 0 pour l'lment child est indispensable pour terminer la rcursivit.
Sinon, aucun document valide ne peut avoir d'lment de type Tree. Le document suivant est valide pour le
schma prcdent. Les lments globaux tree et name doivent tre qualifis dans le document alors que l'lment
local child ne doit pas l'tre.
107
Schmas XML
<child><tns:name>Petit fils</tns:name></child>
</child>
<child><tns:name>Fils Droit</tns:name></child>
</tns:tree>
Il est souvent assez lourd de qualifier chacun des noms des objets dfinis dans le schma. Une alternative assez
commode consiste rendre l'espace de noms par dfaut gal l'espace de noms cible comme dans l'exemple
suivant. Ceci impose bien sr de ne pas utiliser l'espace de noms par dfaut pour les lments des schmas comme il
pourrait tre tentant de le faire. Dans la pratique, on associe l'espace de noms par dfaut l'espace de noms cible et
on dclare galement un prfixe pour cet espace de noms afin de pouvoir y faire rfrence de faon explicite. Dans
l'exemple suivant, l'espace de noms cible identifi par l'URI http://www.omega-one.org/~carton/ est
dclar comme l'espace de noms par dfaut et il est galement associ au prfixe tns.
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.omega-one.org/~carton/">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace"
schemaLocation="http://www.w3.org/2001/xml.xsd"/>
<xsd:element name="name">
<xsd:complexType>
<xsd:simpleContent>
<!-- Le contenu est purement textuel -->
<xsd:extension base="xsd:string">
<!-- L'lment name a les attributs xml:lang, xml:space ... -->
<xsd:attributeGroup ref="xml:specialAttrs"/>
</xsd:extension>
</xsd:simpleContent>
108
Schmas XML
</xsd:complexType>
</xsd:element>
</xsd:schema>
Un document valide pour ce schma est le suivant. L'espace de noms XML [Section 4.7] est toujours associ au
prfixe xml et il n'a pas besoin d'tre dclar.
La syntaxe des expressions rationnelles des schmas est inspire de celle du langage Perl avec cependant quelques
variations. Elle diffre de la syntaxe utilise par les DTD pour dcrire les contenus purs d'lments [Section 3.6.1]
car la concatnation n'est plus marque par la virgule ','. Ces expressions rationnelles sont utilises par la facette
xsd:pattern [Section 5.9.1.3] pour dfinir des restrictions de types simples. Elles sont galement utilises, en
dehors des schmas, par les fonctions XPath matches(), replace() et tokenize() [Section 6.3.3] ainsi
que l'lment XSLT xsl:analyze-string [Section 8.14].
La plupart des caractres se dsignent eux-mmes dans une expression. Ceci signifie que l'expression 'a' (sans
les apostrophes) dsigne l'ensemble rduit l'unique chane 'a' (sans les apostrophes). Certains caractres, dits
spciaux, ont une signification particulire dans les expressions. La liste des caractres spciaux comprend les
caractres '|', '?', '*', '+', '.', '\', '(', ')', '[', ']', '{', '}'. Pour supprimer le caractre spcial
d'un de ces caractres et l'inclure dans une expression, il faut le faire prcder du caractre d'chappement '\'.
Quelques caractres d'espacement [Section 2.2.2] bnficient de notations spcifiques. La tabulation U+09, le saut
de ligne U+0A et le retour chariot U+0D peuvent tre dsigns par '\t', '\n' et '\r'. Ces notations ne sont pas
indispensables puisque ces trois caractres peuvent tre insrs dans un document XML avec la notation &#....
5.15.1. Oprateurs
Les principaux oprateurs des expressions rationnelles sont l'union dsigne par le caractre '|', la concatnation
note par simple juxtaposition et les oprateurs de rptition '?', '*', '+'. Comme pour les expressions
arithmtiques, on peut utiliser les parenthses '(' et ')' pour former des groupes. Une expression de la forme
expr-1|expr-2 dsigne l'union des ensembles de chanes dsigns par expr-1 et expr-2. L'expression
a|b dsigne, par exemple, l'ensemble contenant les deux chanes 'a' et 'b' (sans les apostrophes). Une
expression de la forme expr-1expr-2 dsigne l'ensemble des chanes obtenues en concatnant (c'est--dire en
mettant bout bout) une chane conforme l'expression expr-1 et une chane conforme l'expression expr-2.
L'expression ab dsigne, par exemple, l'ensemble contenant l'unique chane ab. Il est, bien sr, possible de
combiner ces oprateurs. L'expression aba|ba dsigne, par exemple, l'ensemble form des deux chanes aba et
ba. L'expression a(a|b)bc dsigne l'ensemble contenant les deux chanes aabc et abbc.
5.15.2. Rptitions
Les oprateurs '?', '*', '+' permettent de rpter des groupes. Ils utilisent une notation postfixe : ils se placent
aprs leur oprande. S'ils sont placs aprs un caractre, ils s'appliquent uniquement celui-ci mais s'ils sont placs
aprs un groupe entre parenthses, ils s'appliquent tout le groupe. Ils autorisent, respectivement, la rptition de
leur oprande, zro ou une fois, un nombre quelconque de fois et un nombre positif de fois. Une expression de
la forme expr? dsigne l'ensemble constitu de la chane vide et des chanes conformes l'expression expr.
Une expression de la forme expr* dsigne l'ensemble constitu de toutes les chanes obtenues en concatnant
plusieurs (ventuellement zro) chanes conformes l'expression expr. L'expression a? dsigne, par exemple,
l'ensemble form de la chane vide et de la chane 'a'. Les expressions a* et (a|b)* dsignent, respectivement,
les ensembles constitus des chanes formes uniquement de 'a' et les chanes formes de 'a' et de 'b'.
109
Schmas XML
Les accolades '{' et '}' permettent d'exprimer des rptitions dont le nombre est, soit un entier fix, soit dans
un intervalle donn. Une expression de la forme expr{n}, o n est un entier, dsigne l'ensemble constitu de
toutes les chanes obtenues en concatnant exactement n chanes conformes l'expression expr. Une expression
de la forme expr{m,n}, o m et n sont des entiers, dsigne l'ensemble constitu de toutes les chanes obtenues
en concatnant un nombre de chanes conformes l'expression expr compris, au sens large, entre m et n. L'entier
n peut tre omis pour donner une expression de la forme expr{m,}. Le nombre de rptitions doit seulement
tre suprieur m. L'expression (a|b){6} dsigne, par exemple, les chanes de longueur 6 formes de 'a' et de
'b'. L'expression (a|b){3,8} dsigne les chanes de longueur comprise entre 3 et 8 formes de 'a' et de 'b'.
Le caractre spcial '.' dsigne tout caractre autre qu'un retour la ligne. L'expression a.b dsigne, par
exemple, l'ensemble de toutes les chanes de trois caractres dont le premier est 'a', le second n'est pas un retour
la ligne et le dernier est 'b'. L'expression .* dsigne l'ensemble de toutes les chanes ne contenant aucun retour
la ligne.
Un ensemble fini de caractres peut simplement tre dcrit en donnant ces caractres encadrs par des crochets '['
et ']'. L'expression [aeiouy] dsigne l'ensemble des voyelles minuscules et elle est quivalente l'expression
a|e|i|o|u|y. Cette syntaxe est pratique car elle permet d'inclure facilement un intervalle en plaant un tiret
'-' entre les deux caractres qui le dlimitent. L'expression [0-9] dsigne, par exemple, l'ensemble des chiffres.
Il est possible de mettre des caractres et plusieurs intervalles. L'expression [:a-zA-F] dsigne l'ensemble des
lettres minuscules et majuscules et du caractre ':'. L'ordre des caractres entre les crochets est sans importance.
Pour inclure un tiret '-' dans l'ensemble, il faut le placer en premier ou en dernier. Pour inclure un crochet fermant
']', il faut le placer en premier, juste aprs le crochet ouvrant. L'expression [-az] dsigne l'ensemble des trois
caractres '-', 'a' et'z'.
Lorsque le premier caractre aprs le crochet ouvrant est le caractre '^', l'expression dsigne le complmentaire
de l'ensemble qui aurait t dcrit sans le caractre '^'. L'expression [^0-9] dsigne, par exemple, l'ensemble
des caractres qui ne sont pas un chiffre. Pour inclure un caractre '^' dans l'ensemble, il faut le placer une
autre place que juste aprs le crochet ouvrant. L'expression [0-9^] dsigne, par exemple, l'ensemble form des
chiffres et du caractre '^'.
Un ensemble de caractres peut tre dcrit comme la diffrence de deux ensembles entre crochets. La syntaxe prend
la forme [...-[...]] o ... est remplac par une suite de caractres et d'intervalles comme dans les exemples
prcdents. L'expression [a-z-[aeiouy]] dsigne, par exemple, l'ensemble des consonnes minuscules.
Certains ensembles de caractres frquemment utiliss peuvent tre dcrits par le caractre d'chappement '\'
suivi d'une lettre. Les diffrentes combinaisons possibles sont donnes ci-dessous.
\s
\S
\d
\D
\w
110
Schmas XML
\W
\i
\I
caractres autres que les premiers caractres des noms XML, c'est--dire [^:_a-zA-Z]
\c
\C
caractre autres que les caractres des noms XML, c'est--dire [^-.:_0-9a-zA-Z]
L'expression \s*\d+\s* dsigne, par exemple, une suite non vide de chiffres encadre, ventuellement, par des
caractres d'espacement. L'expression \i\c* dsigne l'ensemble des noms XML.
Il est aussi possible de dcrire un ensemble de caractres en utilisant une des catgories de caractres Unicode.
La syntaxe prend la forme \p{cat} pour l'ensemble des caractres de la catgorie cat et \P{cat} pour
son complmentaire. L'expression \p{Lu} dsigne, par exemple, toutes les lettres majuscules. Les principales
catgories de caractres Unicode sont les suivantes.
Catgorie Signification
L lettres
Lu lettres majuscules
Ll lettres minuscules
N chiffres
P caractre de ponctuation
Z Sparateurs
111
Chapitre 6. XPath
XPath est un langage permettant de slectionner des parties d'un document XML. Il est utilis dans de nombreux
dialectes XML. Dans cet ouvrage, il est dj apparu dans les contraintes de cohrence [Section 5.12] des schmas
XML. Les schematrons [Chapitre 7] du chapitre suivant sont essentiellement bass sur XPath. Le langage XSLT
[Chapitre 8] fait galement un usage intensif de XPath pour dsigner les parties traiter.
Le langage XPath n'est pas un langage autonome. C'est un langage d'expressions utilis au sein d'un autre langage
hte. Il ressemble, dans cet aspect, aux expressions rationnelles, appeles aussi expressions rgulires qui est
abrg en regex telles qu'elles sont utilises dans les langages de script tels que Perl ou Python.
La syntaxe de XPath n'est pas une syntaxe XML car les expressions XPath apparaissent en gnral comme valeurs
d'attributs de documents XML. C'est en particulier le cas pour les schmas, les schematrons et XSLT.
XPath tait au dpart un langage permettant essentiellement de dcrire des ensembles de nuds dans un document
XML. La version 1.0 de XPath comprenait quelques fonctions pour la manipulation de nombres et de chanes
de caractres. L'objectif tait alors de pouvoir comparer les contenus de nuds. La version 2.0 de XPath a
considrablement enrichi le langage. Il est devenu un langage beaucoup plus complet capable, par exemple, de
manipuler des listes de nuds et de valeurs atomiques.
XPath est uniquement un langage d'expressions dont l'valuation donne des valeurs sans effet de bord. Il n'est pas
possible dans XPath de mmoriser un rsultat. Il n'existe pas de variables propres XPath mais une expression
XPath peut rfrencer des variables du langage hte. Les valeurs de ces variables sont alors utilises pour valuer
l'expression. L'affectation de valeurs ces variables se fait uniquement au niveau du langage hte.
Le cur de XPath est form des expressions de chemins permettant de dcrire des ensembles de nuds d'un
document XML. Ces expressions ressemblent aux chemins Unix pour nommer des fichiers dans une arborescence.
L'arbre d'un document est form de nuds de diffrents types qui correspondent aux diffrents constituants
possibles d'un document. Ces types de nuds font partie du systme de types [Section 6.1.4] de XPath. Ces types
rpartissent les nuds en un nombre fini de catgories. Ce type ne doit pas tre confondu avec le type associ
un nud lorsque le document a t valid par un schma. Ce dernier type est un type provenant du schma.
Le nud racine de l'arbre d'un document est un nud particulier appel document node ou root node dans
la terminologie de XPath 1.0. Ce nud ne doit pas tre confondu avec l'lment racine qui est un enfant de
ce document node.
112
XPath
element node
Chaque lment du document est reprsent par un nud de ce type. Le contenu texte de l'lment n'est pas
contenu dans ce nud mais dans des nuds textuels.
attribute node
Chaque attribut est reprsent par un nud de ce type dont le parent est le nud de l'lment ayant cet attribut.
La valeur de l'attribut est contenue dans le nud.
comment node
Chaque commentaire du document est reprsent par un nud de ce type qui contient le texte du commentaire.
Chaque instruction de traitement est reprsente par un nud de ce type qui contient le texte de l'instruction.
text node
Ces nuds dits textuels encapsulent le contenu texte des lments. Chaque fragment de texte non intrrompu
par un lment, une instruction de traitement ou un commentaire est contenu dans un tel nud. Le contenu
textuel d'un lment est rparti dans plusieurs nuds de ce type lorsque l'lment contient aussi d'autres
lments, des commentaires ou des instructions de traitement qui scindent le contenu textuel en plusieurs
fragments.
namespace node
Les nuds de ce type reprsentaient en XPath 1.0 les espaces de noms dclars dans un lment. Il sont
obsoltes et ne doivent plus tre utiliss. Ils sont remplacs par des fonctions XPath [Section 6.1.1.2].
Afin d'illustrer ces types de nuds, voici ci-dessous un document XML trs simple ainsi que son arbre.
Dans la figure ci-dessous, chaque nud de l'arbre est reprsent par un rectangle contenant trois informations. La
premire information est le type du nud, la deuxime est le nom ventuel du nud et la troisime est la valeur
textuelle du nud.
113
XPath
Docum ent
nom
Pour le nud d'un lment, d'un attribut ou d'une instruction de traitement, le nom est bien sr le nom de
l'lment, de l'attribut ou de l'instruction. Les nuds des commentaires et les nuds textuels n'ont pas de nom.
Le nud racine n'a galement pas de nom.
parent
Tout nud l'exception du nud racine a un parent qui est soit le nud racine soit le nud de l'lment qui le
contient. La relation parent/enfant n'est pas symtrique en XML. Bien que le parent d'un attribut soit l'lment
qui le contienne, l'attribut n'est pas considr comme un enfant de cet lment (cf. proprit suivante).
enfants
Seuls le nud racine et les nuds des lments peuvent avoir des enfants. Les enfants d'un nud sont les
nuds des lments, des instructions de traitement et des commentaires ainsi que les nuds textuels qu'il
contient. Les attributs ne font pas partie des enfants d'un lment. L'lment racine est un enfant du nud
racine qui peut aussi avoir des instructions de traitement et des commentaires comme enfants.
valeur textuelle
Chaque nud de l'arbre du document XML a une valeur qui est une chane de caractres Unicode [Section 2.2].
Pour un lment, cette valeur textuelle est le rsultat de la concatnation des contenus de tous les nuds
textuels qui sont descendants du nud. Ce texte comprend donc tout le texte contenu dans le nud, y compris
le texte contenu dans ses descendants. De manire image, cette chane est aussi obtenue en supprimant du
contenu de l'lment les balises de ses descendants, les instructions de traitement et les commentaires. La
valeur textuelle de l'lment p du fragment de document XML
est donc la chane Texte en italique et en gras italique. La valeur textuelle est retourne
par l'instruction XSLT xsl:value-of [Section 8.6.5].
114
XPath
Pour un attribut, la valeur textuelle est la valeur de l'attribut. Pour une instruction de traitement, c'est le texte
qui suit le nom de l'instruction. Pour un commentaire, c'est le texte du commentaire sans les dlimiteurs <!--
et -->. La valeur textuelle d'un nud textuel est juste le texte qu'il contient.
type
Cette proprit n'existe que si le document a t un valid par un schma [Chapitre 5]. Il s'agit du type attribu
l'lment ou l'attribut lors de la validation par le schma. Ce type peut tre un type prdfini ou un type
dfini dans le schma.
valeur type
Cette valeur n'existe que si le document a t un valid par un schma [Chapitre 5]. Il s'agit de la valeur
obtenue en convertissant la valeur textuelle dans le type du nud. Si le type d'un attribut est, par exemple,
xsd:double et sa valeur textuelle est la chane 1.0e-3, sa valeur est le nombre flottant 0.001. Cette
conversion n'est possible que si le type du nud est un type simple.
Chaque nud a une valeur qui est utilise chaque fois qu'un nud apparat l o une valeur atomique est
requise. Beaucoup de fonctions et d'oprateurs XPath prennent en paramtre des valeurs atomiques. Lorsqu'un
nud est pass en paramtre de tels fonctions ou oprateurs, celui-ci est converti automatiquement en sa valeur.
Ce processus se droule de la faon suivante. Si le nud a une valeur type (c'est--dire lorsque le document est
trait avec un schma), la valeur est la valeur type et son type est celui de la valeur type. Sinon, la valeur est
la valeur textuelle du nud et son type est xsd:untypedAtomic. Cette conversion d'un nud en valeur est
appele atomisation.
L'atomisation d'un nud peut donner une liste de valeurs atomiques ventuellement vide. C'est le cas lorsque le
type du nud est un type de listes comme le type prdfini xsd:IDREFS ou les types construits avec l'oprateur
xsd:list [Section 5.6.6].
Lorsqu'une liste contenant des nuds doit tre convertie en une liste de valeurs, chacun des nuds est atomis
et sa valeur le remplace dans la liste. Lorsque la valeur du nud comporte plusieurs valeurs atomiques, celles-ci
s'insrent dans la liste la place du nud.
6.1.1.2. Fonctions
Il existe des fonctions XPath permettant de rcuprer les proprits d'un nud. Les fonctions sont dcrites avec
leur type de retour et le type de leurs paramtres. Les types utiliss sont ceux du systme de typage [Section 6.1.4]
de XPath. Lorsque le type du paramtre est node()?, la fonction prend en paramtre un nud ou rien. Dans ce
dernier cas, le paramtre est implicitement le nud courant [Section 6.1.5.2].
retourne le nom complet du nud node ou du nud courant si node est absent.
retourne le nom local du nud node ou du nud courant si node est absent. Le nom local est la partie du
nom aprs le caractre ':' qui la spare du prfixe.
retourne le nom qualifi du nud node ou du nud courant si node est absent.
retourne la valeur textuelle du nud node ou du nud courant si node est absent. Cette fonction ne doit
pas tre confondue avec la fonction xsd:string() [Section 6.1.6] qui convertit une valeur en chane de
caractres.
115
XPath
retourne la racine de l'arbre qui contient le nud node ou le nud courant si node est absent.
node()* id(xsd:string s)
la chane s doit tre une liste de noms XML spars par des espaces. La fonction retourne la liste des nuds
dont la valeur de l'attribut de type ID [Section 3.7.2] ou xsd:ID [Section 5.5.1.4] est un des noms de la
chane s. La valeur passe en paramtre est souvent la valeur d'un attribut de type IDREF ou IDREFS. Pour
qu'un attribut soit de type ID, il doit tre dclar de ce type dans une DTD. Il est aussi possible d'utiliser
l'attribut xml:id [Section 2.7.4.4] qui est de type xsd:ID.
retourne l'URI de base [Section 2.7.4.3] du nud node ou du nud courant si node est absent.
retourne l'URI de base [Section 2.7.4.3] du document contenant le nud node ou le nud courant si node
est absent.
combine l'URI uri avec l'URI de base base et retourne le rsultat [Section 2.3.1]. Si l'URI base est omise
et que le langage hte est XSLT, c'est l'URI de base de la feuille de style qui est utilise.
Les espaces de noms [Chapitre 4] sont manipuls en XPath 1.0 travers l'axe namespace. Cet axe est obsolte
en XPath 2.0. Il est remplac par des fonctions permettant d'accder aux espaces de noms.
retourne l'URI qui dfinit l'espace de noms dans lequel se trouve le nud node ou le nud courant si node
est absent.
retourne la liste des prfixes associs un espace de noms dans le nud node. Si l'espace de noms par dfaut
est dfini, la liste contient la chane vide. La liste contient toujours le prfixe xml associ l'espace de noms
XML.
retourne l'URI qui dfinit l'espace de noms auquel est associ le prfixe prefix dans le nud node.
L'ordre du document peut tre manipul explicitement par les oprateurs XPath '<<' et '>>' [Section 6.5.3].
Il intervient aussi de faon implicite dans l'valuation de certains oprateurs, comme par exemple '/'
[Section 6.2.3], qui ordonnent les nuds de leur rsultat suivant cet ordre.
116
XPath
Les listes peuvent tre construites explicitement avec l'oprateur XPath ',' (virgule). L'oprateur XSLT
xsl:sequence [Section 8.6.8] permet galement de construire explicitement des squences. Beaucoup
d'oprateurs et de fonctions XPath retournent des listes comme valeurs.
Toute valeur est considre par XPath comme une liste de longueur 1 contenant cette valeur. Inversement, toute
liste de longueur 1 est assimile l'unique valeur qu'elle contient. Comme les listes ne peuvent pas tre imbriques,
cette identification est assez naturelle et elle ne conduit aucune confusion.
Les valeurs atomiques comprennent les chanes de caractres, les entiers, les nombres flottants et tous les types
prdfinis [Section 5.5.1] des schmas XML. Les principaux types pour les valeurs atomiques sont les suivants.
Pour chacun d'entre eux, un exemple de valeur est donn.
xsd:string
Chane de caractres : 'string' ou "string"
xsd:boolean
Boolen : true() et false()
xsd:decimal
Nombre dcimal : 3.14
xsd:float et xsd:double
Nombre flottant en simple et double prcision
xsd:integer
Entier : 42
xsd:anyURI
URI : http://www.omega-one.org/~carton/
xsd:untyped et xsd:untypedAtomic
Nud et valeur atomique non typs
6.1.4. Typage
XPath possde un systme de typage assez rudimentaire qui permet de dcrire les types des paramtres et le
type de retour des fonctions. Ce systme de typage est galement utilis par XSLT pour donner le type d'une
variable [Section 8.9] lors de sa dclaration et pour les types de retour et des paramtres des fonctions d'extension
[Section 8.10]. Les types des valeurs influent aussi sur les comportement de certains oprateurs et en particulier
des comparaisons [Section 6.5].
Ce systme est organis en une hirarchie dont la racine est le type item() (avec les parenthses). Tous les autres
types drivent de ce type qui est le plus gnral. Toute valeur manipule par XPath est donc de ce type.
117
XPath
Il y a ensuite des types pour les nuds et des types pour les valeurs atomiques. Pour les nuds, il y a d'abord
un type gnrique node() ainsi que des types pour chacun des types de nuds [Section 6.1.1]. Ces types
sont document-node(), element(), attribute(), text(), processing-instruction() et
comment() (avec les parenthses). Les types pour les valeurs atomiques sont les types prdfinis [Section 5.5.1]
des schmas comme xsd:integer.
Toute valeur atomique extraite du document par atomisation est type. Lorsque le document est valid par un
schma avant traitement par une feuille de style XSLT, les types des valeurs atomiques des contenus d'lments
et des valeurs d'attributs sont donns par le schma. Lorsque le document n'est pas valid par un schma, toutes
ces valeurs atomiques provenant du document sont considres du type xsd:untypedAtomic.
Le systme de type possde trois oprateurs '?', '*' et '+', en notation postfixe, pour construire de nouveaux
types. Ils s'appliquent aux types pour les nuds et les valeurs atomiques dcrits prcdemment. L'oprateur '?'
dsigne un nouveau type autorisant l'absence de valeur. Ces types sont surtout utiliss pour dcrire les paramtres
optionnels des fonctions. La fonction XPath name() [Section 6.1.1.1] a, par exemple, un paramtre de type
node()?. Ceci signifie que son paramtre est soit un nud soit rien. L'oprateur '*' construit un nouveau
type pour les listes. Le type xsd:integer* est, par exemple, le type des listes d'entiers ventuellement vides.
L'oprateur '+' construit un nouveau type pour les listes non vides. Le type xsd:integer+ est, par exemple,
le type des listes non vides d'entiers.
6.1.5. Contexte
L'valuation d'une expression XPath se fait dans un contexte qui est fourni par le langage hte. Le contexte
se dcompose en le contexte statique et le contexte dynamique. Cette distinction prend du sens lorsque les
programmes du langage hte sont susceptibles d'tre compils. Le contexte statique comprend tout ce qui peut
tre dtermin par une analyse statique du programme hte. Tout ce qui dpend du document fait, au contraire,
partie du contexte dynamique.
Les expressions XPath sont beaucoup utilises dans les feuilles de style XSLT. Comme le langage XSLT est
sans effet de bord, l'analyse statique des feuilles de styles XSLT est relativement facile et permet de dterminer
beaucoup d'informations.
Espaces de noms
Tous les espaces de noms [Chapitre 4] en porte, y compris ventuellement l'espace de noms par dfaut. Le
contexte comprend les associations entre les prfixes et les URI qui identifient les espaces de noms. Ceci
permet de prendre en compte les noms qualifis.
Variables
Toutes les variables en porte et leur type ventuel. Les valeurs de ces variables font partie du contexte
dynamique.
Fonctions
Toutes les fonctions disponibles. Ceci comprend les fonctions standards de XPath, les fonctions de conversion
de types et les fonctions d'extension [Section 8.10] dfinies au niveau du langage hte.
Collations
URI de base
118
XPath
L'objet courant est indispensable puisqu'il permet de rsoudre toutes les expressions relatives trs souvent utilises.
L'objet courant est trs souvent un nud du document mais il peut aussi tre une valeur atomique. Lorsque l'objet
courant est un nud, il est appel le nud courant. C'est est un peu l'quivalent du current working directory
d'un shell Unix. L'expression @id retourne, par exemple, l'attribut id du nud courant. L'valuation de certaines
expressions, comme par exemple @id, provoque une erreur si l'objet courant n'est pas un nud. L'objet courant
est retourn par l'expression XPath '.' (point).
Il est frquent qu'une expression XPath soit value pour diffrentes valeurs de l'objet courant prises dans une
liste. L'objet courant parcourt successivement les valeurs de cette liste qui peut tre dtermine avant l'valuation
ou au cours de l'valuation de l'expression XPath. Pour chaque valeur prise dans la liste par l'objet courant, la
position dans le contexte et la taille du contexte sont respectivement la position de la valeur dans liste et la taille
de la liste. La taille du contexte est bien sr la mme pour toutes les valeurs alors que la position dans le contexte
change pour chaque valeur. La position dans le contexte et sa taille sont retournes par les deux fonctions XPath
position() et last().
Variables locales
Certains oprateurs XPath comme for, some et every [Section 6.6.2] introduisent des variables locales
qui font partie du contexte dynamique.
Pour chaque type de base des schmas comme xsd:boolean ou xsd:string, il existe une fonction XPath
de conversion ayant le mme nom. Celle-ci convertit une valeur quelconque en une valeur du type en question.
La fonction xsd:boolean() convertit, par exemple, une valeur en une valeur boolenne [Section 6.3.1].
retourne le nombre n format avec le format format o l'interprtation de ce format est donn par l'lment
xsl:decimal-format [Section 8.6.12] identifi par id.
retourne un identifiant pour le nud node ou le nud courant si node est absent. Au cours d'un mme
traitement, plusieurs appels generate-id avec le mme paramtre donnent le mme identifiant. En
revanche, des appels dans des traitements diffrents peuvent conduire des rsultats diffrents. Cette fonction
119
XPath
est souvent utilise pour produire une valeur destine un attribut de type ID ou xsd:ID comme xml:id
[Section 2.7.4.4].
node() current()
retourne le nud courant auquel s'applique la rgle dfinie par l'lment XSLT xsl:template
[Section 8.5.1].
node()* current-group()
retourne la liste des nuds du groupe courant lors de l'utilisation de l'lment XSLT xsl:for-each-
group [Section 8.7.4].
xsd:string current-grouping-key()
xsd:string regexp-group(xsd:integer n)
retourne le fragment de texte entre une paire de parenthses de l'expression rationnelle lors de l'utilisation de
l'lment XSLT xsl:matching-substring [Section 8.14].
Le type fondamental de XPath est la liste mais les oprateurs de chemins retournent des listes o les nuds sont
dans l'ordre du document et o chaque nud a au plus une seule occurrence. Ces listes reprsentent en fait des
ensembles de nuds. Ce comportement assure une compatibilit avec XPath 1.0 qui manipule des ensembles de
nuds plutt que des listes.
Il existe deux syntaxes, une explicite et une autre abrge pour les expressions de chemins. La premire facilite
la comprhension mais la seconde, beaucoup plus concise, est gnralement utilise dans la pratique. La syntaxe
abrge est dcrite en [Section 6.7] mais la plupart des exemples sont donns avec les deux syntaxes pour une
meilleure familiarisation avec les deux syntaxes.
L'axe par dfaut est l'axe child qui slectionne les enfants du nud courant.
node()
tous les enfants du nud courant, ce qui n'inclut pas les attributs
ancestor::*
tous les anctres stricts du nud courant
6.2.1.1. Axes
Chacun des axes donne une relation qui relie les nuds slectionns au nud courant. Les axes qu'il est possible
d'utiliser dans les expressions XPath sont les suivants.
120
XPath
self
child
Enfant direct
parent
Parent
attribute
Attribut du nud
descendant
Descendant strict
descendant-or-self
121
XPath
ancestor
Anctre strict
ancestor-or-self
preceding-sibling
following-sibling
preceding
gauche
following
droite
122
XPath
namespace
L'axe namespace est un hritage de XPath 1.0 qui doit tre considr comme obsolte. Il est conseill d'utiliser
les fonctions XPath [Section 6.1.1.2] pour accder aux espaces de noms d'un nud.
parent
self
preceding-sibling following-sibling
child
Root
Ancest or
Self
Preceding Following
Descendant
123
XPath
6.2.1.2. Types
Une fois donn un axe, le type permet de restreindre l'ensemble des nuds slectionns un des nuds d'une
certaine forme. Les types possibles sont les suivants.
ns:*
tous les lments ou tous les attributs (suivant l'axe) dans l'espace de noms associ au prfixe ns
*:local
tous les lments ou tous les attributs (suivant l'axe) de nom local local
name
les nuds de nom name (lments ou attributs suivant l'axe utilis)
node()
text()
comment()
processing-instruction() ou processing-instruction(name)
child::* ou *
attribute::* ou @*
attribute::id ou @id
attribut id du nud courant
child::node() ou node()
tous les enfants du nud courant
child::text ou text
tous les lments de nom text qui sont enfants du nud courant
child::text() ou text()
124
XPath
descendant::comment()
tous les commentaires qui sont descendants du nud courant, c'est--dire contenus dans le nud courant
following::processing-instruction()
child::processing-instruction('xml-stylesheet')
toutes les instructions de traitement de nom xml-stylesheet qui sont enfants du nud courant.
tous les attributs autres que id. Cette expression peut aussi tre crite @* except @id.
child::node()[position() = 4] ou node()[4]
descendant::item[attribute::id] ou .//item[@id]
tous les descendants du nud courant qui sont un lment item ayant un attribut id
ancestor::*[@type='base']
tous les anctres du nud courant dont l'attribut type existe et vaut base.
chapter[count(child::section) > 1]
Une expression de la forme expr1/expr2 est value de la faon suivante. L'expression expr1 est d'abord
value pour donner une liste d'objets. Pour chacun des objets de cette liste, l'expression expr2 est value en
modifiant dynamiquement le focus [Section 6.1.5.2] de la faon suivante. L'objet courant est fix l'objet choisi
dans la liste, la position dans le contexte est fixe la position de cet objet dans la liste et la taille du contexte est
galement fixe la taille de la liste. Les listes retournes par chacune des valuations de expr2, sont fusionnes
pour donner une liste de nuds dans l'ordre du document et avec au plus une occurrence de chaque nud dans la
125
XPath
liste. Cette liste est alors le rsultat de l'valuation de expr1/expr2. Si l'valuation de expr1 retourne la liste
vide, l'valuation de expr1/expr2 retourne aussi la liste vide. Le focus reprend, aprs l'valuation, sa valeur
initiale.
Supposons, par exemple, que l'expression expr1 retourne la liste (n1, n2, n3) forme de trois nuds.
L'expression expr2 est donc value trois fois. Elle est value une premire fois en prenant le nud courant
gal n1, la position du contexte gale 1 et la taille du contexte gale 3. Elle est value une deuxime fois
en prenant le nud courant gal n2, la position du contexte gale 2 et la taille du contexte gale 3. Elle est
value une troisime et dernire fois en prenant le nud courant gal n3, la position du contexte gale 3 et la
taille du contexte gale 3. Si ces trois valuations retournent respectivement les listes (n0, n2, n5), (n1)
et (n0, n1, n2, n4, n6) et que l'ordre du document est n0, n1, n2, n4, n5, n6, le rsultat de
l'valuation est la liste (n0, n1, n2, n4, n5, n6).
self::node()/child::* ou ./*
tous les lements qui sont enfants du nud courant
child::*/child::* ou */*
tous les lments qui sont des enfants des enfants du nud courant
child::p/child::em ou p/em
tous les lments em enfants d'un lment p enfant du nud courant
child::*/attribute::* ou */@*
tous les attributs des lments qui sont enfants du nud courant
parent::*/parent::* ou ../..
le parent du parent du nud courant
parent::*/child::* ou ../*
tous lments qui sont frres du nud courant, y compris le nud courant
child::*/parent::* ou */..
le nud courant s'il contient au moins un lment ou aucun nud sinon
descendant::p/child::em ou .//p/em
tous les lements em qui sont enfants d'un lment p descendant du nud courant
descendant::*/descendant::* ou descendant::*
tous les lments descendants du nud courant
ancestor::*/descendant::*
tous les lments du document
descendant::*/ancestor::*
tous les anctres et tous les descendants du nud courant ayant au moins un lment comme enfant si le nud
courant a au moins un lment comme enfant et aucun nud sinon.
descendant::p/following-sibling::em[position()=1] ou .//p/following-
sibling::em[1]
premier frre em d'un lment p descendant du nud courant.
child::*/position()
liste (1, 2, , n) o n est le nombre d'enfants du nud courant.
L'oprateur '/' peut tre cascad et il est associatif gauche. Une expression de la forme expr1/expr2/
expr3 est implicitement parenthse (expr1/expr2)/expr3. Ce parenthsage est trs souvent inutile car
l'oprateur '/' est associatif l'exception de quelques cas pathologiques.
child::*/child::*/attribute::* ou */*/@*
tous les attributs des lments qui sont des enfants des enfants du nud courant
126
XPath
parent::*/child::*/descendant::text()
tous les nuds textuels descendants d'un frre du nud courant
L'oprateur '/' peut aussi tre employ dans des expressions de la forme /expr2 qui sont l'analogue des chemins
absolus dans les systmes de fichiers.
Une expression de la forme /expr2 est value de la faon suivante. L'expression expr2 est value en ayant,
au pralable, fix le nud courant la racine de l'arbre contenant le nud courant, la position dans le contexte
1 et la taille du contexte 1. Une telle expression est donc quivalente une expression root(.)/expr2. La
fonction root() retourne la racine de l'arbre contenant son paramtre.
Le nud courant appartient trs souvent l'arbre d'un document XML. Dans ce cas, la racine de cet arbre est un
nud de type document node. Il est galement possible que le nud courant appartienne un fragment de
document et que la racine de cet arbre soit un nud quelconque.
Les expressions de la forme /expr2 se comportent comme des chemins absolus puisqu'elles s'valuent en partant
d'une racine. Elles ne sont, toutefois, pas compltement absolues car la racine choisie dpend du nud courant.
La racine choisie est celle de l'arbre contenant le nud courant.
/
le nud document node racine de l'arbre
/child::* ou /*
l'lment racine du document
/child::book ou /book
l'lment racine du document si son nom est book et aucun nud sinon
/child::book/child::chapter ou /book/chapter
les lments chapter enfant de l'lment racine du document si son nom est book et aucun nud sinon
/descendant::section ou //section
tous les lments section du document
L'oprateur d'union est not par le mot cl union ou par le caractre '|'. Les oprateurs d'intersection et de
diffrence sont nots respectivement par les mots cl intersect et except.
@* except @id
tous les attributs except l'attribut id
Bien que les listes manipules par XPath peuvent contenir des nuds et des valeurs atomiques, ces oprateurs
fonctionnent uniquement avec des listes reprsentant des ensembles de nuds. Ils ne fonctionnent pas avec des
listes contenant des valeurs atomiques. Les listes de nuds retournes par ces oprateurs sont tries dans l'ordre
du document et ne comportent pas de doublon.
127
XPath
Les valeurs boolennes peuvent tre manipules l'aide des oprateurs and et or et de la fonction not().
true() or false()
true
not(false())
true
Les valeurs des autres types peuvent tre converties explicitement en des valeurs boolennes par la fonction
xsd:boolean() [Section 6.1.6]. Elles sont aussi converties implicitement ds qu'une valeur boolenne est
requise. C'est le cas, par exemple, des filtres [Section 6.4.2], de la structure de contrle if [Section 6.6.1] de
XPath ou des structures de contrle xsl:if [Section 8.7.1] et xsl:when [Section 8.7.2] de XSLT. Les rgles
qui s'appliquent alors sont les suivantes.
Une liste non vide dont le premier lment est un nud est convertie en true.
Si la liste contient une seule valeur atomique, les rgles suivantes s'appliquent. Rappelons qu'une valeur
atomique est considre comme une liste contenant cet objet et inversement.
Une chane de caractres est convertie en true sauf si elle est vide.
xsd:boolean(())
donne false car la liste est vide
xsd:boolean((/,0))
donne true car le premier objet de la liste est un nud
xsd:boolean(0)
donne false car l'entier est gal 0
xsd:boolean(7)
donne true car l'entier est diffrent de 0
xsd:boolean('')
donne false car la chane de caractres est vide
xsd:boolean('string')
donne true car la chane de caractres n'est pas vide
128
XPath
6.3.2. Nombres
Les seuls nombres existant en XPath 1.0 taient les nombres flottants. XPath 2.0 manipule les nombres des trois
types xsd:integer, xsd:decimal et xsd:double des schmas XML [Section 5.5.1.1].
Oprateur div
Cet oprateur calcule le quotient de la division de deux nombres entiers, dcimaux ou flottants.
Ces oprateurs calculent respectivement le quotient et le reste de la division entire de deux entiers.
3 idiv 2, 3 mod 2
2, 1
number abs(number x)
retourne la valeur absolue d'un nombre entier ou flottant. La valeur retourne est du mme type que la valeur
passe en paramtre.
abs(-1), abs(2.3)
1, 2.3
number floor(number x)
retourne la valeur entire approche par valeur infrieure d'un nombre dcimal ou flottant.
number ceiling(number x)
retourne la valeur entire approche par valeur suprieure d'un nombre dcimal ou flottant.
number round(number x)
retourne la valeur entire approche la plus proche d'un nombre dcimal ou flottant. Si le paramtre est gal
n+1/2 pour un entier n, la valeur retourne est l'entier n+1.
round-half-to-even(12.34,-1), round-half-to-even(12.34,1)
10, 12.3
129
XPath
round-half-to-even(2.5), round-half-to-even(3.5)
2, 4
sum(1 to 6)
21
avg(1 to 6)
3.5
Une chane littrale est dlimite par une paire d'apostrophes ''' ou une paire de guillemets '"'. Lorsqu'elle est
dlimite par une paire d'apostrophes, les guillemets sont autoriss l'intrieur et les apostrophes sont incluses en
les doublant. Lorsqu'elle est, au contraire, dlimite par une paire de guillemets, les apostrophes sont autorises
l'intrieur et les guillemets sont inclus en les doublant.
'Une chane'
donne Une chaine
Les expressions XPath sont trs souvent utilises commme valeurs d'attributs d'un dialecte XML comme les
schemas XML [Chapitre 5] ou XSLT [Chapitre 8]. Dans ce cas, les apostrophes ou les guillemets qui dlimitent
la valeur de l'attribut doivent tre introduits avec les entits prdfinies [Section 3.5.1.2] que cela soit comme
dlimiteur ou l'intrieur d'une chane.
Il existe de nombreuses fonctions permettant de manipuler les chanes de caractres. Dans les exemples ci-dessous,
les chanes apparaissant dans les valeurs des expressions sont crites avec des dlimiteurs ''' bien que ceux-ci
ne fassent pas partie des chanes.
130
XPath
string-length('Hello world')
11
retourne la concatnation des chanes de caractres s1, s2, s3, . Le nombre de paramtres de cette fonction
est variable.
retourne la concatnation des chanes de caractres de la liste en insrant la chane sep entre elles.
Contrairement la fonction concat, le nombre de paramtres de cette fonction est fix 2 mais le premier
paramtre est une liste.
retourne la comparaison des deux chanes de caractres s1 et s2 en utilisant la collation [Section 2.2.5]
optionnelle identifie par l'URI col. La valeur de retour est -1, 0 ou 1 suivant que s1 est avant s2 pour
l'ordre lexicographique, gale s2 ou aprs s2. Si col est absente, la collation par dfaut est utilise. Celle-
ci est base sur les codes Unicode.
compare('Hello', 'world')
-1
compare('hello', 'World')
1
retourne true si la chane factor apparat comme sous-chane dans la chane s et false sinon.
contains('Hello', 'lo')
true
retourne true si une partie de la chane s est conforme l'expression rationnelle regexp [Section 5.15] et
false sinon. La chane optionnelle flags prcise comment doit tre effectue l'opration.
matches('Hello', '^\w+$')
true
131
XPath
substring('Hello world', 3, 5)
'llo w'
retourne la chane obtenue en remplaant dans la chane s chaque caractre de la chane from par le caractre
la mme position dans la chane to. Si la chane from est plus longue que la chane to, les caractres de
from sans caractre correspondant dans to sont supprims de la chane s.
retourne la chane obtenue en remplaant dans la chane s les occurrences de l'expression rationnelle regexp
[Section 5.15] par la chane repl. L'expression regexp peut dlimiter des blocs avec des paires de
parenthses '(' et ')' qui peuvent ensuite tre utiliss dans la chane repl avec la syntaxe $1, $2, .
132
XPath
retourne la liste des chanes obtenues en dcoupant la chane s chaque occurence de l'expression regexp
[Section 5.15] qui ne peut pas contenir la chane vide.
tokenize('Hello  world', '\s')
('Hello', '', 'world')
xsd:string normalize-space(xsd:string s)
supprime les caractres d'espacement [Section 2.2.2] en dbut et en fin de chane et remplace chaque suite de
caractres d'espacement conscutifs par un seul espace. Le rsultat est du type xsd:normalizedString
[Section 5.5.1.2].
xsd:string lower-case(xsd:string s)
lower-case('Hello world')
'hello world'
xsd:string upper-case(xsd:string s)
upper-case('Hello world')
'HELLO WORLD'
convertit une liste de points de code [Section 2.2] en une chane de caractres.
xsd:integer* string-to-codepoints(xsd:string s)
convertit une chane de caractres en une liste de points de code [Section 2.2].
string-to-codepoints('A€0')
(65, 8364, 48)
retourne la normalisation [Section 2.2.6] de la chane s avec la normalisation spcifie par la chane
norm. Cette dernire peut prendre les valeurs NFC, NFD, NFKC et NFKD condition que chacune de ces
normalisations soit implmente. Si norm est absente, c'est la normalisation C (NFC) par dfaut qui est
utilise. Celle-ci est toujours implmente.
normalize-unicode('ö')
'' o le caractre '' U+308 est le caractre spcial trma.
133
XPath
La principale diffrence avec les expressions rationnelles des schmas est l'ajout des deux ancres '^' et '$'. Ces
deux caractres deviennent spciaux. Ils dsignent la chane vide place, respectivement, au dbut et la fin de
la chane. Ces deux caractres sont utiles car la fonction matches() retourne true ds qu'un fragment de la
chane est conforme l'expression rationnelle. Pour forcer la chane, prise dans son intgralit, tre conforme, il
faut ajouter les caractres '^' et '$' au dbut et la fin de l'expression rationnelle.
Le fonctionnement des ancres '^' et '$' est modifi par le modificateur 'm'.
6.3.4.1. Modificateurs
Les fonctions matches() et replace() prennent un dernier paramtre optionnel flag qui modifie leur
comportement. Ce paramtre doit tre une chane de caractres pouvant contenir les caractres 'i', 'm' et 's'
dans n'importe quel ordre. Chacun de ces caractres joue le rle d'un modificateur qui influence un des aspects
du fonctionnement de ces fonctions.
Le caractre 'i' indique que la chane est compare l'expression sans tenir compte de la casse des lettres. Ceci
signifie que les lettres minuscules et majuscules ne sont plus distingues.
Le caractre 'm' modifie la signification des ancres '^' et '$'. Il indique que la chane est compare
l'expression en mode multi-ligne. Dans ce mode, la chane est vue comme plusieurs chanes obtenues en dcoupant
chaque saut de ligne marqu par le caractre U+0A [Section 2.2.2]. Ceci signifie que le caractre '^' dsigne
alors la chane vide place au dbut de la chane ou aprs un saut de ligne et que le caractre '$' dsigne alors
la chane vide place la fin de la chane ou avant un saut de ligne.
matches('Hello
world', '^Hello$')
donne false.
Le caractre 's' modifie la signification du caractre spcial '.'. Il dsigne normalement tout caractre autre
qu'un saut de ligne. Avec le modificateur 's', il dsigne tout caractre, y compris le saut de ligne U+0A
[Section 2.2.2].
matches('Hello
world', '^.*$')
donne false.
6.4. Listes
La liste est la structure de donnes fondamentale de XPath. Il existe plusieurs oprateurs permettant de construire et
de manipuler des listes. La restriction importante des listes XPath est qu'elles ne peuvent pas tre imbriques. Une
liste XPath ne peut pas contenir d'autres listes. Elle peut uniquement contenir des nuds et des valeurs atomiques.
134
XPath
Ainsi, l'expression ((1,2),(3,4,5)) ne donne pas une liste contenant deux listes de deux et trois entiers. Elle
donne la liste de cinq entiers que donne galement l'expression (1,2,3,4,5).
6.4.1. Constructeurs
L'oprateur essentiel de construction de listes est ',' (virgule) qui permet de concatner, c'est--dire mettre
bout bout, des listes. Il est aussi bien utilis pour crire des listes constantes comme (1,2,3,4,5) que pour
concatner les rsultats d'autres expressions. Contrairement aux oprateurs de chemins [Section 6.2], l'oprateur
',' ne rordonne pas les lments des listes et ne supprime pas les doublons. Le rsultat de l'expression
expr1,expr2 est la nouvelle liste forme des valeurs du rsultat de expr1 suivies des valeurs du rsultat de
l'expression expr2. Si une valeur apparat dans les deux rsultats, elle a plusieurs occurrences dans le rsultat
final. Par exemple, le rsultat de l'expression (1,2),(1,3) est bien la liste (1,2,1,3) avec deux occurrences
de l'entier 1.
Le fait qu'une valeur soit assimile la liste (de longueur 1) contenant cette valeur simplifie l'criture des
expressions. Ainsi les deux expressions (1),(2) et 1,2 sont quivalentes.
title, author
donne la liste des enfants de nom title puis des enfants de nom author du nud courant.
(1, 2), 2, 1, 2
donne la liste (1, 2, 2, 1, 2) avec rptitions.
L'oprateur to permet de crer une liste contenant une suite d'entiers conscutifs. L'expression n1 to n2
donne la liste n1,n1+1,n1+2,,n2-1,n2 des entiers de n1 n2 compris. Cet oprateur est surtout utile avec
l'oprateur for [Section 6.6.2] pour itrer sur une liste d'entiers.
1 to 5
donne la liste (1, 2, 3, 4, 5)
1, 2 to 4, 5
donne la liste (1, 2, 3, 4, 5)
6.4.2. Filtres
Un filtre permet d'extraire d'une liste les objets qui satisfont une condition pour former une nouvelle liste. Un filtre
se prsente comme une expression entre des crochets '[' et ']' place aprs la liste filtrer.
Une expression de la forme expr1[expr2] est value de la faon suivante. L'expression expr1 est d'abord
value pour donner une liste l d'objets. Pour chaque objet o de la liste l, l'expression expr2 est value en
modifiant, au pralable, le focus [Section 6.1.5.2] de la manire suivante. L'objet courant est fix l'objet o, la
position du contexte est fixe la position de l'objet o dans la liste l et la taille du contexte est fixe la taille de
l. Le rsultat de cette valuation est ensuite converti en une valeur boolenne en utilisant les rgles de conversion
[Section 6.3.1]. Le rsultat final de l'valuation de expr1[expr2] est la liste des objets de l pour lesquels
expr2 s'est value en la valeur true. Les objets slectionns restent bien sr dans l'ordre de la liste l. La liste
rsultat est en fait construite en supprimant de la liste l les objets pour lesquels expr2 s'value en false.
Lors de l'valuation de l'expression suivante, l'objet courant qui est retourn par '.' prend les valeurs successives
1, 2, 3, 4 et 5. Seules les valeurs paires satisfont la condition et sont conserves.
(1 to 5)[. mod 2 = 0]
135
XPath
Les filtres sont beaucoup utiliss dans les expression de chemin [Section 6.2.2] pour slectionner des nuds.
Plusieurs conditions peuvent tre combines l'aide des oprateurs boolens and et or. Les filtres peuvent aussi
tre enchans en les mettant l'un aprs l'autre.
Le second exemple montre que les filtres peuvent tre enchans. Il ne donne pas le mme rsultat que le premier
exemple car les positions retournes par la fonction position() du second filtre sont celles dans la liste obtenue
aprs le premier filtre. Comme le premier enfant text a t supprim, il y a un dcalage d'une unit.
Les expressions de chemins retournent des listes de nuds tris dans l'ordre du document et sans doublon. Au
contraire, l'oprateur ',' ne supprime pas les doublons.
p[@align or @type]
donne la liste des enfants p du nud courant ayant un attribut align ou type.
p[@align], p[@type]
donne la liste des enfants p du nud courant ayant un attribut align suivis des enfants p ayant un attribut
type. Si un nud p possde les deux attributs, il apparat deux fois dans la liste.
6.4.3. Fonctions
Il existe des fonctions XPath permettant de manipuler les listes.
xsd:integer count(item()* l)
retourne la longueur de la liste l, c'est--dire le nombre de nuds ou valeurs atomiques qui la composent.
count('Hello world', 1, 2, 3)
4
xsd:boolean empty(item()* l)
empty(1 to 5)
false
xsd:boolean exists(item()* l)
exists(1 to 5)
true
item()* distinct-values(item()* l)
retourne une liste des valeurs distinctes de la liste l en supprimant les valeurs gales pour l'oprateur eq.
136
XPath
remove(1 to 5, 3)
(1, 2, 4, 5)
insert-before(1 to 5, 3, 1 to 3)
(1, 2, 1, 2, 3, 3, 4, 5)
item()* reverse(item()* l)
reverse(1 to 5)
(5, 4, 3, 2, 1)
6.5. Comparaisons
Les comparaisons sont un aspect important mais dlicat de XPath. Elles jouent un rle important en XPath car
elles permettent d'affiner la slection des nuds en prenant en compte leurs contenus. Il est, par exemple, possible
de slectionner des lments d'un document dont la valeur d'un attribut satisfait une condition comme dans les
expressions item[@type='free'] et list[@length < 5]. Les comparaisons sont dlicates utiliser
car leur smantique n'est pas toujours intuitive.
Il existe deux types d'oprateurs pour effectuer des comparaisons entre valeurs. Les premiers oprateurs dits
gnraux datent de la premire version de XPath. Ils permettent de comparer deux valeurs quelconques, y compris
des listes, avec des rsultats parfois inattendus. Les seconds oprateurs ont t introduits avec la version 2.0
de XPath. Ils autorisent uniquement les comparaisons entres les valeurs atomiques de mme type. Ils sont plus
restrictifs mais leur comportement est beaucoup plus prvisible. Ils ncessitent, en revanche, que les valeurs
compares soient du bon type. Ceci impose de valider le document avec un schma ou de faire des conversions
explicites de types avec les fonctions appropries [Section 6.1.6].
Il existe aussi l'oprateur is et les deux oprateurs << et >> permettant de tester l'galit et l'ordre des nuds
[Section 6.1.2] dans le document.
137
XPath
de caractres est l'ordre lexicographique du dictionnaire. Cet ordre lexicographique prend en compte les collations
[Section 2.2.5].
2 ne 3
donne true
2 lt 3
donne true
'chaine' ne 'string'
donne true
'chaine' lt 'string'
donne true
Ces oprateurs de comparaison exigent que leurs deux paramtres soient du mme type. Les constantes prsentes
dans le programme sont automatiquement du bon type. En revanche, les contenus des lments et les valeurs
des attibuts doivent tre convertis explicitement l'aide des fonctions de conversion lorsque le document est
trait indpendamment d'un schma. Pour tester si la valeur d'un attribut pos vaut la valeur 1, il est ncessaire
d'crire xsd:integer(@pos) eq 1 o la valeur de l'attribut pos est convertie en entier par la fonction
xsd:integer. Les oprateurs gnraux de comparaison vitent ces conversions fastidieuses car ils effectuent
eux-mmes des conversions implicites.
La contrainte d'galit des types des valeurs n'est pas stricte. Il est possible de comparer une valeur d'un type avec
une valeur d'un type obtenu par restriction [Section 5.9]. Il est galement possible de comparer des valeurs des
diffrents types numriques xsd:integer, xsd:decimal, xsd:float et xsd:double.
Les objets comparer sont d'abord atomiss [Section 6.1.1.1], ce qui signifie que les nuds prsents dans les
listes sont remplacs par leur valeur pour obtenir uniquement des valeurs atomiques. Ensuite, la comparaison est
effectue de faons diffrentes suivant que les objets sont des listes composes d'une seule valeur (considres
alors comme une simple valeur) ou de plusieurs valeurs.
Lorsque les deux valeurs sont de type xsd:untypedAtomic, celle-ci sont compares comme des chanes de
caractres. Lorsqu'une seule des deux valeurs est de type xsd:untypedAtomic, celle-ci est convertie dans le
type de l'autre valeur avant de les comparer. Quand le type de l'autre valeur est un type numrique, la valeur de
type xsd:untypedAtomic est convertie en une valeur de type xsd:double plutt que dans le type de l'autre
138
XPath
valeur. Ceci vite qu'une valeur dcimale comme 1.2 soit convertie en entier avant d'tre compare la valeur
1. Si les deux valeurs sont de types incompatibles, la comparaison choue et provoque une erreur.
Les expressions suivantes sont values sur le document prcdent en supposant, chaque fois, que le nud
courant est l'lment racine list du document. Pour chacune des expressions, le rsultat est une liste d'enfants
item de l'lment list. Il est dcrit en donnant les positions de ces lments item slectionns. Le rsultat
item[1], item[2] de la premire expression signifie, par exemple, qu'elle slectionne le premier et le
deuxime enfants item.
item[@type=1]
donne item[1], item[2] car la valeur de l'attribut type est convertie en nombre flottant avant d'tre
compare 1. La valeur '01' est donc convertie en '1'.
item[@type='1']
donne item[1] car la valeur de l'attribut type est convertie en chane de caractres avant d'tre compare
'1'.
item[@type=.]
donne item[1] car la valeur de l'attribut type et le contenu de l'lment item sont convertis en chanes
de caractres avant d'tre compars.
item[@type=1.2]
donne item[4] car la valeur de l'attribut type est convertie en nombre flottant avant d'tre compare 1.2.
item[xsd:double(.)=xsd:double(@type)]
donne item[1], item[3] car la valeur de l'attribut type et le contenu de l'lment item sont convertis
en nombres flottants avant d'tre compars.
Il faut faire attention au fait que les comparaisons peuvent chouer et provoquer des erreurs lorsque les types ne
sont pas compatibles. Ce problme renforce l'intrt de la validation des documents avant de les traiter.
() = ()
donne false car une des deux listes est vide.
() != ()
donne false car une des deux listes est vide.
L'exemple prcdent montre que l'oprateur != n'est pas la ngation de l'oprateur =, ce qui n'est pas trs intuitif.
139
XPath
() != (1)
donne false car une des deux listes est vide.
(1) = (1)
donne true car la valeur 1 de la liste l1 est gale la valeur 1 de la liste l2.
(1) != (1)
donne false car l'unique valeur 1 de la liste l1 n'est pas diffrente de l'unique valeur 1 de la liste l2.
(1) = (1, 2)
donne true car la valeur 1 de la liste l1 est gale la valeur 1 de la liste l2.
(1) != (1, 2)
donne true car la valeur 1 de la liste l1 est n'est pas gale la valeur 2 de la liste l2.
Ds que la comparaison de deux valeurs des listes l1 et l2 choue, la comparaison globale entre les listes l1
et l2 choue galement. L'ordre des comparaisons entre les valeurs des deux listes est laiss libre par XPath et
chaque logiciel peut les effectuer dans l'ordre qui lui convient. Lorsqu'une de ces comparaisons donne la valeur
true et qu'une autre de ces comparaisons choue, le rsultat de la comparaison des deux listes est imprvisible.
Il est gal true si une comparaison donnant true est effectue avant toute comparaison qui choue mais la
comparaison globale choue dans le cas contraire.
La smantique des comparaisons de listes permet d'crire simplement certains tests. Pour savoir si une valeur
contenue, par exemple, dans une variable $n est gale une des valeurs de la liste (2, 3, 5, 7), il suffit
d'crire $n = (2, 3, 5, 7).
Les deux oprateurs '<<' et '>>' permettent de tester si un nud se trouve avant ou aprs un autre nud dans
l'ordre du document [Section 6.1.2].
Les expressions suivantes sont values sur le document prcdent en supposant, chaque fois, que le nud
courant est la racine du document.
list is list/item/parent::*
donne true car il s'agit du mme nud qui est l'lment racine du document.
list/item[1]/@type is list/item[2]/@type
donne false car il s'agit de deux nuds diffrents bien que les deux attributs aient mme nom et mme
valeur.
140
XPath
Un exemple pertinent d'utilisation de l'oprateur is est donn par la feuille de style avec indexation [Section 8.12]
pour regrouper les diteurs et supprimer leurs doublons dans le document bibliography.xml.
Elle est quivalente au fragment XSLT suivant o le test est ralis par un lment xsl:choose [Section 8.7.2].
<a>
<xsl:choose>
<xsl:when test="@xml:id">
<xsl:attribute name="id" select="@xml:id"/>
</xsl:when>
<xsl:otherwise>
<xsl:attribute name="id" select="generate-id()"/>
</xsl:otherwise>
</xsl:choose>
</a>
6.6.1. Conditionnelle
L'oprateur if permet d'effectuer un test. Sa syntaxe est la suivante.
La smantique est celle de if dans tous les langages de programmation. L'expression test est value et le
rsultat est converti en une valeur boolenne [Section 6.3.1]. Si cette valeur boolenne est true, l'expression
expr1 est value et le rsultat est celui de l'expression globale. Sinon, l'expression expr2 est value et le
rsultat est celui de l'expression globale.
La partie else expr2 est obligatoire et ne peut pas tre omise. Lorsque cette seconde partie est inutile, on met
simplement else ().
L'oprateur if est parfois remplac par un filtre [Section 6.4.2]. L'expression if (@xml:id) then @xml:id
else generate-id() est en effet quivalente l'expression plus concise (@xml:id, generate-id())
[1].
6.6.2. Itration
L'oprateur for permet de parcourir des listes pour construire une nouvelle liste. Il ne s'agit pas d'une structure
de contrle pour des itrations quelconques comme le for ou le while des langages C ou Java. Il s'apparente
plus l'oprateur map des langages fonctionnels comme ML qui permet d'appliquer une fonction chacun des
objets d'une liste.
La syntaxe de l'oprateur for est la suivante o var est une variable et expr1 et expr2 sont deux expressions.
La variable var peut uniquement apparatre dans l'expression expr2.
141
XPath
L'valuation d'une telle expression est ralise de la faon suivante. L'expression expr1 est d'abord value pour
donner une liste de valeurs. Pour chacune de ces valeurs, celle-ci est affecte la variable var et l'expression
expr2 est value. Le rsultat global est la liste obtenue en concatnant les listes obtenues pour chacune des
valuations de l'expression expr2.
Le rsultat de l'expression expr2 est une liste qui peut donc contribuer plusieurs valeurs de la liste finale. Si,
au contraire, ce rsultat est la liste vide, il n'y a aucune contribution la liste finale.
La variable var introduite par l'oprateur for est une variable muette. Sa porte est rduite l'expression expr2
aprs le mot cl return. Aucune valeur ne peut lui tre affecte directement.
for $i in 1 to 5 return $i * $i
l'valuation de cette expression donne la liste (1,4,9,16,25) des cinq premiers carrs
Il est possible d'imbriquer plusieurs oprateurs for. Il y a d'ailleurs une syntaxe tendue qui permet une criture
concise de ces itrations imbriques. Cette syntaxe prend la forme suivante.
Cette expression est, en fait, quivalente l'expression suivante crite avec la premire syntaxe.
for var-1 in expr-1 return for return for var-N in expr-N return expr
for $i in 0 to 2, $j in 0 to 2 return $i * 3 + $j
l'valuation de cette expression donne la liste (0,1,2,3,4,5,6,7,8) qui est la concatnation des trois
listes (0,1,2), (3,4,5) et (6,7,8)
L'valuation d'une telle expression est ralise de la faon suivante. L'expression expr1 est d'abord value pour
donner une liste de valeurs. Pour chacune de ces valeurs, celle-ci est affecte la variable var et l'expression
expr2 est value. Le rsultat de l'expression globale est true si au moins une des valuations de expr2 donne
une valeur qui se convertit en true [Section 6.3.1]. Il est gal false sinon.
142
XPath
L'valuation d'une telle expression est ralise de la faon suivante. L'expression expr1 est d'abord value pour
donner une liste de valeurs. Pour chacune de ces valeurs, celle-ci est affecte la variable var et l'expression
expr2 est value. Le rsultat de l'expression globale est true si toutes les valuations de expr2 donnent une
valeur qui se convertit en true [Section 6.3.1]. Il est gal false sinon.
' '
..
//
[n]
En XPath 1.0, la formule '.' tait une abrviation pour self::node() et elle dsignait toujours un nud. En
XPath 2.0, elle dsigne l'objet courant qui peut tre une valeur atomique ou un nud.
Il faut remarquer que '//' n'est pas une abbrviation de descendant-or-self::. Les deux expressions
//section[1] et descendant-or-self::section[1] donnent des rsultats diffrents. La premire
expression donne la liste des lments section qui sont le premier enfant section de leur parent alors que la
seconde donne le premier lment section du document.
6.8. Motifs
Les motifs XPath sont des expressions XPath simplifies permettant de slectionner de faon simple des nuds
dans un document. Ils sont beaucoup utiliss par XSLT [Chapitre 8], d'abord pour spcifier des nuds auxquels
s'applique une rgle [Section 8.5.1] mais aussi pour la numrotation [Section 8.6.11] et l'indexation [Section 8.12].
Ils rpondent une exigence d'efficacit. Le cur de XSLT est l'application de rgles des nuds du document
source. Il est important de dterminer rapidement quelles sont les rgles susceptibles de s'appliquer un nud.
Dans ce but, les motifs n'utilisent qu'un sous-ensemble trs limit de XPath. De surcrot, les motifs sont valus
de faon particulire, sans utiliser le nud courant.
Les seuls oprateurs utiliss dans les motifs sont les oprateurs '|', '/' et '//' et leur imbrication est trs
restreinte. Un motif prend ncessairement la forme suivante
143
XPath
o les expressions expr-1, , expr-N ne contiennent que des oprateurs '/' et '//'. En outre, les seuls axes
possibles dans les motifs sont les deux axes child::, attribute::. L'axe descendant-or-self:: est
implicite dans l'utilisation de l'oprateur '//' mais c'est la seule faon de l'utiliser dans un motif. En revanche, les
tests portant sur les types de nuds comme text() ou comment() et les filtres sont autoriss dans les motifs.
L'valuation d'un motif XPath est ralise de faon diffrente d'une expression XPath classique. Celle-ci ne
ncessite pas de nud courant. Un motif est toujours valu partir de la racine du document. De plus, un
motif commence toujours implicitement par l'oprateur '//'. Le motif section est, en fait, valu comme
l'expression //section. Il slectionne tous les lments section du document. Des exemples de motifs avec
les nuds qu'ils slectionnent sont donns ci-dessous.
la racine du document
section
tous les lments section
chapter|section
tous les lments chapter et section
chapter/section
tous les lments section enfants d'un lment chapter
chapter//section
tous les lments section descendants d'un lment chapter
section[1]
tous les lments section qui sont le premier enfant de leur parent
section[@lang]
tous les lments section ayant un attribut lang
section[@lang='fr']
tous les lments section dont l'attribut lang a la valeur fr
@*
section/@lang
tous les attributs lang des lments section
text()
144
XPath
Le mode interactif de xmllint est activ avec l'option --shell. Les principales commandes disponibles sont
alors les suivantes.
help
affiche un rcapitulatif des commandes disponibles.
cd path
change le nud courant en le nud retourn par l'expression XPath path.
pwd
affiche le nud courant.
xpath path
affiche le rsultat de l'valution de l'expression XPath path.
cat [node]
affiche le contenu du nud node.
dir [node]
affiche les informations relatives au nud node.
grep string
affiche les occurrences de la chane string dans le contenu du nud courant.
145
XPath
146
Chapitre 7. Schematron
7.1. Introduction
Schematron est un autre formalisme permettant de spcifier la structure d'un document XML. C'est donc au
dpart une alternative aux schmas [Chapitre 5] mais il est plutt complmentaire des schmas. Ce formalisme
n'est pas trs adapt pour dfinir l'imbrication des lments comme le font les DTD [Chapitre 3] ou les schmas
en donnant une grammaire. En revanche, il permet d'imposer des contraintes sur le document qu'il est difficile,
voire impossible, d'exprimer avec les schmas. Il est frquent d'utiliser les deux formalismes conjointement.
Un schma dfinit la structure globale du document et un schematron la complte en ajoutant des contraintes
supplmentaires que doit satisfaire le document pour tre valide. Il existe d'ailleurs des mcanismes permettant
d'inclure un schematron au sein d'un schma.
Schematron est bas sur XPath [Chapitre 6]. Un schematron est constitu de rgles crites avec des expressions
XPath qui expriment la prsence ou l'absence de motifs dans le document. Ce mcanisme rend schematron
trs puissant puisqu'il est possible de mettre en relation des lments et des attributs qui sont loigns dans le
document. Schematron reste cependant trs simple car le vocabulaire est restreint. L'criture d'un schematron
requiert l'utilisation de seulement quelques lments.
lment racine sch:schema du schematron avec la dclaration de l'espace de noms des schematrons.
Titre informatif du schematron.
Rgle s'appliquant tous les lments list du document cible.
Contrainte proprement dite exprime par une expression XPath.
Texte utilis pour la fabrication du rapport.
Si le schematron prcdent est appliqu au document XML suivant, le rapport va contenir le texte
"L'attribut ... d'enfants." car la contrainte entre la valeur de l'attribut length et le nombre d'enfants
de l'lment list n'est pas satisfaite par le deuxime lment list du document.
147
Schematron
Le rsultat de la vrification du document ci-dessus avec le schematron donn prcdemment est donn la section
suivante.
7.3. Fonctionnement
Le principe de fonctionnement de schematron est le suivant. Un document cible est valid avec un schematron
en utilisant une application approprie. Cette validation produit un rapport qui retrace les diffrentes tapes de la
validation. Ce rapport contient des messages destins l'utilisateur. Ces messages peuvent provenir d'ventuelles
erreurs mais ils peuvent aussi tre positifs et confirmer que le document satisfait bien certaines contraintes. Ces
diffrents messages sont produits par l'application de validation ou ils sont issus du schematron. Le schematron
associe, en effet, des messages aux diffrentes contraintes qu'il contient. Ce rapport est souvent lui mme un
document XML.
La validation d'un document avec un schematron est souvent ralise en deux phases. Dans une premire phase, le
schematron est transform en une version compile qui est indpendante du document. Dans une seconde phase,
la version compile est utilise pour produire le rapport. La premire phase est parfois, elle-mme, scinde en
plusieurs tapes afin de prendre en compte les rgles [Section 7.6] et les blocs abstraits [Section 7.7].
Co m p ila t e u r
com piler.xsl
Sc h e m a t ro n Sc h e m a t ro n c o m p il
schem a.sch schem a.xsl
XSLT
Pro c e s s o r
Do c u m e n t Ra p p o rt
docum ent .xm l report .xm l
XSLT
Pro c e s s o r
La composition exacte du rapport dpend de l'application qui ralise la validation du document avec le schematron.
Il contient des fragments de texte issus du schematron mais aussi du texte produit par l'application de validation. Ce
148
Schematron
rapport peut tre un simple fichier texte mais il est souvent un document XML, en particulier lorsque la validation
est ralise via XSLT. Le format SVRL est un dialecte XML conu spcialement pour les rapports de validation
avec des schematrons. Il est en particulier utilis par l'implmentation standard de schematron disponible l'adresse
http://www.schematron.com/.
Le rapport SVRL obtenu par la validation du document XML avec le schematron donn ci-dessus est le suivant.
Un schematron est essentiellement constitu de rgles regroupes en blocs. Il contient galement du texte
permettant de dcrire les oprations effectues. Il peut aussi dclarer des espaces de noms et des cls XSLT
[Section 8.12].
La dclaration d'un espace de noms se fait par l'lment sch:ns dont les attributs prefix et uri donnent
respectivement le prfixe et l'URI qui identifie l'espace de noms.
149
Schematron
Le contenu de chaque lment sch:pattern est compos de rgles. Chaque rgle est donne par un lment
sch:rule dont l'attribut context dtermine quels nuds la rgle s'applique. Chaque rgle contient ensuite
des tests introduits par les lments sch:assert et sch:report.
<sch:pattern>
<sch:rule context="...">
...
</sch:rule>
<sch:rule context="...">
...
</sch:rule>
...
</sch:pattern>
La validation d'un document avec un schematron consiste traiter squentiellement chacun des blocs de rgles.
Pour chaque bloc et pour chaque nud du document cible est dtermine la rgle appliquer. Les diffrents tests
de cette rgle sont raliss et des messages sont ajouts au rapport en fonction des rsultats de ces tests. Mme si
plusieurs rgles peuvent s'appliquer un nud, une seule des rgles du bloc est rellement applique. Il faut donc
viter la situation o plusieurs rgles d'un mme bloc s'appliquent potentiellement un mme nud.
7.5. Rgles
Chaque rgle est matrialise par un lment sch:rule qui contient un ou plusieurs tests. L'lment sch:rule
possde un attribut context dont la valeur doit tre un motif XPath [Section 6.8]. Ce motif dtermine sur quels
nuds s'applique la rgle.
Les tests d'une rgle sont introduits par les lments sch:assert et sch:report. Ces deux lments prennent
la mme forme. Ils possdent un attribut test dont la valeur est une expression XPath et ils contiennent du texte
qui est ventuellement utilis pour construire le rapport. Ces deux lments se distinguent par leurs smantiques
qui sont l'oppos l'une de l'autre.
<sch:rule context="...">
150
Schematron
<sch:assert test="...">
...
</sch:assert>
<sch:report test="...">
...
</sch:report>
...
</sch:rule>
Un test introduit par sch:assert est ralis de la faon suivante. L'expression XPath contenue dans l'attribut
test est value en prenant le nud slectionn comme contexte et le rsultat de l'valuation est converti en
une valeur boolenne [Section 6.3.1]. Si le rsultat est false, le texte contenu dans l'lment sch:assert est
ajout au rapport. Sinon rien n'est ajout au rapport.
Dans l'exemple ci-dessous, le message d'erreur est ajout au rapport si la condition n'est pas vrifie, c'est--dire
si l'lment book n'a aucun des attributs id ou key.
<sch:rule context="book">
<sch:assert test="@id|@key">
L'lment book doit avoir un attribut id ou key
</sch:assert>
</sch:rule>
Un test introduit par sch:report est, au contraire, ralis de la faon suivante. L'expression XPath contenue
dans l'attribut test est value en prenant le nud slectionn comme contexte et le rsultat de l'valuation
est converti en une valeur boolenne [Section 6.3.1]. Si le rsultat est true, le texte contenu dans l'lment
sch:report est ajout au rapport. Sinon rien n'est ajout au rapport.
Dans l'exemple ci-dessous, le message d'erreur est ajout au rapport si la condition est vrifie, c'est--dire si
l'lment book a simultanment les deux attributs id et key.
<sch:rule context="book">
<sch:report test="count(@id|@key) > 1">
L'lment book doit avoir un seul des attributs id ou key
</sch:report>
</sch:rule>
Chaque rgle peut bien sr contenir plusieurs lments sch:assert et sch:report comme dans l'exemple
ci-dessous. L'ordre de ces diffrents lments est sans importance.
<sch:rule context="tns:pattern[@is-a]">
<sch:assert test="key('patid', @is-a)">
L'attribut is-a doit rfrencer un bloc abstrait.
</sch:assert>
<sch:report test="@abstract = 'true'">
Un bloc avec un attribut is-a ne peut pas tre abstrait.
</sch:report>
<sch:report test="rule">
Un bloc avec un attribut is-a ne peut pas contenir de rgle.
</sch:report>
</sch:rule>
Le texte contenu dans les lments sch:assert et sch:report peut aussi contenir des lments sch:name
et sch:value-of qui permettent d'ajouter du contenu dynamique. Lors de la construction du rapport, ces
lments sont valus et ils sont remplacs par le rsultat de leur valuation. L'lment sch:name s'value en le
nom de l'lment sur lequel est appliqu la rgle. Il est particulirement utile dans les rgles abstraites [Section 7.6]
et les blocs abstraits [Section 7.7] o le nom du contexte n'est pas fix. L'lment sch:value-of a un attribut
select contenant une expression XPath. L'valuation de cette expression remplace l'lment sch:value-of
dans le rapport. Un exemple d'utilisation de cet lment est donn la section suivante.
151
Schematron
Une rgle est dclare abstraite avec un attribut abstract ayant la valeur true. Elle n'a pas d'attribut context.
Elle possde, en revanche, un attribut id qui permet de la dsigner pour l'utiliser. Une autre rgle peut utiliser une
rgle abstraite en lui fournissant un contexte. Elle fait appel la rgle abstraite grce l'lment sch:extends
dont l'attribut rule donne l'identifiant de la rgle abstraite.
Dans l'exemple suivant une rgle abstraite de nom has-title est dfinie. Elle vrifie que le nud contexte
possde un enfant title et que celui-ci est le premier enfant. Deux rgles utilisent ensuite cette rgle pour les
lments book et chapter.
152
Schematron
Ce schematron permet de vrifier que le document suivant n'est pas correct. L'lment title n'est pas le premier
enfant du second chapter et le troisime chapter n'a pas d'enfant title.
Un bloc est dclar abstrait avec un attribut abstract ayant la valeur true. Il a aussi un attribut id pour lui
donner un identifiant. Le bloc qui utilise un bloc abstrait doit avoir un attribut is-a qui donne l'identifiant du bloc
abstrait. Il ne doit pas contenir de rgles mais seulement des lments sch:param qui permettent d'instancier
les paramtres. L'lment sch:param a des attributs name et value qui donnent respectivement le nom du
paramtre et la valeur qui lui est affecte.
Le fonctionnement des blocs abstraits est semblable au passage de paramtres des lments xsl:apply-
templates et xsl:call-template [Section 8.9.2] de XSLT. En revanche, l'lment sch:param des
153
Schematron
schematrons est l'analogue de l'lment xsl:with-param de XSLT. L'lment xsl:param de XSLT n'a pas
d'quivalent dans les schematrons car les paramtres des blocs abstraits ne sont pas dclars.
Le schematron suivant dfinit un bloc abstrait de nom uniq qui contient deux rgles dpendant des paramtres
elem et desc. La premire rgle vrifie que l'lment elem a au moins un descendant desc. La seconde vrifie
au contraire qu'il n'a pas plus d'un descendant desc. Ces deux rgles conjugues vrifient donc que l'lment
elem a exactement un seul descendant desc.
Le bloc abstrait uniq est ensuite utilis par les deux blocs uniq-id et uniq-title. Le premier bloc donne
les valeurs book et @id|@key aux deux paramtres elem et desc. Il vrifie donc que chaque lment book
possde exactement un seul des deux attributs id et key. Le second bloc donne les valeurs book et title aux
paramtres elem et desc. Il vrifie donc que chaque lment book possde exactement un seul enfant title.
La vrification effectue par le premier bloc n'est pas faisable avec les DTD [Chapitre 3] et les schmas
XML [Chapitre 5]. Les dclarations d'attributs de ces deux langages se font sur chacun des attributs de faon
indpendante. Il n'est pas possible d'exprimer une contrainte qui met en relation deux attributs ou deux lments.
Le mcanisme des blocs abstraits est souvent implment comme les #define du langage C. Chaque bloc qui
utilise un bloc abstrait est remplac par une copie de celui-ci o les paramtres sont substitus par leurs valeurs.
Le schematron prcdent est en fait quivalent au schematron suivant. Le bloc abstrait uniq a disparu mais ses
rgles apparaissent dupliques dans les deux blocs uniq-id et uniq-title.
154
Schematron
L'exemple ci-dessous illustre la puissance des schematrons. Ce schematron exprime certaines contraintes que
doivent satisfaire les schematrons pour tre valides. Ces contraintes portent sur les liens entre les lments
pattern abstraits et ceux qui les utilisent. Pour une meilleure efficacit, ce schmatron utilise un index cr par
l'lment XSLT xsl:key [Section 8.12].
<sch:pattern>
<sch:rule context="tns:pattern[@is-a]">
<sch:assert test="key('patid', @is-a)">
L'attribut is-a doit rfrencer un bloc abstrait.
</sch:assert>
<sch:report test="@abstract = 'true'">
Un bloc avec un attribut is-a ne peut pas tre abstrait.
</sch:report>
<sch:report test="rule">
Un bloc avec un attribut is-a ne peut pas contenir de rgle.
</sch:report>
</sch:rule>
</sch:pattern>
<sch:pattern>
<sch:rule context="tns:pattern[@abstract = 'true']">
<sch:assert test="@id">
Un bloc abstrait doit avoir un attribut id.
</sch:assert>
<sch:report test="@is-a">
Un bloc abstrait ne peut pas avoir un attribut is-a.
155
Schematron
</sch:report>
</sch:rule>
</sch:pattern>
</sch:schema>
Une phase est dclare par un lment sch:phase ayant un attribut id permettant de l'identifier. Chaque bloc
de cette phase est donn par un enfant sch:active ayant un attribut pattern qui prcise l'identifiant du bloc.
Dans l'exemple minimal ci-dessous, il y a deux phases appeles phase1 et phase2. Chacune de ces deux phases
contient un seul bloc.
156
Chapitre 8. XSLT
Le langage XSL (pour XML Stylesheet Language) a t conu pour transformer des documents XML en d'autres
formats comme PDF ou des pages HTML. Au cours de son dveloppement, le projet s'est avr plus complexe
que prvu et il a t scind en deux units distinctes XSLT et XSL-FO. Le langage XSLT (pour XML Stylesheet
Language Transformation) est un langage de transformation de documents XML. Le langage XSL-FO [Chapitre 9]
(pour XML Stylesheet Language - Formatting Objets) est un langage de mise en page de document. Le processus
de transformation d'un document XML en un document imprimable, au format PDF par exemple, est donc dcoup
en deux phases. Dans la premire phase, le document XML est transform en un document XSL-FO l'aide de
feuilles de style XSLT. Dans la seconde phase, le document FO obtenu la premire phase est converti par un
processeur FO en un document imprimable.
Mme si le langage XSLT puise son origine dans la transformation de documents XML en document XSL-FO,
il est adapt la transformation d'un document de n'importe quel dialecte XML dans un document de n'importe
quel autre dialecte XML. Il est souvent utilis pour produire des documents XSL-FO ou XHTML mais il peut
aussi produire des documents SVG [Chapitre 11]. Le langage XSLT est aussi souvent utilis pour raliser des
transformations simples sur des documents. Il s'agit, par exemple, de supprimer certains lments, de remplacer
un attribut par un lment ou de dplacer un lments.
Ce chapitre est consacr la partie XSLT de XSL. Comme l'ensemble de cet ouvrage, il est essentiellement
bas sur des exemples disponibles l'URL http://www.liafa.univ-paris-diderot.fr/~carton/
Enseignement/XML/
8.1. Principe
Le principe de fonctionnent de XSLT est le suivant. Une feuille de style XSLT contient des rgles qui dcrivent
des transformations. Ces rgles sont appliques un document source XML pour obtenir un nouveau document
XML rsultat. Cette transformation est ralise par un programme appel processeur XSLT. La feuille de style est
aussi appele programme dans la mesure o il s'agit des instructions excuter par le processeur.
157
XSLT
Fe u ille d e s t yle
st ylesheet .xsl
Do c u m e n t s o u rc e Do c u m e n t r s u lt a t
source.xm l result .xm l
XSLT
Pro c e s s o r
La version 2.0 de XSLT a introduit un certain nombre d'volutions par rapport la version 1.0. Une premire
volution importante est l'utilisation de XPath 2.0 [Chapitre 6] la place de XPath 1.0. Une seconde volution
importante est la possibilit de traiter un document valid au pralable par un schma XML [Chapitre 5].
L'intrt de cette validation est d'associer un type chaque contenu d'lment et chaque valeur d'attribut. Si le
type d'un attribut est, par exemple, xsd:integer et que sa valeur 123, celle-ci est interprte comme un entier
et non comme une chane de caractres la manire de XSLT 1.0. La validation par un schma n'est cependant
pas ncessaire pour utiliser XSLT 2.0 et profiter des volutions par rapport XSLT 1.0. Il existe donc deux faons
de traiter un document avec XSLT 2.0, soit sans schma soit avec schma. La premire faon correspond au
fonctionnement de XSLT 1.0. La seconde faon prend en compte les types associs aux nuds par la validation.
Pour la version 1.0 de XSLT, il existe plusieurs processeurs libres dont le plus rpandu est xsltproc. Il est
trs souvent dj install sur les machines car il fait partie de la librairie standard libxslt. En revanche, il
n'implmente que la version 1.0 de la norme avec quelques extensions. Le logiciel saxon implmente la XSLT
2.0 mais la version gratuite n'implmente que le traitement sans schma. Il n'existe pas actuellement de processeur
libre implmentant le traitement avec schma. Pour cette raison, ce chapitre se concentre sur le traitement sans
schma mme si l'essentiel reste encore valable dans le traitement avec schma.
Le langage XSLT est un dialecte XML. Ceci signifie qu'une feuille de style XSLT est un document XML qui
peut lui-mme tre manipul ou produit par d'autres feuilles de style. Cette possibilit est d'ailleurs exploit par
schematron [Chapitre 7] pour raliser une validation en plusieurs phases.
158
XSLT
La feuille de style est contenue dans l'lment racine xsl:stylesheet. Elle est constitue d'une seule rgle
introduite par l'lement xsl:template dont l'attribut match prcise que cette rgle s'applique la racine
du document source. L'lment xsl:template contient le document XHTML produit. En appliquant ce
programme n'importe quel document XML, on obtient le rsultat suivant qui est un document XHTML valide.
L'entte XML du rsultat t automatiquement mise par le processeur XSLT. Comme le codage [Section 2.2.4]
du document rsultat n'est pas spcifi par la feuille de style, c'est le codage UTF-8 par dfaut de XML qui a t
utilis. Le processeur a insr la dclaration de l'espace de noms XHTML dans l'lment racine html du document.
Le processeur a galement ajout l'lment meta propre HTML pour prciser le codage des caractres. Le
fonctionnement prcis de cette feuille de style est explicit aprs l'explication gnrale.
159
XSLT
Chaque fragment produit par l'application d'une rgle est une suite de nuds reprsentant des lments, des
attributs, des instructions de traitement et des commentaires. Il s'agit le plus souvent d'une suite d'lments ou
d'attributs. Lors de l'assemblage des fragments, ces nuds viennent s'insrer l'intrieur d'un autre fragment.
Chaque rgle est dclare par un lment xsl:template. Le contenu de cet lment est le fragment de
document qui est produit par l'application de cette rgle. Ce contenu contient des lments de l'espace de noms
XSLT et des lments d'autres espaces de noms. Ces derniers lments sont recopis l'identique pour former
le fragment. Les lments de XSLT sont des instructions qui sont excutes par le processeur XSLT. Ces
lments sont remplacs dans le fragment par le rsultat de leur excution. L'lment essentiel est l'lment
xsl:apply-templates qui permet d'invoquer l'application d'autres rgles. Les fragments de document
produits par ces applications de rgles remplacent l'lment xsl:apply-templates. L'emplacement de
l'lment xsl:apply-templates constitue donc le point d'ancrage pour l'insertion du ou des fragments
produits par son excution.
<xsl:template match="...">
<!-- Fragment produit -->
...
<!-- Application de rgles -->
<xsl:apply-templates .... />
...
<!-- Application de rgles -->
<xsl:apply-templates .... />
...
<xsl:template/>
Chacune des rgles est dclare avec un lment xsl:template dont l'attribut match prcise sur quels nuds
elle est susceptible d'tre applique. Le processus de transformation consiste appliquer des rgles sur des nuds
dits actifs du documents source. Au dpart, seule la racine est active et la premire rgle est donc applique
cette racine. L'application de chaque rgle produit un fragment de document qui va constituer une partie du
document rsultat. Elle active d'autres nuds avec des lments xsl:apply-templates placs au sein du
fragment de document. Des rgles sont alors appliques ces nouveaux nuds actifs. D'une part, elles produisent
des fragments de documents qui remplacent dans le document rsultat les lments xsl:apply-templates
qui les ont provoques. D'autre part, elles activent ventuellement d'autres nuds pour continuer le processus. Ce
dernier s'arrte lorsqu'il n'y a plus de nuds actifs.
Le processus de transformation s'apparente donc un parcours de l'arbre du document source. Il y a cependant une
diffrence importante. Dans un parcours classique d'un arbre comme les parcours en largeur ou en profondeur, le
traitement d'un nud entrane le traitement de ses enfants. L'application d'une rgle XSLT active d'autres nuds
mais ceux-ci ne sont pas ncessairement les enfants du nud sur lequel la rgle s'applique. Les nuds activs sont
dtermins par l'attribut select des lments xsl:apply-templates. Chaque attribut select contient
une expression XPath dont l'valuation donne la liste des nuds activs.
La figure ci-dessous illustre la construction de l'arbre rsultat par l'application des rgles XSLT. Chacun des
triangles marqus template reprsente un fragment de document produit par l'application d'une rgle. Tous ces
triangles sont identiques sur la figure mme si les fragments qu'ils reprsentent sont diffrents. Le triangle tout en
haut reprsente le fragment produit par la rgle applique au commencement la racine du document. Les flches
marques apply-templates symbolisent l'application de nouvelles rgles par l'activation de nuds. L'arbre
du document rsultat est, en quelque sorte, obtenu en contractant ces flches marques apply-templates et en
insrant leur point de dpart le triangle sur lequel elles pointent. Les flches partant d'un mme triangle peuvent
partir de points diffrents car un mme fragment de document peut contenir plusieurs lments xsl:apply-
templates.
160
XSLT
t em plat e
apply-t em plat es
Il est maintenant possible de revenir sur le premier programme Hello, Word! et d'en expliquer le
fonctionnement. Ce programme contient une seule rgle qui s'applique la racine du document source. Comme le
premier nud actif au dpart est justement la racine, le processus commence par appliquer cette rgle. Le document
rsultat est construit en ajoutant sa racine le contenu de la rgle. Comme ce contenu ne contient aucun lment
xsl:apply-templates, aucun nouveau nud n'est rendu actif et le processus de transformation s'arrte aprs
l'application de cette premire rgle.
8.4. Entte
Le programme ou feuille de style est entirement inclus dans un lment racine xsl:stylesheet ou de
faon compltement quivalente un lment xsl:transform. L'attribut version prcise la version de XSLT
utilise. Les valeurs possibles sont 1.0 ou 2.0. Un processeur XSLT 1.0 signale gnralement une erreur lorsque
la feuille de style n'utilise pas cette version. Un processeur XSLT 2.0 passe dans un mode de compatibilit avec
la version 1.0 lorsqu'il rencontre une feuille de style de XSLT 1.0. La feuille de style dclare plusieurs espaces
de noms [Chapitre 4]. L'espace de noms des lments de XSLT doit d'abord tre dclar. Il est identifi par l'URI
http://www.w3.org/1999/XSL/Transform. Le prfixe xsl est gnralement associ cet espace de
noms. Dans tout ce chapitre, ce prfixe est utilis pour qualifier les lments XSLT. Il faut ensuite dclarer les
ventuels espaces de noms du document source et du document rsultat. Ces dclarations d'espaces de noms sont
indispensables car le contenu de chaque rgle contient un mlange d'lments XSLT et d'lments du document
rsultat. Les espaces de noms permettent au processeur XSLT de les distinguer.
Les processeurs XSLT ajoutent les dclarations ncessaires d'espaces de noms dans le document rsultat. Il arrive
que certains espaces de noms soient dclars alors qu'ils ne sont pas ncessaires. L'attribut exclude-result-
prefixes de xsl:stylesheet permet d'indiquer que certains espaces de noms ne seront pas utiliss dans le
document rsultat et que leurs dclarations doivent tre omises. Cet attribut contient une liste de prfixes spars
par des espaces. Dans l'exemple suivant, les espaces de noms associs aux prfixes xsl (XSLT) et dbk (DocBook)
ne sont pas dclars dans le document rsultat.
161
XSLT
xmlns:dbk="http://docbook.org/ns/docbook"
xmlns="http://www.w3.org/1999/xhtml">
...
L'lment xsl:output doit tre un enfant de l'lment xsl:stylesheet. Il contrle le format du document
rsultat. Son attribut method qui peut prendre les valeurs xml, xhtml, html et text indique le type
de document rsultat produit. Ses attributs encoding, doctype-public, doctype-system prcisent
respectivement l'encodage du document, le FPI et l'URL de la DTD [Section 3.2.2]. L'attribut indent dont la
valeur est yes ou no prcise si le rsultat doit tre indent. L'indentation est seulement ncessaire si le document
doit tre lu par un il humain. Elle peut sensiblement augmenter la taille du document. Un exemple typique
d'utilisation de xsl:output pour produire un document XHTML est le suivant.
<xsl:stylesheet version="2.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns="http://www.w3.org/1999/xhtml">
<xsl:output method="xml"
encoding="iso-8859-1"
doctype-public="-//W3C//DTD XHTML 1.1//EN"
doctype-system="http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"
indent="yes"/>
Lorsque la feuille de style produit plusieurs documents rsultat, plusieurs autres lments xsl:output peuvent
apparatre dans la feuille de style. Ceux-ci doivent avoir un attribut name permettant de les identifier. Ces lments
servent contrler le format des documents crits par des lments xsl:result-document [Section 8.13.2].
La slection des nuds textuels supprimer est base sur une liste de noms d'lments du document source dont
les caractres d'espacement doivent tre prservs. Par dfaut, cette liste contient tous les noms d'lments et aucun
nud textuel contenant des caractres d'espacement n'est supprim. L'lment xsl:strip-space permet de
retirer des noms d'lments de cette liste et l'lment xsl:preserve-space permet d'en ajouter. Ce dernier
lment est rarement utilis puisque la liste contient, au dpart, tous les noms d'lments. L'attribut elements
des lments xsl:strip-space et xsl:preserve-space contient une liste de noms d'lments ( retirer
ou ajouter) spars par des espaces. Cet attribut peut galement contenir la valeur '*' ou des valeurs de la forme
tns:*. Dans ces cas, sont retirs (pour xsl:strip-space) ou ajouts (pour xsl:preserve-space) la
liste tous les noms d'lments ou tous les noms d'lments de l'espace de noms associ au prfixe tns.
Un nud textuel est retir de l'arbre du document si les deux conditions suivantes sont vrifies. Il faut d'abord
que le nom de son parent n'appartienne pas la liste des noms d'lments dont les espaces doivent tre prservs.
Ceci signifie que le nom de son parent a t retir de la liste grce un lment xsl:strip-space. Il faut
ensuite que la valeur de l'attribut xml:space donn au plus proche parent contenant cet attribut ne soit pas la
valeur preserve. La valeur par dfaut de cet attribut est default qui autorise la suppression.
La feuille de style suivante recopie le document source mais les nuds textuels contenant uniquement
des caractres d'espacement sont supprims du contenu des lments strip. Afin d'observer les effets de
xsl:strip-space, il est ncessaire que la valeur de l'attribut indent de l'lment xsl:output soit no
pour qu'aucun caractre d'espacement ne soit ajout pour l'indentation.
162
XSLT
Si la feuille de style prcdente est applique au document prcdent, certains espaces sont supprims. Aucun des
espaces contenus dans les lments p n'est supprim car ces lments ont un seul nud textuel comme enfant et
ce nud textuel contient des caractres autres que des espaces. En revanche, des retours la ligne entre les balises
<strip> et <p> ainsi que les espaces entre les balises </p> et <p> disparaissent car les nuds textuels qui les
contiennent ne contiennent que des caractres d'espacement.
163
XSLT
Les dfinitions de rgles sont globales. Tous les lments xsl:template sont enfants de l'lment racine
xsl:stylesheet et la porte des rgles est l'intgralit de la feuille de style. Au contraire, les lments
xsl:apply-templates et xsl:call-template ne peuvent apparatre que dans le contenu d'un lment
xsl:template.
Le fragment de programme suivant dfinit une rgle. La valeur de l'attribut match vaut '/' et indique donc que
la rgle s'applique uniquement la racine de l'arbre. La racine de l'arbre rsultat est alors le fragment XHTML
contenu dans xsl:template. Comme ce fragment ne contient pas d'autres directives XSLT, le traitement de
l'arbre source s'arrte et le document rsultat est rduit ce fragment.
<xsl:template match="/">
<html>
<head>
<title>Hello, World!</title>
</head>
<body>
<h1>Hello, world!</h1>
</body>
</html>
</xsl:template>
La rgle ci-dessous s'applique tous les lments de nom author, year ou publisher.
<xsl:template match="author|year|publisher">
...
</xsl:template>
164
XSLT
Lorsqu'une rgle est applique un nud du document source, ce nud devient le nud courant du focus
[Section 6.1.5.2]. Les expressions XPath sont alors values partir de ce nud qui est retourn par l'expression
'.'. Certains lments comme xsl:for-each [Section 8.7.3] ou les filtres [Section 6.4.2] peuvent localement
changer le focus et le nud courant. Le nud sur lequel est applique la rgle peut encore tre recupr par un
appel la fonction XPath current() [Section 6.1.7].
L'expression XPath de l'attribut select slectionne, en gnral, plusieurs nuds. Sur chacun de ces nuds,
est applique une seule rgle dpendant du nud. La rgle est choisie parmi les rgles o il y a concordance
entre le motif XPath de l'attribut match et le nud. Lors de l'application de la rgle choisie, chaque nud
slectionn devient le nud courant du focus [Section 6.1.5.2]. Pour appliquer plusieurs rgles un mme nud,
il faut plusieurs lments xsl:apply-templates. Il est, en particulier, possible d'avoir recours des modes
[Section 8.11] pour appliquer des rgles diffrentes.
La valeur par dfaut de l'attribut select est node() [Section 6.2.1.2] qui slectionne tous les enfants du nud
courant, y compris les nuds textuels, les commentaires et les instructions de traitement mais pas les attributs.
Pour slectionner uniquement les enfants qui sont des lments, il faut mettre la valeur '*'. Pour slectionner
tous les attributs du nud courant, il faut mettre la valeur @* qui est l'abrviation de attribute::*. Il est,
bien sr, possible de mettre toute expression XPath comme ancestor-or-self::p[@xml:lang][1]/
@xml:lang. Une partie importante de la programmation XSLT rside dans les choix judicieux des valeurs
des attributs select des lments xsl:apply-templates ainsi que des valeurs des attributs match des
lments xsl:template.
Dans la feuille de style suivante, la premire rgle qui s'applique la racine '/' cre la structure du document
XHTML. Les enfants li de l'lment ul sont crs par les applications de rgles sur les lments book
provoques par le premier lment xsl:apply-templates. Les contenus des lments li sont construits par
les applications de rgles sur les enfants des lments book provoques par le second lment xsl:apply-
templates.
Les nuds sur lesquels sont appliqus les rgles sont trs souvent des descendants et mme des enfants du nud
courant mais ils peuvent galement tre trs loigns dans le document. Dans l'exemple suivant, les lments sont
165
XSLT
retourns par la fonction XPath id() [Section 8.12]. Il faut remarquer que l'lment xsl:for-each change le
focus et que l'expression XPath '.' ne dsigne plus le nud courant sur lequel s'applique la rgle.
<xsl:template match="dbk:callout">
<xsl:text>\item[</xsl:text>
<!-- Parcours des lments rfrencs par l'attribut arearefs -->
<xsl:for-each select="id(@arearefs)">
<xsl:apply-templates select="."/>
</xsl:for-each>
<xsl:text>]</xsl:text>
<xsl:apply-templates/>
</xsl:template>
Les nuds slectionns par l'expression XPath de l'attribut select sont normalement traits dans l'ordre du
document [Section 6.1.2]. L'lment xsl:apply-templates peut, nanmoins, contenir un ou plusieurs
lments xsl:sort pour effectuer un tri [Section 8.8] des nuds slectionns.
8.5.3. Priorits
Lorsque plusieurs rgles peuvent s'appliquer un mme nud, le processeur XSLT choisit la plus approprie
parmi celles-ci. Le choix de la rgle est d'abord dict par les priorits d'import [Section 8.15] entre les feuilles de
style puis par les priorits entre les rgles.
Le choix de la rgle appliquer s'effectue en deux tapes. La premire tape consiste ne conserver que les
rgles de la feuille de style de priorit d'import maximale parmi les rgles applicables. Lorsqu'une feuille de style
est importe, elle a une priorit d'import infrieure la feuille de style ralisant l'import. L'ordre des imports a
galement une incidence sur les priorits d'import. Lorsque plusieurs feuilles de style sont importes par une mme
feuille de style, les feuilles importes en premier ont une priorit infrieure celles importes ensuite.
La seconde tape consiste choisir, parmi les rgles restantes, celle qui a la priorit maximale. C'est une erreur
s'il y en a plusieurs de priorit maximale. Le processeur XSLT peut signaler l'erreur ou continuer en choisissant
une des rgles. La priorit d'une rgle est un nombre dcimal. Elle peut est fixe par un attribut priority de
l'lment xsl:template. Sinon, elle prend une valeur par dfaut qui dpend de la forme du motif [Section 6.8]
contenu dans l'attribut match. Les priorits par dfaut prennent des valeurs entre -0.5 et 0.5. Lorsque le motif
est de la forme expr-1 | ... | expr-N, le processeur considre chacun des motifs expr-i de faon
indpendante. Il fait comme si la rgle tait rpte pour chacun de ces motifs. L'axe n'a aucune incidence sur la
priorit par dfaut. Celle-ci est dtermine par les rgles ci-dessous.
-0.5
pour les motifs trs gnraux de la forme *, @*, node(), text(), comment() ainsi que le motif /,
-0.25
pour les motifs de la forme *:name ou prefix:* comme *:p ou dbk:*,
0
pour les motifs de la forme name ou @name comme section ou @type,
0.5
pour tous les autres motifs comme chapter/section ou section[@type].
166
XSLT
L'lment xsl:next-match applique l'lment courant la rgle qui se trouvait juste avant la rgle en cours
d'application dans l'ordre des priorits croissantes. Cet lment est souvent utilis pour dfinir une rgle pour un
cas particulier tout en rutilisant la rgle pour le cas gnral. Dans l'exemple suivant, la rgle spcifique pour les
lments para avec un attribut role gal right a une priorit suprieure l'autre rgle. Celle-ci ajoute un
lment div avec un attribut style. Elle appelle la rgle gnrale pour la rgle pour les lments DocBook
para grce l'lment xsl:next-match.
L'lment xsl:apply-imports permet d'appliquer au nud courant une rgle provenant d'une feuille de style
importe [Section 8.15] par la feuille de style contenant la rgle en cours. La rgle applique est la rgle ayant une
priorit maximale parmi les rgles provenant des feuilles de style importes. Cet lment est souvent utilis pour
redfinir une rgle d'une feuille de style importe tout en utilisant la rgle redfinie. Dans l'exemple suivant, la
feuille de style general.xsl contient une rgle pour les lments DocBook para.
La feuille de style main.xsl importe la feuille de style general.xsl [Section 8.15]. Elle contient une nouvelle
rgle pour les lments DocBook para. Cette rgle a une priorit d'import suprieure et elle est donc applique en
priorit. Cette rgle fait appel la rgle contenue dans general.xsl grce l'lment xsl:apply-imports.
L'utilisation de xsl:call-template est courante pour factoriser des parties communes plusieurs rgles.
Lorsque des rgles partagent un mme fragment, il est appropri de placer ce fragment dans une nouvelle rgle
nomme puis de l'utiliser en invoquant, plusieurs reprises, cette rgle avec l'lment xsl:call-template.
Dans la feuille de style suivante, les diffrentes rgles pour traiter les lments title, url et les autres enfants
de l'lment book font appel la rgle comma pour ajouter une virgule si l'lment n'est pas le dernier enfant.
167
XSLT
Il est important que le focus soit prserv l'appel de cette rgle pour que le test position() != last()
fonctionne correctement.
<xsl:template match="book">
<!-- Une entre (item) de la liste par livre -->
<li><xsl:apply-templates select="*"/></li>
</xsl:template>
<xsl:template match="title">
<!-- Titre du livre en italique -->
<i><xsl:apply-templates/></i>
<xsl:call-template name="comma"/>
</xsl:template>
<xsl:template match="url">
<!-- URL du livre en police fixe -->
<tt><xsl:apply-templates/></tt>
<xsl:call-template name="comma"/>
</xsl:template>
<xsl:template match="*">
<xsl:apply-templates/>
<xsl:call-template name="comma"/>
</xsl:template>
<xsl:template name="comma">
<!-- Virgule si ce n'est pas le dernier -->
<xsl:if test="position() != last()">
<xsl:text>, </xsl:text>
</xsl:if>
</xsl:template>
</xsl:stylesheet>
Cette fonctionnalit est utilise dans le premier exemple Hello, Word! [Section 8.2]. L'unique lment
xsl:template contient le document XHTML produit par la feuille de style. Les espaces de noms jouent ici
un rle essentiel puisqu'ils permettent de distinguer les directives de traitement pour le processeur XSLT (c'est-
-dire les lments XSLT) des autres lments.
<xsl:template match="/">
168
XSLT
<html>
<head>
<title>Hello World!</title>
</head>
<body>
<h1>Hello world!</h1>
</body>
</html>
</xsl:template>
L'insertion d'un contenu fixe, comme dans l'exemple prcdent, est trs limit. Le rsultat attendu dpend
gnralement du document source. Dans la rgle ci-dessous, le contenu de l'lment h1 provient du document
source. Ce texte est extrait du document source grce l'lment xsl:value-of dcrit ci-dessous
[Section 8.6.5]. Il est le contenu textuel de l'lment racine text du document source.
<xsl:template match="/">
<html>
<head>
<title>Localized Hello World !</title>
</head>
<body>
<h1><xsl:value-of select="text"/></h1>
</body>
</html>
</xsl:template>
Si la feuille de style ainsi modifie est applique au document suivant, on obtient un document XHTML o le
contenu de l'lment h1 est maintenant Bonjour !.
Du contenu peut aussi tre construit par un lment xsl:apply-templates. Ce contenu est alors le rsultat
de l'application de rgles aux lments slectionns par l'attribut select de xsl:apply-templates. On
reprend le document bibliography.xml dj utilis au chapitre sur la syntaxe [Chapitre 2].
La feuille de style suivante transforme le document bibliography.xml en un document XHTML qui prsente
la bibliographie sous forme d'une liste avec une mise en forme minimaliste. Cette feuille de style fonctionne de
la manire suivante. La premire rgle est applique la racine du document source. Elle produit le squelette du
document XHTML avec en particulier un lment ul pour contenir la liste des livres. Le contenu de cet lment ul
est construit en appliquant une rgle chacun des lments book par l'intermdiaire d'un lment xsl:apply-
templates avec un attribut select de valeur bibliography/book. La seconde rgle de la feuille de style
est la rgle applique aux lments book. Pour chacun de ces lments, elle produit un lment li qui s'insre
dans le contenu de l'lment ul. Le contenu de l'lment li est, nouveau, produit en appliquant une rgle aux
enfants de l'lment book par l'intermdiaire d'un lment xsl:apply-templates dont l'attribut select
a la valeur par dfaut node(). C'est la dernire rgle qui s'applique chacun de ces lments. Cette rgle se
contente d'appliquer rcursivement une rgle leurs enfants. La rgle par dfaut [Section 8.6.2] pour les nuds
textuels recopie alors les contenus de ces nuds.
169
XSLT
</head>
<body>
<h1>Bibliographie</h1>
<ul><xsl:apply-templates select="bibliography/book"/></ul>
</body>
</html>
</xsl:template>
<!-- Rgle pour les lments book -->
<xsl:template match="book">
<!-- Une entre li de la liste par livre -->
<li><xsl:apply-templates/></li>
</xsl:template>
<!-- Rgle pour les autres lments -->
<xsl:template match="*">
<!-- Rcupration du texte par la rgle par dfaut -->
<xsl:apply-templates/>
</xsl:template>
</xsl:stylesheet>
Dans la feuille de style prcdente, deux rgles sont susceptibles de s'appliquer aux lments book. La premire
est la rgle dont la valeur de l'attribut match est book et la seconde est celle dont la valeur de l'attribut match
est '*'. Le processeur XSLT choisit la premire en raison des priorits [Section 8.5.3] attribues aux rgles en
fonction du motif contenu dans l'attribut match.
La prsentation de la bibliographie en XHTML obtenue avec la feuille de style prcdente est trs sommaire. Il
est possible de l'amliorer en mettant, par exemple, le titre en italique et l'URL en fonte fixe. Il suffit, pour cela,
d'ajouter deux rgles spcifiques pour les lments title et url. Les deux nouvelles rgles suivantes ont une
priorit suprieure la dernire rgle de la feuille de style. Elles sont donc respectivement appliques aux lments
title et url.
170
XSLT
Beaucoup de la programmation XSLT s'effectue en jouant sur les lments slectionns par les attributs match
des lments xsl:apply-templates. La feuille de style suivante prsente la bibliographie en XHTML sous
la forme de deux listes, une pour les livres en franais et une autre pour les livres en anglais. Le changement par
rapport la feuille de style prcdente se situe dans la rgle applique la racine. Celle-ci contient maintenant deux
lments xsl:apply-templates. Le premier active les livres en franais et le second les livres en anglais.
Pour produire des lments XSLT dans le document rsultat, la feuille de style dclare, d'une part, l'espace de noms
XSLT associ, comme d'habitude, au prfixe xsl et elle dclare, d'autre part, un autre espace de noms associ
un prfixe arbitraire tns. Les lments XSLT devant tre recopis dans le rsultat sont placs dans l'espace de
noms associ au prfixe tns. L'lment xsl:namespace-alias assure la conversion de cet autre espace de
noms en l'espace de noms XSLT dans le rsultat. L'exemple suivant est une feuille de style produisant une autre
feuille de style produisant, son tour, un document XHTML.
171
XSLT
La feuille de style suivante est la feuille de style minimale sans aucune dfinition de rgles. Elle est nanmoins
utile grce la prsence des rgles par dfaut.
En appliquant cette feuille de style minimale au document bibliography.xml, on obtient le rsultat suivant.
XML by Example
Benot Marchal
2000
Macmillan Computer Publishing
0-7897-2242-9
XSLT fondamental
Philippe Drix
172
XSLT
2002
Eyrolles
2-212-11082-0
Ce rsultat s'explique par la prsence de rgles par dfaut qui sont les suivantes.
La rgle par dfaut pour les attributs est de retourner leur valeur. Les valeurs des attributs n'apparaissent pas dans
le rsultat ci-dessus car cette rgle par dfaut pour les attributs n'est pas invoque. En effet, la valeur par dfaut de
l'attribut select de l'lment apply-templates est node(), qui est la forme abrge de child::node()
et qui ne slectionne pas les attributs.
<body background-color="{$color}">
...
<div style="height: {$height+10}; width: {$width+10}">
Cette syntaxe est dj plus concise que l'utilisation de l'lment xsl:attribute [Section 8.6.6] pour ajouter
un attribut et lui donner une valeur. Le premier exemple ci-dessus est quivalent l'exemple ci-dessous.
<body>
<xsl:attribute name="background-color" select="$color"/>
Les expressions XPath en attribut avec des structures de contrle XPath [Section 6.6] sont souvent beaucoup plus
concises que les constructions quivalentes en XSLT. L'expression XPath ci-dessous est, par exemple, plus courte
que l'quivalent avec les structures de contrle XSLT [Section 8.7].
173
XSLT
Pour insrer des accolades ouvrantes ou fermantes dans la valeur d'un attribut, il faut simplement doubler les
accolades et crire '{{' ou '}}'. Si la rgle XSLT suivante
<xsl:template match="*">
<braces id="{@id}" esc="{{@id}}" escid="{{{@id}}}"/>
</xsl:template>
est applique un lment <braces id="JB007"/>, on obtient l'lment suivant. La chane {@id}
est remplace par la valeur de l'attribut id. En revanche, la chane {{@id}} donne la valeur {@id} o
chaque accolade redouble donne une seule accolade. Finalement, la chane {{{@id}}} combine les deux
comportements.
Les expressions XPath en attribut apparaissent normalement dans les attributs des lments hors de l'espace de
noms XSLT. Elles peuvent galemement apparatre comme valeur de quelques attributs d'lments XSLT. C'est,
par exemple, le cas de l'attribut name des lments xsl:element et xsl:attribute [Section 8.6.6] et de
l'attribut href de xsl:result-document [Section 8.13.2]. Ce mcanisme permet d'insrer dans le document
rsultat des lments et/ou des attributs dont les noms sont calculs dynamiquement.
La prsentation de la bibliographie en XHTML peut tre amliore par l'ajout de virgules ',' entre le titre,
l'auteur, de chacun des livres. L'lment xsl:text est alors ncessaire pour insrer les virgules. Il faut, en
outre, grer l'absence de virgule la fin grce l'lment xsl:if [Section 8.7.1].
Pour que le test position() != last() fonctionne correctement, il faut que la rgle applique aux lments
book n'active pas les nuds textuels contenant des caractres d'espacements. Il faut, pour cela, remplacer la valeur
par dfaut de l'attribut select par la valeur '*' qui ne slectionne que les enfants qui sont des lments et pas
ceux de type text().
174
XSLT
L'lment xsl:value-of cre un nud textuel dont le contenu est calcul. L'attribut select doit contenir
une expression XPath qui est value pour donner une liste de valeurs. Chacune de ces valeurs est convertie en une
chane de caractres. Lorsqu'une valeur est un nud, la conversion retourne la valeur textuelle [Section 6.1.1.1]
de celui-ci. Le texte est alors obtenu en concatnant ces diffrentes chanes. Un espace ' ' est insr, par dfaut,
entre ces chanes. Le caractre insr peut tre chang en donnant une valeur l'attribut separator de l'lment
xsl:value-of.
La feuille se style suivante collecte des valeurs des enfants de l'lment racine list pour former le contenu d'un
lment values.
Le document suivant comporte un lment racine avec des enfants item contenant des valeurs 1, 2 et 3.
En appliquant la feuille de style prcdente au document prcdent, on obtient le document suivant o apparaissent
les trois valeurs 1, 2 et 3 spares par des virgules ','.
Le fonctionnement de xsl:value-of de XSLT 1.0 est diffrent et constitue une incompatibilit avec XSLT 2.0.
Avec XSLT 1.0, seule la premire valeur de la liste donne par l'valuation de l'expression de l'attribut select
est prise en compte. Les autres valeurs sont ignores. En appliquant la feuille de style prcdente au document
prcdent avec un processeur XSLT 1.0, on obtient le document suivant o seule la valeur 1 apparat.
<xsl:value-of select="."/>
<xsl:value-of select="generate-id()"/>
<xsl:value-of select="key('idchapter', @idref)/title"/>
<xsl:value-of select="ancestor-or-self::p[@xml:lang][1]/@xml:lang"/>
Dans l'exemple suivant, le nom de l'lment est obtenu en concatnant la chane fixe new- avec la valeur de la
variable XSLT var [Section 8.9].
175
XSLT
Les lments xsl:element et xsl:attribute sont particulirement utiles lorsque l'insertion de l'lment
ou de l'attribut est conditionnelle. Le fragment de feuille de style suivant construit un lment tr. Un attribut
bgcolor de valeur #ffffcc est ajout lorsque la position de l'lment courant [Section 6.1.5.2] est paire.
<tr>
<xsl:if test="position() mod 2 = 0">
<xsl:attribute name="bgcolor">#ffffcc</xsl:attribute>
</xsl:if>
...
</tr>
L'lment xsl:element peut avoir un attribut use-attribute-set pour ajouter les attributs dclars par
des groupes d'attributs.
Un groupe d'attributs est introduit par l'lment xsl:attribute-set dont l'attribut name prcise le nom.
Cet lment doit tre un enfant de l'lment racine xsl:stylesheet de la feuille de style. L'lment
xsl:attribute-set contient des dclarations d'attributs introduites par des lments xsl:attribute. Le
groupe d'attribut est ensuite utilis par l'intermdiaire de l'attribut use-attribute-sets. Cet attribut peut
apparatre dans les lments XSLT xsl:element [Section 8.6.6] et xsl:copy [Section 8.6.9] mais il peut
aussi apparatre dans d'autres lments hors de l'espace de noms XSLT [Chapitre 4]. Dans ce dernier cas, son nom
doit tre qualifi pour qu'il fasse partie de l'espace de noms XSLT. L'attribut use-attribute-sets contient
une liste de noms de groupes d'attributs spars par des espaces.
Un groupe d'attributs peut rutiliser d'autres groupes d'attributs. Il contient alors tous les attributs de ces groupes
en plus de ceux qu'il dclare explicitement. Les noms des groupes utiliss sont donns par un attribut use-
attribute-sets de l'lment xsl:attribute-set.
La feuille de style suivante permet la transformation d'un sous-ensemble, dlibrment trs rduit, de DocBook
en XHTML. Le sous-ensemble est constitu des lments book, title, chapter, sect1 et para. La feuille
de style dfinit trois groupes d'attributs de noms text, title et para. Le premier est prvu pour contenir des
attributs gnraux pour les lments XHTML contenant du texte. Il est utilis dans les dfinitions des deux autres
groupes title et para. Le groupe title est utilis pour ajouter des attributs aux lments h1 et h2 construits
par la feuille de style. Le groupe para est utilis pour ajouter des attributs aux lments p.
Il faut remarquer que de nom l'attribut use-attribute-sets n'est pas qualifi lorsque celui-ci apparat dans
un lment XSLT comme xsl:attribute-set alors qu'il est qualifi lorsque celui-ci apparat dans des
lments hors de l'espace de noms XSLT comme h1 et p.
176
XSLT
<xsl:attribute name="align">left</xsl:attribute>
</xsl:attribute-set>
<!-- Dfinition d'un groupe d'attribut para pour les paragraphes -->
<xsl:attribute-set name="para" use-attribute-sets="text"/>
<!-- Dfinition d'un groupe d'attribut title pour les titres -->
<xsl:attribute-set name="title" use-attribute-sets="text">
<xsl:attribute name="id" select="generate-id()"/>
</xsl:attribute-set>
<xsl:template match="/">
<xsl:comment>Generated by dbk2html.xsl</xsl:comment>
<html xmlns="http://www.w3.org/1999/xhtml">
<head><title><xsl:value-of select="dbk:book/dbk:title"/></title></head>
<body><xsl:apply-templates/></body>
</html>
</xsl:template>
<!-- lments non traits -->
<xsl:template match="dbk:title|dbk:subtitle"/>
<!-- Livre -->
<xsl:template match="dbk:book">
<xsl:apply-templates/>
</xsl:template>
<!-- Chapitres -->
<xsl:template match="dbk:chapter">
<h1 xsl:use-attribute-sets="title"><xsl:value-of select="dbk:title"/></h1>
<xsl:apply-templates/>
</xsl:template>
<!-- Sections de niveau 1 -->
<xsl:template match="dbk:sect1">
<h2 xsl:use-attribute-sets="title"><xsl:value-of select="dbk:title"/></h2>
<xsl:apply-templates/>
</xsl:template>
<!-- Paragraphes -->
<xsl:template match="dbk:para">
<p xsl:use-attribute-sets="para"><xsl:apply-templates/></p>
</xsl:template>
</xsl:stylesheet>
Un document produit par cette feuille de style contient de multiples occurrences des mmes attributs avec les
mmes valeurs. Il est prfrable d'utiliser CSS [Chapitre 10] qui permet de sparer le contenu de la prsentation
et de rduire, du mme coup, la taille du fichier XHTML.
Une feuille de style peut importer [Section 8.15] la feuille de style prcdente tout en redfinissant certains groupes
d'attributs pour en modifier le comportement.
177
XSLT
</xsl:stylesheet>
La prsence de commentaires dans un document gnr par une feuille de style est trs souvent superflue. Elle
peut cependant tre ncessaire pour inclure des rgles CSS [Chapitre 10] dans l'entte d'un document XHTML
comme dans l'exemple donn pour les paramtres globaux [Section 8.9.2.1].
Si la feuille de style prcdente est applique au document suivant, on obtient le document rsultat donn ci-
dessous.
178
XSLT
Les deux lments item contenant 12 et 41 ont t copis par le premier xsl:copy-of dont l'attribut select
vaut '.'. L'lment item contenant 23 a t copi par le second xsl:copy-of dont l'attribut select vaut
following-sibling::*[1] car il est le premier frre droit de celui contenant 12. Le document rsultat ci-
dessous n'aurait pas t le mme si l'lment xsl:sequence avait t remplac par un lment xsl:copy-
of. L'axe following-sibling fonctionne car les nuds proviennent du document source et ne sont pas des
copies.
Une liste cre par xsl:sequence peut tre trie par l'lment xsl:perform-sort [Section 8.8.1].
Les attributs, dans le cas o le nud courant est un lment, et le contenu ne sont pas copis par xsl:copy. Ils
doivent tre ajouts explicitement. Le contenu de l'lment xsl:copy dfinit le contenu de l'lment copi. C'est
ici qu'il faut, par exemple, mettre des lments xsl:copy-of et/ou xsl:apply-templates pour ajouter
des attributs et/ou du contenu.
La feuille de style suivante transforme le document bibliography.xml en remplaant chaque attribut lang
d'un lment book par un lment lang contenant la valeur de l'attribut lang. La feuille de style est constitue
de deux rgles. Une premire rgle s'applique aux lments book et une seconde tous les autres lments. Dans
les deux rgles, la copie de l'lment est ralise par un lment xsl:copy. La copie des attributs est ralise
par un lment xsl:copy-of qui slectionne explicitement les attributs. La copie des enfants est ralise par
un lment xsl:apply-templates pour un appel rcursif des rgles.
179
XSLT
</xsl:stylesheet>
L'lment xsl:copy peut avoir un attribut use-attribute-set pour ajouter les attributs dclars par des
groupes d'attributs [Section 8.6.6.1].
180
XSLT
8.6.11. Numrotation
Le rle de l'lment xsl:number est double. Sa premire fonction est de crer un entier ou une liste d'entiers
pour numroter un lment. La seconde fonction est de formater cet entier ou cette liste. La seconde fonction est
plutt adapte la numrotation. Pour formater un nombre de faon prcise, il est prfrable d'utiliser la fonction
XPath format-number() [Section 8.6.12].
8.6.11.1. Formats
La fonction de formatage est relativement simple. L'attribut format de xsl:number contient une chane forme
d'un prfixe, d'un indicateur de format et d'un suffixe. Le prfixe et le suffixe doivent tre forms de caractres non
alphanumriques. Ils sont recopis sans changement. L'indicateur de format est remplac par l'entier. Le tableau
suivant rcapitule les diffrents formats possibles. Le format par dfaut est 1.
Format Rsultat
1 1, 2, 3, , 9, 10, 11,
01 01, 02, 03, , 09, 10, 11,
a a, b, c, , z, aa, ab,
A A, B, C, , Z, AA, AB,
i i, ii, iii, iv, v, vi, vii, viii, ix, x, xi,
I I, II, III, IV, V, VI, VII, VIII, IX, X, XI,
Format Rsultat
w one, two, three, , nine, ten, eleven,
W ONE, TWO, THREE, , NINE, TEN, ELEVEN,
Ww One, Two, Three, , Nine, Ten, Eleven,
Si l'attribut value est absent, le numro est calcul grce aux valeurs des attributs level, count et from.
L'attribut level dtermine le mode de calcul alors que les attributs count et from dterminent les lments
pris en compte. Ces deux derniers attributs contiennent un motif XPath [Section 6.8] permettant de slectionner
des nuds.
L'attribut level peut prendre les valeurs single, multiple et any. Les modes de calcul single et any
fournissent un seul entier alors que le mode multiple fournit une liste d'entiers. Dans ce dernier cas, le format
peut contenir plusieurs indicateurs de formats spars par des caractres non alphanumriques comme 1.1.1
ou [A-1-i].
181
XSLT
2 2 .3 .2 21
Mo d e s in g le Mo d e m u lt ip le Mo d e a n y
La feuille de style suivante ajoute un numro aux lments section. Ce numro est calcul dans le mode
single.
On considre le document XML suivant qui reprsente le squelette d'un livre avec deux chapitres, deux sections
dans chaque chapitre et deux sous-sections dans chaque section. Les sections ainsi que les sous-sections sont
contenues dans des lments section.
En appliquant la feuille de style au document prcdent, on obtient le document XML suivant. Chaque lment
section contient en plus un numro calcul par xsl:number en mode single. Les sections sont numrotes
partir de 1 dans chaque chapitre et les sous-sections sont aussi numrotes partir de 1 dans chaque section.
182
XSLT
</chapter>
<chapter>
<section>1<section>1</section><section>2</section></section>
<section>2<section>1</section><section>2</section></section>
</chapter>
</book>
Dans le mode multiple, l'lment xsl:number fournit une liste d'entiers qui est calcule de la faon suivante.
Le nud de dpart est dtermin par l'attribut from qui contient un motif XPath. C'est l'anctre le plus proche
du nud courant qui satisfait le motif de l'attribut from. Par dfaut, le nud de dpart est la racine du document.
Ensuite, on considre chacun des anctres entre le nud de dpart et le nud courant qui satisfait l'attribut count,
avec le nud de dpart exclus et le nud courant inclus. Pour chacun de ces anctres, le nombre (plus une unit)
de frres gauches qui satisfont le motif de count fournit un des entiers de la suite.
Si l'lment xsl:number de la feuille de style prcdente est remplac par l'lment suivant, on obtient le
document ci-dessous. Comme le format est A.1.i, chaque section contient un numro global form d'un numro
de chapitre (A, B, ), d'un numro de section (1, 2, ) et d'un numro de sous-section (i, ii, ). Ces diffrents
numros sont spars par les points '.' qui sont repris du format.
Si un attribut from avec la valeur chapter est ajout l'lment xsl:number de la feuille de style prcdente,
on obtient le document ci-dessous. Les chapitres ne sont plus pris en compte dans la numrotation des sections
et des sous-sections.
<book>
<chapter>
<section>A<section>A.1</section><section>A.2</section></section>
<section>B<section>B.1</section><section>B.2</section></section>
</chapter>
<chapter>
<section>A<section>A.1</section><section>A.2</section></section>
<section>B<section>B.1</section><section>B.2</section></section>
</chapter>
</book>
Dans le mode any, le nud de dpart est gal au dernier nud avant le nud courant qui vrifie le motif donn par
l'attribut from. Par dfaut, le nud de dpart est la racine du document. Le numro est gal au nombre (augment
d'une unit pour commencer avec 1) de nuds entre le nud de dpart et le nud courant qui satisfont le motif
donn par l'attribut count.
Si l'lment xsl:number de la feuille de style prcdente est remplac par l'lment suivant, on obtient le
document ci-dessous. Chaque section contient son numro d'ordre dans tout le document car la valeur par dfaut
de from est la racine du document.
183
XSLT
L'lment xsl:number suivant utilise l'attribut from pour limiter la numrotation des lments section aux
contenus des lments chapter. En appliquant la feuille de style prcdente avec cet lment xsl:number,
on obtient le document ci-dessous. Chaque section contient son numro d'ordre dans le chapitre.
La fonction XPath format-number() [Section 6.1.7] permet de formater un nombre entier ou dcimal de faon
plus prcise. Le premier paramtre est le nombre formater et le second est une chane de caractres qui dcrit le
formatage effectuer. Cette fonction est inspire de la classe DecimalFormat de Java et elle s'apparente, par les
formats utiliss, la fonction printf du langage C. Un troisime paramtre optionnel rfrence ventuellement
un lment xsl:decimal-format pour changer la signification de certains caractres dans le format.
Lorsqu'aucun lment xsl:decimal-format n'est rfrenc, le format est une chane forme de caractres
'#', '0', '.', ',', '%' U+25, '' U+2030 et ';'. La signification de ces diffrents caractres est donne ci-
dessous. La chane passe en second paramtre peut aussi contenir d'autres caractres qui sont recopis inchangs
dans le rsultat.
'#'
position pour un chiffre
'0'
position pour un chiffre remplac ventuellement par 0
'.'
position du point dcimal
','
position du sparateur de groupe (milliers, millions, )
184
XSLT
';'
sparateur entre un format pour les nombres positifs et un format pour les nombres ngatifs.
La chane de caractres passe en second paramtre format-number() peut contenir deux formats spars
par un caractre ';' comme #000;-#00 par exemple. Le premier format #000 est alors utilis pour les nombres
positifs et le second format -#00 pour les nombres ngatifs. Dans ce cas, le second format doit explicitement
insrer le caractre '-' car c'est la valeur absolue du nombre qui est formate. En formatant les nombres 12 et
-12 avec ce format #000;-#00, on obtient respectivement 012 et -12. La table ci-dessous donne quelques
exemples de rsultats de la fonction format-number() avec des formats diffrents.
L'lment xsl:decimal-format permet de changer les caractres utiliss dans le format. Cet lment dclare
un objet qui dfinit l'interprtation des caractres dans le format utilis par format-number(). L'attribut name
donne le nom de l'objet qui est utilis comme troisime paramtre de la fonction format-number(). Outre
cet attribut, l'lment xsl:decimal-format possde plusieurs attributs permettant de spcifier les caractres
utiliss pour marquer les diffrentes parties du nombre (point dcimal, sparateur de groupe, etc ).
decimal-separator
caractre pour marquer le point dcimal ('.' par dfaut)
grouping-separator
caractre pour sparer les groupes (',' par dfaut)
digit
caractre pour la position d'un chiffre ('#' par dfaut)
zero-digit
caractre pour la position d'un chiffre remplac par '0' ('0' par dfaut)
pattern-separator
caractre pour sparer deux formats pour les nombres positifs et les nombres ngatifs (';' par dfaut)
percent
caractre pour formater les pourcentages ('%' par dfaut)
per-mille
caractre pour formater les millimes ('' par dfaut)
Les lments xsl:decimal-format doivent tre enfants de l'lment racine xsl:stylesheet de la feuille
de style et leur porte est globale. Ils peuvent tre rfrencs par la fonction format-number() dans n'importe
quelle expression XPath de la feuille de style.
185
XSLT
La condition du test est une expression XPath contenue dans l'attribut test de xsl:if. Cette expression est
value puis convertie en valeur boolenne [Section 6.3.1]. Si le rsultat est true, le contenu de l'lment xsl:if
est pris en compte et les nuds crs sont insrs dans le rsultat de la rgle. Sinon, le contenu de l'lment
xsl:if est ignor.
<xsl:if test="not(position()=last())">
<xsl:text>, </xsl:text>
</xsl:if>
Les conditions contenues dans les attributs test des lments xsl:when sont values puis converties en valeur
boolenne [Section 6.3.1]. Le contenu du premier lment xsl:when dont la condition donne la valeur true
est pris en compte et les nuds crs sont insrs dans le rsultat de la rgle. Les autres lments xsl:when et
un ventuel lment xsl:otherwise sont ignors. Si aucune condition ne donne la valeur true, le contenu
de l'lment xsl:otherwise, s'il existe, est pris en compte. Tous les lments xsl:when sont ignors. Si
aucune condition ne donne la valeur true et s'il n'y a pas d'lment xsl:otherwise, l'lment xsl:choose
tout entier est ignor.
Le fragment de feuille de style retourne le contenu de l'enfant title de nud courant si cet enfant existe ou
construit un titre avec un numro avec xsl:number [Section 8.6.11] sinon.
<xsl:choose>
<xsl:when test="title">
186
XSLT
<xsl:value-of select="title"/>
</xsl:when>
<xsl:otherwise>
<xsl:text>Section </xsl:text>
<xsl:number level="single" count="section"/>
</xsl:otherwise>
</xsl:choose>
L'attribut select dtermine les objets traits. L'expression XPath qu'il contient est value pour donner une liste
l d'objets qui est, ensuite, parcourue. Le contenu de l'lment xsl:for-each est excut pour chacun des objets
de la liste l. Le focus [Section 6.1.5.2] est modifi pendant l'excution de xsl:for-each. chaque itration,
l'objet courant est fix un des objets de la liste l. La taille du contexte est galement fixe la longueur de l et
la position dans le contexte est finalement fixe la position de l'objet courant dans la liste l.
La feuille de style suivante prsente la bibliographie bibliography.xml sous forme d'un tableau XHTML.
Le tableau est construit par l'unique rgle de la feuille de style. La premire ligne du tableau avec des lments
th est ajoute explicitement et les autres lignes avec des lments td sont ajoutes par un lment xsl:for-
each qui parcourt tous les lments book de bibliography.xml. Le rsultat de la fonction position()
est formate par l'lment xsl:number [Section 8.6.11] pour numroter les lignes du tableau.
187
XSLT
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Bibliographie en tableau</title>
</head>
<body>
<h1>Bibliographie en tableau</h1>
<table align="center" border="1" cellpadding="2" cellspacing="0">
<tr>
<th>Numro</th>
<th>Titre</th>
<th>Auteur</th>
<th>diteur</th>
<th>Anne</th>
</tr>
<tr>
<td>1</td>
<td>XML langage et appplications</td>
<td>Alain Michard</td>
<td>Eyrolles</td>
<td>2001</td>
</tr>
<!-- Fichier tronqu -->
...
</table>
</body>
</html>
La feuille de style prcdente utilise l'lment xsl:for-each pour itrer sur les diffrents livres contenus dans
le fichier bibliography.xml. Le mme rsultat peut tre obtenu sans utiliser xsl:for-each comme dans
la feuille de style ci-dessous. L'ide est d'employer judicieusement l'lment xsl:apply-templates qui itre
implicitement sur les nuds slectionns. La plupart des utilisations de xsl:for-each peuvent tre vites.
Elles sont souvent le signe d'une mauvaise programmation XSLT.
188
XSLT
<tr>
<xsl:if test="position() mod 2 = 0">
<xsl:attribute name="bgcolor">#ffffcc</xsl:attribute>
</xsl:if>
<td><xsl:number value="position()" format="1"/></td>
<xsl:apply-templates select="title, author, publisher, year"/>
</tr>
</xsl:template>
<xsl:template match="title | author | publisher | year">
<td><xsl:value-of select="."/></td>
</xsl:template>
</xsl:stylesheet>
La feuille de style suivante donne un premier exemple simple d'utilisation de l'lment xsl:for-each-
group. Elle prsente la bibliographie en XHTML en regroupant les livres par annes. Le regroupement est
ralis par l'lment xsl:for-each-group avec l'attribut group-by gal l'expression XPath year.
L'attribut select dtermine que les lments regrouper sont les lment book. Le traitement de chacun
des groupes est ralis par le contenu de l'lment xsl:for-each-group. La cl du groupe est d'abord
rcupre par la fonction XPath current-grouping-key() [Section 6.1.7] pour construire le titre contenu
dans l'lment XHTML h2. Les lments book de chaque groupe sont ensuite traits, l'un aprs l'autre, grce un
lment xsl:apply-templates. L'attribut select de cet lment utilise la fonction current-group()
[Section 6.1.7] qui retourne la liste des objets du groupe.
189
XSLT
</xsl:for-each-group>
</body>
</html>
</xsl:template>
<!-- Rgle pour les lments book -->
<xsl:template match="book">
<li><xsl:apply-templates select="*"/></li>
</xsl:template>
<!-- Rgle pour les lments title -->
<xsl:template match="title">
<i><xsl:apply-templates/></i>
<xsl:call-template name="separator"/>
</xsl:template>
<!-- Rgle pour les autres lments -->
<xsl:template match="*">
<xsl:apply-templates/>
<xsl:call-template name="separator"/>
</xsl:template>
<!-- Virgule aprs les lments -->
<xsl:template name="separator">
<xsl:if test="position() != last()">
<xsl:text>, </xsl:text>
</xsl:if>
</xsl:template>
</xsl:stylesheet>
<h2>Anne 2001</h2>
...
</body>
</html>
La feuille de style suivante donne un exemple plus avanc d'utilisation de l'lment xsl:for-each-group.
Celle-ci effectue une transformation d'un document XHTML en un document DocBook. Pour simplifier, on se
contente de sous-ensembles trs restreints de ces deux dialectes XML. On considre uniquement les lments
html, body, h1, h2 et p de XHTML et des lments book, chapter, sect1, title et para de DocBook.
Ces deux dialectes organisent un document de manires diffrentes. Dans un document XHTML, les chapitres
et les sections sont uniquement dlimits par les titres h1 et h2. Au contraire, dans un document DocBook, les
lments chapter et sect1 encapsulent les chapitres et les sections. Ces diffrences rendent plus difficile la
transformation de XHTML vers DocBook. Pour trouver le contenu d'un chapitre, il est ncessaire de regrouper tous
les lments placs entre deux lments h1 conscutifs. L'lment xsl:for-each-group permet justement
de raliser facilement cette opration.
190
XSLT
L'espace de noms par dfaut de la feuille de style est celui de DocBook. Les noms des lments XHTML doivent
ainsi tre qualifis par le prfixe html associ l'espace de noms de XHTML.
Le document suivant est le document XHTML sur lequel est appliqu la tranformation. Celui-ci reprsente le
squelette typique d'un document XHTML avec des titres de niveaux 1 et 2 et des paragraphes.
191
XSLT
<p>Paragraphe I.0.1</p>
<h2>Titre I.1</h2>
<p>Paragraphe I.1.1</p>
<p>Paragraphe I.1.2</p>
<h2>Titre I.2</h2>
<p>Paragraphe I.2.1</p>
<p>Paragraphe I.2.2</p>
<h1>titre II</h1>
<p>Paragraphe II.0.1</p>
<h2>Titre II.1</h2>
<p>Paragraphe II.1.1</p>
<p>Paragraphe II.1.2</p>
<h2>Titre II.2</h2>
<p>Paragraphe II.2.1</p>
<p>Paragraphe II.2.2</p>
</body>
</html>
Le document suivant est le document DocBook obtenu par transformation par la feuille de style prddente du
document XHTML prcdent. Les deux lments h1 du document XHTML donnent deux lments chapter
dans le document DocBook.
8.8. Tris
L'lment xsl:sort permet de trier des nuds avant de les traiter. L'lment xsl:sort doit tre le
premier enfant des lments xsl:apply-templates, xsl:for-each ou xsl:for-each-group. Le tri
192
XSLT
s'applique tous les nuds slectionns par l'attribut select de ces diffrents lments. Le tri est ralis juste
aprs la slection des nuds et avant leur traitement qui s'effectue dans l'ordre obtenu. Le fragment de feuille de
style suivant permet, par exemple, de trier les lments book par ordre lexicographique croissant d'auteur.
<xsl:apply-templates select="bibliography/book">
<xsl:sort select="author" order="ascending"/>
</xsl:apply-templates>
L'attribut select de xsl:sort dtermine la cl du tri. L'attribut data-type qui peut prendre les valeurs
number ou text spcifie comment les cls doivent tre interprtes. Il est possible d'avoir plusieurs cls de tri
en mettant plusieurs lments xsl:sort comme dans l'exemple suivant. Les lments book sont d'abord tris
par auteur puis par anne.
<xsl:apply-templates select="bibliography/book">
<xsl:sort select="author" order="ascending"/>
<xsl:sort select="year" order="descending"/>
</xsl:apply-templates>
Le tri ralis par xsl:sort est bas sur les valeurs retournes par l'expression XPath contenue dans l'attribut
select. Cette expression est souvent le nom d'un enfant ou d'un attribut mais elle peut aussi tre plus complexe.
La feuille de style suivante rordonne les enfants des lments book. L'expression contenue dans l'attribut
select de xsl:sort retourne un numro d'ordre en fonction du nom de l'lment. Ce numro est calcul avec
la fonction index-of() [Section 6.4.3] et une liste de noms dans l'ordre souhait. Cette solution donne une
expression concise. Elle a aussi l'avantage que l'ordre est donn par une liste qui peut tre fixe ou calcule. Cette
liste peut, par exemple, tre la liste des noms des enfants du premier lment book.
<!-- Liste des noms des enfants du premier lment book -->
<xsl:variable name="orderlist" as="xsd:string*"
select="/bibliography/book[1]/*/name()"/>
...
<xsl:template match="book">
<xsl:copy>
<!-- Copie des attributs -->
<xsl:copy-of select="@*"/>
<xsl:apply-templates>
<!-- Tri des enfants dans l'ordre donn par la liste fixe -->
<!-- Les noms absents de la liste sont placs la fin -->
<xsl:sort select="(index-of(('title', 'author', 'publisher',
'year', 'isbn'), name()),10)[1]"/>
<!-- Tri dans l'ordre des enfants du premier lment book -->
<!-- <xsl:sort select="index-of($orderlist, name())"/> -->
</xsl:apply-templates>
</xsl:copy>
</xsl:template>
</xsl:stylesheet>
193
XSLT
Le langage XSLT distingue les variables des paramtres. Les variables servent mmoriser des valeurs
intermdiaires alors que les paramtres servent transmettre des valeurs aux rgles. Les variables sont introduites
par l'lment xsl:variable et les paramtres par l'lment xsl:param. L'lment xsl:with-param
permet de donner une valeur un paramtre lors de l'appel une rgle.
8.9.1. Variables
La valeur affecte la variable est fixe au moment de sa dclaration par l'lment xsl:variable et elle ne
peut plus changer ensuite. Les variables ne sont donc pas vraiment variables. Il s'agit d'objets non mutables dans
la terminologie des langages de programmation. La porte de la variable est l'lment XSLT qui la contient. Les
variables dont la dclaration est enfant de l'lment xsl:stylesheet sont donc globales.
L'attribut name dtermine le nom de la variable. La valeur est donne soit par une expression XPath dans
l'attribut select soit directement dans le contenu de l'lment xsl:variable. Un attribut optionnel as
peut spcifier le type de la variable. Les types possibles sont les types XPath [Section 6.1.4]. Dans l'exemple
suivant, les deux variables squares et cubes sont dclares de type xsd:integer*. Chacune d'elles
contient donc une liste ventuellement vide d'entiers. La valeur de la variable square est donne par l'lment
xsl:sequence [Section 8.6.8] contenu dans l'lment xsl:variable. La valeur de la variable cubes est
donne par l'expression XPath de l'attribut select.
Une variable dclare peut apparatre dans une expression XPath en tant prcde du caractre '$' comme dans
l'exemple suivant.
<xsl:value-of select="$squares"/>
Une variable permet aussi de mmoriser un ou plusieurs nuds. Il est parfois ncessaire de mmoriser le nud
courant dans une variable afin de pouvoir y accder dans une expression XPath qui modifie le contexte dynamique
194
XSLT
[Section 6.1.5.2]. Le fragment de feuille de style suivant mmorise le nud courant dans la variable current.
Il l'utilise ensuite pour slectionner les lments publisher dont l'attribut id est gal l'attribut by du nud
courant.
XSLT 2.0 a introduit une fonction XPath current() [Section 6.1.7] qui retourne le nud en cours de traitement
par la rgle. Il n'est plus ncessaire de le mmoriser dans une variable. L'exemple prcdent pourrait tre rcrit
de la faon suivante.
L'expression XPath //publisher[@id = $current/@by] n'est pas trs efficace car elle ncessite un
parcours complet du document pour retrouver le bon lment publisher. Elle peut avantageusement tre
remplace par un appel la fonction key(). Il faut au pralable crer avec xsl:key [Section 8.12] un index des
lments publisher bas sur la valeur de leur attribut id. Cette approche est illustre dans l'exemple suivant.
Une variable peut aussi tre utilise, dans un souci d'efficacit, pour mmoriser un rsultat intermdiaire. Dans
l'exemple suivant, le nud retourn par la fonction key() est mmoris dans la variable result puis utilis
plusieurs reprises.
L'lment xsl:variable permet galement de dclarer des variables locales lors de la dfinition de fonctions
d'extension XPath [Section 8.10].
8.9.2. Paramtres
Il existe des paramtres XSLT qui s'apparentent aux paramtres des fonctions des langages classiques comme C
ou Java. Ils servent transmettent des valeurs la feuille de style et aux rgles. Les paramtres sont dclars par
l'lment xsl:param qui permet galement de donner une valeur par dfaut comme en C++. Cet lment peut
tre enfant de l'lment racine xsl:stylesheet ou des lments xsl:template. Dans le premier cas, le
paramtre est global et dans le second cas, il est local la rgle dclare par xsl:template.
Comme avec l'lment xsl:variable, l'attribut name de l'lment xsl:param dtermine le nom du
paramtre. La valeur par dfaut est optionnelle. Elle est donne soit par une expression XPath dans l'attribut
select soit directement dans le contenu de l'lment xsl:param. Un attribut optionnel as peut spcifier le
type du paramtre [Section 6.1.4]. Le fragment suivant dclare un paramtre bg-color avec une valeur par
dfaut gale la chane de caractres white.
Les apostrophes ''' sont ncessaires autour de la chane white car la valeur de l'attribut select est une
expression XPath. La mme dclaration peut galement prendre la forme suivante sans les apostrophes.
<xsl:param name="bg-color">white<xsl:param/>
195
XSLT
Les paramtres globaux sont dclars par un lment xsl:param enfant de l'lment xsl:stylesheet. Leur
valeur est fixe au moment de l'appel au processeur XSLT. Leur valeur reste constante pendant toute la dure
du traitemet et ils peuvent tre utiliss dans toute la feuille de style. La syntaxe pour donner une valeur un
paramtre global dpend du processeur XSLT. Les processeurs qui peuvent tre utiliss en ligne de commande ont
gnralement une option pour donner une valeur un paramtre. Le processeur xstlproc a, par exemple, des
options --param et --stringparam dont les valeurs sont des expressions XPath. La seconde option ajoute
implicitement les apostrophes ''' ncessaires autour des chanes de caractres.
La feuille de style suivante utilise un paramtre global bg-color pour la couleur de fond du document XHTML
rsultat. Sa valeur est utilise pour inclure une rgle CSS [Chapitre 10] dans un commentaire [Section 8.6.7] dans
l'entte du document.
<xsl:template match="/">
<xsl:comment>Generated by dbk2html.xsl</xsl:comment>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title><xsl:value-of select="dbk:book/dbk:title"/></title>
<style>
<xsl:comment>
body { background-color: <xsl:value-of select="$bg-color"/>; }
</xsl:comment>
</style>
</head>
<body><xsl:apply-templates/></body>
</html>
</xsl:template>
...
</xsl:stylesheet>
Pour changer la couleur de fond du document rsultat, il faut donner une autre valeur au paramtre bg-color
comme dans l'exemple suivant.
Dans l'exemple suivant, la premire rgle (pour la racine '/') applique la rgle l'lment text avec le paramtre
color gal blue. La valeur par dfaut de ce paramtre est black.
196
XSLT
Dans l'exemple prcdent, la valeur passe en paramtre est une chane de caractres mais elle peut aussi tre
un nud ou une liste de nuds. Dans l'exemple suivant, la rgle get-id retourne un attribut id. La valeur de
celui-ci est produite partir des attributs id et xml:id du nud pass en paramtre. Par dfaut, ce nud est
le nud courant.
Un paramtre d'une rgle peut avoir ou ne pas avoir de valeur par dfaut fournie lors de la dclaration de celui-ci
par xsl:param. Lorsque la rgle est appele implicitement ou explicitement sans donner de valeur au paramtre
avec xsl:with-param, c'est la valeur par dfaut qui est utilise si celle-ci existe et c'est une erreur sinon.
Les paramtres sans valeur par dfaut doivent ncessairement recevoir une valeur avec xsl:with-param. Le
processeur XSLT peut signaler l'erreur ou continuer le traitement.
L'lment xsl:param est galement utilis pour dclarer les paramtres des fonctions d'extension XPath
[Section 8.10]. La rgle get-id de la feuille de style prcdente aurait aussi pu tre remplace par une fonction
d'extension. Dans la feuille de style suivante, la fonction XPath get-id() calcule la valeur de l'attribut id
partir des attributs id et xml:id du nud pass en paramtre.
197
XSLT
8.9.3. Rcursivit
XPath 2.0 a ajout des fonctions qui facilitent le traitement des chanes de caractres. Avec XSLT 1.0 et
XPath 1.0, il est souvent ncessaire d'avoir recours des rgles rcursives pour certains traitements. Les deux
rgles quote.string et quote.string.char donnes ci-dessous insrent un caractre '\' avant chaque
caractre '\' ou '"' d'une chane.
<!-- Insertion de '\' avant chaque caractre '"' et '\' du contenu -->
<xsl:template match="text()">
<xsl:call-template name="quote.string">
<xsl:with-param name="string" select="."/>
</xsl:call-template>
</xsl:template>
<!-- Insertion de '\' avant chaque caractre '"' et '\' du paramtre string -->
<xsl:template name="quote.string">
<!-- Chane reue en paramtre -->
<xsl:param name="string"/>
<xsl:choose>
<xsl:when test="contains($string, '"')">
<xsl:call-template name="quote.string.char">
<xsl:with-param name="string" select="$string"/>
<xsl:with-param name="char" select="'"'"/>
</xsl:call-template>
</xsl:when>
<xsl:when test="contains($string, '\')">
<xsl:call-template name="quote.string.char">
<xsl:with-param name="string" select="$string"/>
<xsl:with-param name="char" select="'\'"/>
</xsl:call-template>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="$string"/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<!-- Fonction auxiliare pour quote.string -->
<xsl:template name="quote.string.char">
<!-- Chane reue en paramtre -->
<xsl:param name="string"/>
<!-- Caractre reu en paramtre -->
<xsl:param name="char"/>
<xsl:variable name="prefix">
198
XSLT
<xsl:call-template name="quote.string">
<xsl:with-param name="string" select="substring-before($string, $char)"/>
</xsl:call-template>
</xsl:variable>
<xsl:variable name="suffix">
<xsl:call-template name="quote.string">
<xsl:with-param name="string" select="substring-after($string, $char)"/>
</xsl:call-template>
</xsl:variable>
<xsl:value-of select="concat($prefix, '\', $char, $suffix)"/>
</xsl:template>
Ce traitement pourrait tre ralis de faon plus concise avec la fonction XPath 2.0 replace().
<!-- Insertion de '\' avant chaque caractre '"' et '\' du contenu -->
<xsl:template match="text()">
<xsl:value-of select="replace(., '(["\\])', '\\$1')">
</xsl:template>
Dans la feuille de tyle suivante, la rgle r1 pour les lments list transmet les quatres paramtres normal1,
normal2, tunnel1 et tunnel2. Les deux premiers sont des paramtres normaux alors que les deux derniers
sont des paramtres tunnel. La rgle r2 pour les lments sublist dclare uniquement les deux paramtres
normal1 et tunnel1. Bien qu'elle reoivent les quatre paramtres, elle peut uniquement utiliser les deux
paramtres normal1 et tunnel1 qu'elle dclare. Elle retransmet ensuite ces deux paramtres. La rgle r3
pour les lments item dclare les quatre paramtres normal1, normal2, tunnel1 et tunnel2 avec des
valeurs par dfaut. Les deux paramtres normal1 et tunnel1 n'utilisent pas cette valeur par dfaut car ils ont
t transmis par la rgle r2. Le paramtre tunnel2 ne l'utilise pas non plus car il roit directement la valeur
transmise par la rgle r1 car il est dclar comme paramtre tunnel. Finalement, le paramtre normal2 prend la
valeur par dfaut car il n'est pas tunnel et parce qu'il n'a pas t transmis.
199
XSLT
</xsl:copy>
</xsl:template>
<!-- Rgle r2 -->
<xsl:template match="sublist">
<xsl:param name="normal1" select="-1"/>
<!-- L'attribut tunnel="yes" est ncessaire -->
<!-- Sinon, il s'agit d'une variable diffrente -->
<xsl:param name="tunnel1" select="-1" tunnel="yes"/>
<xsl:copy>
<xsl:value-of select="$normal1, $tunnel1"/>
<xsl:apply-templates select="*">
<xsl:with-param name="normal1" select="$normal1"/>
<xsl:with-param name="tunnel1" select="$tunnel1" tunnel="yes"/>
</xsl:apply-templates>
</xsl:copy>
</xsl:template>
<!-- Rgle r3 -->
<xsl:template match="item">
<xsl:param name="normal1" select="'d'"/>
<xsl:param name="tunnel1" select="'d'" tunnel="yes"/>
<xsl:param name="normal2" select="'d'"/>
<xsl:param name="tunnel2" select="'d'" tunnel="yes"/>
<xsl:copy>
<xsl:value-of select="$normal1, $tunnel1, $normal2, $tunnel2"/>
</xsl:copy>
</xsl:template>
</xsl:stylesheet>
En appliquant la feuille de style prcdent au document suivant, obtient le document rsultat donn ensuite.
Dans le document rsultat, les deux valeurs 1 et 1 insres dans l'lment sublist par xsl:value-of sont
les valeurs transmises par les paramtres normal1 et tunnel1. Les valeurs 1, 1 et 2 insres dans l'lment
item sont les valeurs transmises par les paramtres normal1, tunnel1 et tunnel2. La valeur d est la valeur
par dfaut du paramtre normal2.
La dfinition d'une fonction XPath est introduite par l'lment xsl:function. Cet lment a des attributs
name et as qui donnent respectivement le nom et le type de retour de la fonction. Le nom de la fonction est un
nom qualifi avec un espace de noms [Chapitre 4]. Les paramtres de la fonction sont donns par des lments
xsl:param [Section 8.9.2] enfants de l'lment xsl:function. Chacun de ces lments a aussi des attributs
name et as qui donnent respectivement le nom et le type du paramtre. En revanche, l'lment xsl:param ne
peut pas donner une valeur par dfaut au paramtre avec un attribut select ou un contenu. Cette restriction est
justifie par le fait que les fonctions XPath sont toujours appeles avec un nombre de valeurs correspondant leur
arit (nombre de paramtres). Les types possibles pour le type de retour et les paramtres sont les types XPath
[Section 6.1.4]. La dfinition d'une fonction prend donc la forme gnrique suivante.
200
XSLT
La fonction url:protocol de l'exemple suivant extrait la partie protocole [Section 2.3.1] d'une URL. Elle a un
paramtre url qui reoit une chane de caractres. Elle retourne la chane de caractres situe avant le caractre
':' si l'URL commence par un protocole ou la chane vide sinon.
Une fois dfinie, la fonction url:protocol peut tre utilise comme n'importe quelle autre fonction
XPath. Si la valeur de l'attribut xml:base [Section 2.7.4.3] est la chane http://www.omega-one.org/
index.html, l'exemple suivant cre un nud textuel contenant la chane http.
<xsl:value-of select="url:protocol(@xml:base)"/>
La fonction url:protocol peut tre, son tour, utilise pour dfinir une nouvelle fonction url:address
qui extrait l'adresse internet d'une URL. Cette fonction utilise une variable locale protocol pour mmoriser le
rsultat de la fonction url:protocol.
Les fonctions dfinies par xsl:function peuvent bien sr tre rcursives. La fonction rcursive suivante
url:file extrait le nom du fichier d'un chemin d'accs. C'est la chane de caractres situe aprs la dernire
occurrence du caractre '/'.
Une fonction XPath est identifie par son nom qualifi et son arit (nombre de paramtres). Il est ainsi possible
d'avoir plusieurs fonctions de mme nom condition qu'elles soient d'arits diffrentes. Ceci permet de simuler des
paramtres avec des valeurs par dfaut en donnant plusieurs dfinitions d'une mme fonction avec des nombres de
201
XSLT
paramtres diffrents. Dans l'exemple suivant, la fonction fun:join-path est dfinie une premire fois avec
trois paramtres. La seconde dfinition avec seulement deux paramtres permet d'omettre le troisime paramtre
qui devient ainsi optionnel.
8.11. Modes
Les modes sont un mcanisme important des feuilles de style XSLT. Ils permettent de faire subir plusieurs
traitements diffrents un mme nud du document source. Sans les modes, c'est toujours la mme rgle qui est
applique un mme nud pour donner le mme rsultat. Il est possible d'utiliser des paramtres [Section 8.9.2]
pour changer le traitement effectuer mais cette mthode n'est pas trs pratique car elle oblige regrouper dans
une mme rgle plusieurs traitements diffrents. L'ide des modes est d'crire une rgle pour chaque traitement et
ensuite de prciser le traitement effectuer lorsqu'une rgle est applique.
L'exemple classique est la transformation d'un document fait de chapitres et de sections (comme un document
DocBook) en un document d'un autre format tel PDF ou HTML. La table des matire n'est pas crite dans le
document source. Elle est calcule partir de la liste des chapitres et des sections. Chaque chapitre doit ainsi tre
trait deux fois : une premire fois pour produire les pages qui le contiennent et une seconde fois pour en extraire
une partie de la table des matires. Les deux traitements sont trs diffrents. Le premiet traite tout le contenu du
chapitre alors que le second se contente de rcuprer le titre du chapitre et les titres de ses sections.
Ces diffrents traitements peuvent tre distingus par des modes. Chaque rgle de la feuille de style dclare pour
quels modes elle s'applique avec l'attribut mode de l'lment xsl:template. En parallle, chaque application
de rgles avec xsl:apply-templates spcifie un mode avec un attribut mode.
Chaque mode est identifi par un nom XML [Section 2.2.3]. Il existe en outre les valeurs particulires #default,
#all et #current qui peuvent apparatre dans les valeurs des attributs mode.
La valeur de l'attribut mode de l'lment xsl:template est soit la valeur #all soit une liste de modes, y
compris #default, spars par des espaces. La valeur #current n'a pas de sens dans ce contexte et ne peut
pas apparatre. La valeur par dfaut est bien sr #default.
202
XSLT
...
<!-- Rgle applicable avec tous les modes -->
<xsl:template match="..." mode="#all">
...
La valeur de l'attribut mode de l'lment xsl:apply-templates est soit #default soit #current soit
le nom d'un seul mode. La valeur #all n'a pas de sens dans ce contexte et ne peut pas apparatre. La valeur par
dfaut est, bien sr, #default. La valeur #current permet appliquer des rgles avec le mme mode que celui
de la rgle en cours. Elle est utile lorsqu'une rgle peut s'appliquer dans plusieurs modes.
Dans la feuille de style suivante, la rgle sur la racine '/' applique, deux reprises, des rgles sur les lments
sublist : une premire fois dans le mode par dfaut et une seconde fois dans le mode mode1. La mme rgle
est applique les deux fois puisque la rgle pour les lments sublist s'applique justement dans le mode par
dfaut et dans le mode mode1. son tour, cette rgle applique des rgles, deux reprises, sur les lments item
: une premire fois dans le mode en cours et une seconde fois dans le mode mode2. Cela donne au total quatre
applications de rgles sur les lments item : une dans le mode par dfaut, une dans le mode mode1 et deux
dans le mode mode2. Comme il existe uniquement des rgles pour les modes mode1 et mode2 pour les lments
item, il n'y a en dfinitive que trois applications de rgles sur ces lments : une dans le mode mode1 et deux
dans le mode mode2.
En appliquant la feuille de style prcdente au document suivant, on obtient le document donn ensuite.
203
XSLT
<list><sublist><item/></sublist></list>
Le document rsultat contient deux lments sublist crs par l'lment xsl:copy lors des deux applications
de la rgle dans le mode par dfaut et dans le mode mode1. Le premier lment sublist contient un lment
item2 cr par l'application de la rgle dans le mode mode2. Le second lment sublist contient des lments
item1 et item2 crs par l'application de rgles dans les modes mode1 et mode2.
L'exemple suivant illustre une utilisation classique des modes. Le document est trait une premire fois en mode
toc pour en extraire une table des matires et une seconde fois pour crer le corps du document proprement dit.
8.12. Indexation
La fonction id() [Section 6.1.1.2] permet de retrouver des nuds dans un document partir de leur attribut de
type ID [Section 3.7.2]. Elle prend en paramtre une liste de noms spars par des espaces. Elle retourne une liste
contenant les lments dont la valeur de l'attribut de type ID est un des noms passs en paramtre. Cette fonction
est typiquement utilise pour traiter des attributs de type IDREF ou IDREFS. Ces attributs servent rfrencer
des lments du document en donnant une (pour IDREF) ou plusieurs (pour IDREFS) valeurs d'attibuts de type
ID. La fonction id() permet justement de retrouver ces lments rfrencs.
L'exemple suivant illustre l'utilisation classique de la fonction id(). On suppose avoir un document contenant
une bibliographie o les diteurs ont t placs dans une section spare du document [Section 3.7.2]. Chaque
lment book contient un lment published ayant un attribut by de type IDREF pour identifier l'lment
publisher correspondant dans la liste des dideurs. La feuille de style suivante permet de revenir une
bibliographie o chaque lment book contient directement l'lment publisher correspondant. L'lment
retourn par la fonction id() est mmoris dans une variable [Section 8.9] pour l'utiliser plusieurs reprises.
204
XSLT
<bibliography>
<xsl:apply-templates select="bibliography/books/book"/>
</bibliography>
</xsl:template>
<!-- Rgles pour les livres -->
<xsl:template match="book">
<book>
<!-- Copie des attributs -->
<xsl:copy-of select="@*"/>
<!-- Copie des lments autres que published -->
<xsl:copy-of select="*[name() != 'published']"/>
<!-- Remplacement des lments published -->
<xsl:apply-templates select="published"/>
</book>
</xsl:template>
<!-- Rgle pour remplacer published par le publisher rfrenc -->
<xsl:template match="published">
<!-- Elment publisher rfrenc par l'lment published -->
<xsl:variable name="pubnode" select="id(@by)"/>
<publisher>
<!-- Recopie des attributs autres que id -->
<!-- L'attribut id ne doit pas tre recopi car sinon,
on peut obtenir plusieurs lments publisher avec
la mme valeur de cet attribut -->
<xsl:copy-of select="$pubnode/@*[name() != 'id']"/>
<xsl:copy-of select="$pubnode/* | $pubnode/text()"/>
</publisher>
</xsl:template>
</xsl:stylesheet>
Lorsque la fonction id() retourne plusieurs nuds, il est possible de les traiter un par un en utilisant un lment
xsl:for-each comme dans l'exemple suivant.
<xsl:for-each select="id(@arearefs)">
<xsl:apply-templates select="."/>
</xsl:for-each>
Afin de pouvoir accder efficacement des nuds d'un document XML, il est possible de crer des
index. L'lment xsl:key cre un index. L'lment xsl:key doit tre un enfant de l'lment racine
xsl:stylesheet. L'attribut name de xsl:key fixe le nom de l'index pour son utilisation. L'attribut match
contient un motif [Section 6.8] qui dtermine les nuds indexs. L'attribut use contient une expression XPath qui
spcifie la cl d'indexation, c'est--dire la valeur qui identifie les nuds et permet de les retrouver. Pour chaque
nud slectionn par le motif, cette expression est value en prenant le nud slectionn comme nud courant.
Pour indexer des lments en fonction de la valeur de leur attribut type, on utilise l'expression @type comme
valeur de l'attribut use. La valeur de l'attribut use peut tre une expression plus complexe qui slectionne des
enfants et des attributs. Dans l'exemple suivant, tous les lments chapter du document sont indxs en fonction
de leur attribut id.
La fonction key() de XPath permet de retrouver un nud en utilisant un index cr par xsl:key. Le premier
paramtre est le nom de l'index et le second est la valeur de la cl. Dans l'exemple suivant, on utilise l'index cr
l'exemple prcdent. La valeur de l'attribut @idref d'un lment contenu dans la variable $node sert pour
retrouver l'lment dont c'est la valeur de l'attribut id. Le nom idchapter de l'index est un nom XML et il doit
tre plac entre apostrophes ou guillemets.
205
XSLT
L'utilisation d'un index peut tre contourne par des expressions XPath appropries. L'expression ci-dessus avec
la fonction key est quivalente l'expression XPath ci-dessous qui utilise l'oprateur '//' [Section 6.7].
L'inconvnient de cette dernire expression est de provoquer un parcours complet du document chaque
valuation. Si l'expression est value de nombreuses reprises, ceci peut conduire des problmes d'efficacit.
Lors de la prsentation des attributs de type ID et IDREF [Section 3.7.2], il a t observ que la bibliographie
bibliography.xml doit tre organise de faon diffrente si les lments publisher contiennent des
informations autres que le nom de l'diteur. Afin d'viter de dupliquer ces informations dans chaque livre, il
est prfrable de regrouper les lments publisher dans une section part. Chaque lment publisher
contenu dans un lment book est alors remplac par un lment published avec un attribut by de type IDREF
pour rfrencer l'lment publisher dplac. La feuille de style suivante remplace les lments publisher
par des lments published et les regroupe dans une liste en fin de document. Elle suppose que chaque
lment publisher contient, au moins, un enfant name avec le nom de l'diteur. Elle supprime galement les
doublons en vitant que deux lments publisher avec le mme nom, c'est--dire le mme contenu de l'lment
name, apparaissent dans la liste. Cette suppression des doublons est ralise par une indexation des lments
publisher sur le contenu de name. Pour chaque lment publisher, l'indexation permet de retrouver
efficacement tous les lments publisher avec un contenu identique de name. Seul le premier de ces lments
publisher est ajout la liste des diteurs dans le document rsultat.
Pour savoir si un lment publisher est le premier de ces lments avec le mme nom, celui-ci est compar
avec le premier de la liste retourne par la fonction key() avec l'oprateur is [Section 6.5.3]. La copie de cet
lment publisher est ralise par un lment xsl:copy [Section 8.6.9] ainsi que par lement xsl:copy-
of [Section 8.6.10] pour ses attributs et ses enfants.
206
XSLT
La faon la plus simple d'utiliser la fonction document() est de lui passer en paramtre l'URI d'un document
XML. La fonction retourne alors le nud racine du document. Ceci signifie que le document a t lu et transform
en arbre. Le rsultat peut tre mmoris dans une variable [Section 8.9] ou tre utilis directement. Si l'URI est
relative, elle est rsolue partir de l'URI de base [Section 2.7.4.3] d'un second paramtre optionnel qui doit tre
un nud d'un document. Le document suivant files.xml rfrence deux autres documents europa.xml et
states.xml par l'intermdiaire des attributs href des lments file.
Les deux documents europa.xml et states.xml rfrencs par le document files.xml sont les suivants.
La feuille de style suivante collecte toutes les villes des documents europa.xml et states.xml pour en faire
une liste unique. Pour chaque lment file de files.xml, l'appel document(@href) retourne le document
rfrenc par l'attribut href.
207
XSLT
<xsl:apply-templates select="document(@href)/cities/city">
<!-- Tri des villes par leur nom -->
<xsl:sort select="."/>
</xsl:apply-templates>
</xsl:for-each>
</list>
</xsl:template>
<xsl:template match="city">
<item><xsl:value-of select="."/></item>
</xsl:template>
</xsl:stylesheet>
L'application de la feuille de style prcdente au document files.xml donne le document ci-dessous. L'lment
xsl:sort [Section 8.8], enfant de l'lment xsl:apply-templates, trie les villes l'intrieur de chacun
des documents europa.xml et states.xml. En revanche, les villes ne sont pas tries globalement.
Le premier paramtre de la fonction document() peut galement tre une liste de nuds. Pour chaque
nud de cette liste, la fonction document() est appele avec comme premier paramtre la valeur textuelle
[Section 6.1.1.1] du nud interprte comme un URI. Le second paramtre ventuel est galement transmis.
Chacun de ces appels retourne le nud racine d'un document. Le rsultat global de la fonction document() est
la liste des nuds retourns par ces diffrents appels. La feuille de style suivante collecte galement toutes les
villes des documents europa.xml et states.xml pour en faire une liste unique. Le paramtre de la fonction
document() est la liste des attributs href des lments file dans le document files.xml.
L'application de la feuille de style prcdente au document files.xml donne le document ci-dessous. L'lment
xsl:sort [Section 8.8], enfant de l'lment xsl:apply-templates, trie les villes globalement.
208
XSLT
La fonction doc() de XPath 2.0 a un rle similaire la fonction document(). La fonction collection()
retourne galement une liste de nuds provenant de documents externes. Le fonctionnement de cette fonction est
propre chaque processeur XSLT.
La feuille de style prcdente peut tre applique au document suivant qui contient des lments file avec un
attribut href encapsuls dans un lment files.
En appliquant le feuille de style prcdente au document ci-dessus, obtient les deux documents multi-
out1.xml et multi-out2.xml donns ci-dessous.
209
XSLT
La chane analyser et l'expression rationnelle sont respectivement donnes par les attributs select et
regex de l'lment xsl:analyze-string. Les deux enfants xsl:matching-substring et xsl:non-
matching-substring de xsl:analyze-string donnent le rsultat suivant que la chane est compatible
ou non avec l'expression.
Dans l'exemple suivant, le contenu de l'lment name est dcoup la virgule pour extraire le prnom et le nom
de famille d'un nom complet crit suivant la convention anglaise. Les deux parties du nom sont ensuite utilises
pour construire les enfants firstname et lastname de name. Lorsque le contenu ne contient pas de virgule,
l'lment name est laiss inchang.
<xsl:template match="name">
<xsl:analyze-string select="." regex="([^,]*),\s*(.*)">
<xsl:matching-substring>
<name>
<firstname><xsl:value-of select="regex-group(2)"/></firstname>
<lastname><xsl:value-of select="regex-group(1)"/></lastname>
</name>
</xsl:matching-substring>
<xsl:non-matching-substring>
<name><xsl:value-of select="."/></name>
</xsl:non-matching-substring>
</xsl:analyze-string>
</xsl:template>
210
XSLT
deux lments ont un attribut href contenant l'URL [Section 2.3] de la feuille de style inclure. Cette URL
est trs souvent le nom relatif ou absolu d'un fichier local. Les deux lments xsl:include et xsl:import
doivent tre enfants de l'lment racine xsl:stylesheet et ils doivent tre placs avant toute dfinition de
rgle par un lment xsl:template. L'exemple suivant est la feuille de style principale pour la transformation
de cet ouvrage au format DocBook en HTML.
Lorsque un processeur XSLT choisit une rgle appliquer un nud du document source, il prend en compte deux
paramtres qui sont la priorit d'import entre les feuilles de style et les priorits entre les rgles. Lorsque la feuille
de style est importe avec l'lment xsl:include, les deux feuilles de style ont mme priorit d'import comme
si les rgles des deux feuilles se trouvaient dans une mme feuille de style. Au contraire, lorsque la feuille de style
est importe avec l'lment xsl:import, la feuille de style importe a une priorit d'import infrieure. Les rgles
de la feuille de style qui ralise l'import, c'est--dire celle qui contient l'lment xsl:import, sont appliques
en priorit sur les rgles de la feuille importe. Ce mcanisme permet d'adapter la feuille de style importe en
ajoutant des rgles dans la feuille de style qui importe. Lorsqu'une rgle ajoute remplace une rgles de la feuille
importe, elle peut encore utiliser la rgle remplace grce l'lment xsl:apply-imports [Section 8.5.4].
Une feuille de style peut importer plusieurs feuilles de style avec plusieurs lments xsl:import. Dans ce cas,
les feuilles de style importes en premier ont une priorit d'import infrieure. L'ordre des priorits d'import est
l'ordre des lments xsl:import dans la feuille de style qui importe. Il est galement possible qu'une feuille
de style importe par un lment xsl:import ralise elle-mme des imports d'autres feuilles de style avec des
lments xsl:import. Lorsqu'il y a plusieurs niveaux d'import, l'ordre d'import entre les diffrentes feuilles
de style est d'abord dict par l'ordre des imports de premier niveau puis l'ordre des imports de second niveau et
ainsi de suite. Ce principe est illustr par l'exemple suivant. Supposons qu'une feuille de style A importe, dans cet
ordre, les feuilles de style B et C, que la feuille B importe, son tour, les feuilles D et E et que la feuille C importe,
finalement, les feuilles F et G (cf. Figure). L'ordre des feuilles par priorit d'import croissante est D, E, B, F, G,
C, A. Cet ordre correspond un parcours suffixe de l'arbre des imports.
A
im p o rt s
B C
D E F G
211
Chapitre 9. XSL-FO
XSL-FO est un dialecte de XML permettant de dcrire le rendu de documents. Un document XSF-FO contient le
contenu mme du document ainsi que toutes les indications de rendu. Il s'apparente donc un mlange de HTML
et CSS [Chapitre 10] avec une syntaxe XML mais il est plus destin l'impression qu'au rendu sur cran. Le
langage XSL-FO est trs verbeux et donc peu adapt l'criture directe de documents. Il est plutt conu pour des
documents produits par des feuilles de style XSLT [Chapitre 8].
Le document prcdent peut tre trait par un programme comme fop pour produire un document
helloworld.pdf ou helloworld.png.
212
Chapitre 10. CSS
10.1. Principe
Le principe des feuilles de style CSS est de sparer le contenu de la forme. Elles sont beaucoup utilises avec
HTML et XHTML mais elles peuvent aussi l'tre avec XML (cf. exemple avec la bibliographie).
Les rles des XSLT et CSS sont diffrents et mme complmentaires. Le rle de XSLT est de transformer le
document source en un autre document rsultat, XHTML par exemple. Il s'agit donc d'agir sur le contenu et en
particulier sur la structure de ce contenu. Au contraire, CSS ne permet pas (ou trs peu) de changer le contenu.
Il peut uniquement intervenir sur la prsentation. Une bonne solution est d'utiliser XSLT et CSS de pair. XSLT
produit un document XHTML dont la prsentation est contrle par une feuille de style CSS.
10.2. Rgles
Une feuille de style est forme de rgles qui ont la forme suivante. Les espaces et les retours la ligne jouent
uniquement un rle de sparateurs. L'indentation de la feuille de style est donc libre.
selector {
property1: value1;
property2: value2;
...
propertyN: valueN;
}
Le slecteur selector dtermine quels sont les lments auxquels s'applique la rgle. Les proprits
property1, property2, , propertyN de tous ces lments prendront les valeurs respectives value1,
value2, , valueN. Chaque valeur est spare du nom de la proprit par le caractre ':'. Le caractre ';'
spare les couples proprit/valeur de la rgle. Il n'est donc pas indispensable aprs le dernier couple de la rgle.
Des commentaires peuvent tre mis dans les feuilles de styles en dehors ou dans les rgles en utilisant une syntaxe
identique celle du langage C. Ils commencent par les deux caractres '/*' et se terminent par les deux caractres
'*/'.
L'exemple ci-dessous est la feuille de style utilise pour la prsentation de cet ouvrage au format HTML.
/* Fond blanc */
body {
background-color: white;
}
213
CSS
10.2.1. Mdia
Les rgles d'une feuille de style peuvent dpendre du mdia utilis pour rendre le document. Par mdia, on entend
le support physique servant matrialiser le document. Il peut s'agir d'un cran d'ordinateur, d'un projecteur, de
papier. La syntaxe est la suivante.
@media medium {
/* Rgles pour le mdia */
...
}
Les principales valeurs possibles pour medium sont screen pour un cran d'ordinateur, print pour du papier
et projection pour un projecteur.
10.2.2. Slecteurs
Un slecteur prend la forme gnrale suivante. Il est constitu par une suite de slecteurs spars par des virgules.
Il slectionne alors tous les lments slectionns par chacun des slecteurs individuels.
La forme la plus simple d'un slecteur est le nom name d'un lment comme h1, p ou encore pre. Tous les
lments de nom name sont alors slectionns. Dans l'exemple suivant, le fond de l'lment body, c'est--dire
de tout le document, est blanc.
body {
background-color: white;
}
Tous les lments dont l'attribut class contient la chane classname peuvent tre slectionns par le slecteur
.classname o la valeur de l'attribut est prcde d'un point '.'.
L'attribut class d'un lment peut contenir plusieurs chanes spares par des espaces comme dans l'exemple
suivant. Un slecteur de forme .classname slectionne un lment si la chane classname est une des chanes
de la valeur de l'attribut class.
Cette forme de slecteur peut tre combine avec le nom name d'un lment pour former un slecteur
name.classname qui slectionne tous les lments de nom name dont l'attribut class contient la chane
classname. Dans l'exemple suivant, tous les lments p de classe equation ou figure auront leur texte
centr.
p.equation, p.figure {
text-align: center;
}
L'lment unique dont l'attribut id a la valeur name peut tre slectionn par le slecteur #name o la valeur
de l'attribut est prcde d'un dise '#'. Dans l'exemple suivant, le contenu de l'lment h1 dont l'attribut id
vaut title sera de couleur rouge.
Le slecteur '*' slectionne tous les lments. Dans l'exemple suivant, tous les lments (c'est--dire le texte)
seront de couleur bleue l'exception des lments p qui seront de couleur grise.
* { color: blue }
214
CSS
p { color: gray }
Certaines parties d'un document qui ne correspondent pas un lment peuvent tre slectionnes par des pseudo-
lments. La premire ligne et le premier caractre du contenu d'un lment name peuvent tre dsigns par
name:first-line et name:first-letter.
p:first-line {
text-indent: 15pt;
}
Le pseudo-lment :first-child permet en outre de slectionner le premier enfant d'un lment. Dans
l'exemple suivant, la rgle s'applique uniquement la premire entre d'une liste.
li:first-child {
color: blue;
}
Les pseudo-lments :before et :after et la proprit content permettent d'ajouter du contenu avant et
aprs un lment.
li:before {
content: "[" counter(c) "]";
counter-increment: c;
}
Un slecteur peut aussi prendre en compte la prsence d'attributs et leurs valeurs. Un ou plusieurs prdicats portant
sur les attributs sont ajouts un slecteur lmentaire. Chacun des prdicats est ajout aprs le slecteur entre
crochet '[' et ']'. Les diffrents prdicats possibles sont les suivants.
[att]
L'lment est slectionn s'il a un attribut att quelque soit sa valeur.
[att=value]
L'lment est slectionn s'il a un attribut att dont la valeur est exactement la chane value.
[att~=value]
L'lment est slectionn s'il a un attribut att dont la valeur est une suite de chanes spares par des
espaces dont l'une est exactement la chane value. Le slecteur .classname est donc une abrviation de
[class~="classname"].
[att|=value]
L'lment est slectionn s'il a un attribut att dont la valeur est une suite de chanes de caractres spares
par des tirets '-' dont la premire chane est gale la chane value.
Dans l'exemple suivant, la rgle s'applique aux lments p dont l'attribut lang commence par en- comme en-
GB ou en-US mais pas fr. La proprit quote dfinit quels caractres doivent entourer les citations.
215
CSS
p[lang|="en"] {
quotes: '"' '"' "'" "'";
}
Il est possible de mettre plusieurs prdicats portant sur les attributs comme dans l'exemple suivant. Le slecteur
suivant slectionne les lments p ayant un attribut lang de valeur fr et un attribut type de valeur center.
p[lang="fr"][type="center"] {
...
}
Il est possible de composer des slecteurs avec les trois oprateurs ' ' (espace), '>' et '+' pour former des
nouveaux slecteurs.
Le slecteur selector1 selector2 slectionne tous les lments slectionns par selector2 qui sont en
outre descendants dans l'arbre du document (c'est--dire inclus) d'un lment slectionn par selector1. Dans
l'exemple suivant, seuls les lments em contenus directement ou non dans un lment p auront leur texte en gras.
p em {
font-weight: bold;
}
Cet oprateur peut aussi combiner plusieurs slecteurs. Dans l'exemple suivant, sont slectionns les lments de
classe sc contenus dans un lment em lui mme contenu dans un lment p. Il y a bien un espace entre em et
.sc. Le slecteur p em.sc est bien sr diffrent.
p em .sc {
font-variant: small-caps;
}
Le slecteur selector1 > selector2 slectionne tous les lments slectionns par selector2 qui sont
en outre enfant (c'est--dire directement inclus) d'un lment slectionn par selector1.
Le slecteur selector1 + selector2 slectionne tous les lments slectionns par selector2 qui sont
en outre frre droit (c'est--dire qui suivent directement) d'un lment slectionn par selector1.
10.2.3. Proprits
Les proprits qui peuvent tre modifies par une rgle dpendent des lments slectionns. Pour chaque lment
de XHTML, il y a une liste des proprits qui peuvent tre modifies.
10.2.4. Valeurs
Les valeurs possibles dpendent de la proprit. Certaines proprits acceptent comme display uniquement un
nombre dtermin de valeurs. D'autres encore prennent une couleur, un entier, un pourcentage, un nombre dcimal
ou une dimension avec une unit.
Pour les dimensions, il est ncessaire de faire suivre le nombre d'une unit parmi les units suivantes.
Symbole Unit
px pixel
pt point = 1/72 in
pc pica = 12 pt
em largeur du M dans la police
ex hauteur du x dans la police
216
CSS
Symbole Unit
in pouce
mm millimtre
cm centimtre
Comme la proprit color est hrite, la rgle suivante impose que le texte de tout lment est noir l'exception
des lments pour lesquels cette proprit est modifie.
body {
color: black;
}
1. La proprit est modifie par au moins une rgle qui slectionne l'lment. La valeur de la proprit est alors
donne par la rgle de plus grande priorit (cf. ci-dessous).
2. Si aucune rgle ne donne la valeur de la proprit et si la proprit est hrite, la valeur est gale la valeur
de la proprit pour le pre.
3. Si la proprit n'est pas hrite ou si l'lment est la racine du document, la valeur de la proprit est alors une
valeur par dfaut appele valeur initiale.
10.3.2. Cascade
Plusieurs rgles peuvent s'appliquer un mme lment. Il y a souvent plusieurs feuilles de style pour le mme
document : une feuille de style par dfaut pour l'application, une autre fournie par l'auteur du document et
ventuellement une feuille donne par l'utilisateur. De plus, une mme feuille peut contenir plusieurs rgles qui
slectionnent le mme lment.
La priorit d'une rgle est d'abord dtermine par sa provenance. La feuille de style de l'auteur a priorit sur celle
de l'utilisateur qui a elle-mme priorit sur celle de l'application.
Pour les rgles provenant de la mme feuille de style, on applique l'algorithme suivant pour dterminer leur
priorit. On calcule une spcificit de chaque slecteur qui est un triplet (a,b,c) d'entiers. L'entier a est le nombre
d'occurrences de prdicats sur l'attribut id de forme #ident. L'entier b est le nombre de prdicats sur les autres
attributs y compris les attributs class de forme classname. Le nombre c est finalement le nombre de noms
d'lments apparaissant dans le slecteur. Les spcificits (a,b,c) et (a',b',c') des slecteurs des deux rgles sont
alors compares par ordre lexicographique. Ceci signifie qu'on compare d'abord a et a', puis b et b' si a est gal
a', puis finalement c et c' si (a,b) est gal (a',b').
Pour des rgles dont les slecteurs ont mme spcificit, c'est l'ordre d'apparition dans la feuille de style qui
dtermine la priorit. La dernire rgle apparue a une priorit suprieure.
217
CSS
To p
TM Ma rg in
TB Bo rd e r
TP Pa d d in g
LM LB LP RP RB RM
Le ft Co n t e n t Rig h t
BP
BB
BM
Bo t t o m
Le type de la bote est contrle par la proprit display de l'lment. Les principales valeurs que peut prendre
cette proprit sont block, inline, list-item et none. Cette dernire valeur permet de ne pas afficher
certains lments. Il est ainsi possible de crer des pages dynamiques en modifiant avec des scripts la valeur de
cette proprit.
La proprit position dtermine comment l'lment est positionn dans la bote englobante de l'lment pre. La
valeur static signifie que l'lment est positionn automatiquement par l'application dans le flux d'lments. La
valeur relative signifie que les valeurs des proprits top, right, bottom et left donnent un dplacement
par rapport la position normale. Pour les valeurs absolute et fixed, les proprits top, right, bottom
et left fixent la position par rapport la page ou par rapport la fentre de l'application.
218
CSS
bibliography {
display: block;
border: 1px solid black;
margin: 30px;
padding: 20px;
}
/* Calcul de la marque */
book:before {
content: "[" counter(c) "]";
counter-increment: c;
}
/* Titre en italique */
title {
font-style: italic;
}
<head>
219
CSS
<title>Titre de la page</title>
<link href="style.css" rel="stylesheet" type="text/css" />
</head>
<head>
<title>Titre de la page</title>
<style type="text/css"><!--
/* Contenu de la feuille de style inclus dans un commentaire XML */
body { background-color: white; }
--></style>
</head>
220
CSS
10.7.2. Fond
Proprit Valeur
background combinaison des proprits background-*
background-attachement scroll ou fixed
background-color couleur
background-image image
background-position pourcentage, dimension ou (top, center ou
bottom) et (left, right ou center)
background-repeat no-repeat, repeat-x, repeat-y ou repeat
10.7.4. Listes
Proprit Valeur
list-style Combinaison des trois proprits list-style-*
list-style-image image
list-style-position outside ou inside
list-style-type none, disc, circle, square, decimal, upper-
Roman, lower-Roman, upper-alpha ou lower-
alpha
221
Chapitre 11. SVG
SVG est un dialecte de XML pour le dessin vectoriel. Ce format permet de dfinir les lments graphiques de
manire standard.
e l l o , SV G!
H
Figure 11.1. Rendu du document ci-dessous
lment Rendu
Ligne
x2 ,y2
<line x1=... y1=... x2=... y2=... />
x1 ,y1
222
SVG
lment Rendu
Rectangle wid t h
x,y
<rect x=... y=... width=...
height=... /> h e ig h t
Ellipse
x4 ,y4
x2 ,y2
x4 ,y4
x2 ,y2
11.2.2. Chemins
lment Rendu
Point de dpart
Ligne horizontale
x1 ,y2
223
SVG
lment Rendu
Ligne
x2 ,y2
<path d="M x1 y1 L x2 y2"/>
x1 ,y1
x1 ,y1
x1 ,y1 c x2 ,c y2
x1 ,y1 c x2 ,c y2 x3 ,y3
x1 ,y1
Pour une introduction aux courbes de Bezier, on peut se rferer cette partie [Section 11.5].
11.2.3. Remplissage
lment Rendu (PNG)
Rgle evenodd
224
SVG
11.3. Transformations
L'lment g permet de grouper plusieurs lments graphiques. Il est ainsi possible d'associer simlutanment
plusieurs lments des rgles de style communes.
L'lment g permet aussi d'appliquer des transformations affines sur les lments graphiques. L'attribut
transform de l'lment g contient une suite de transformations appliques successivments. Les transformations
possibles sont les suivantes.
Transformation Action
translate(dx,dy) Translation (dplacement)
scale(x) ou scale(x,y) Dilatation
rotate(a) ou scale(a,cx,cy) Rotation
skewX(x) et skewY(y) Inclinaisons
225
SVG
P3 P4
P2 P2 P3
P2
P1 P4 P1 P3 P1 P4
La mthode de Casteljau permet la construction gomtrique de points de la courbe. Soient P1, P2, P3 et P4 les
points de contrle et soient L2, H et R3 les milieux des segments P1P2, P2P3 et P3P4. Soient L3 et R2 les milieux
des segments L2H et HR3 et soit L4 = R1 le milieu du segment L3R2 (cf. Figure ). Le point L4 = R1 appartient
la courbe de Bzier et il est obtenu pour t = 1/2. De plus la courbe se dcompose en deux courbes de Bzier : la
courbe de points de contrle L1 = P1, L2, L3 et L4 et la courbe de points de contrle R1, R2, R3 et R4 = P4. Cette
dcomposition permet de poursuivre rcursivement la construction de points de la courbe.
On remarque que chaque point de la courbe est barycentre des points de contrle affects des poids (1-t)3, 3t(1-
t)2, 3t2(1-t) et t3. Comme tous ces poids sont positifs, la courbe se situe entirement dans l'enveloppe convexe
des points de contrle.
226
SVG
Si dans la construction prcdente, les milieux sont remplacs par les barycentres avec les poids t et 1-t, on obtient
le point de la courbe de coordonnes x(t), y(t).
P3
H
P2
L4 = R1 R2
L3
R3
L2
P1 = L1 P4 = R4
11.5.2. B-splines
Les courbes B-splines sont aussi des courbes de degr 3. Elles sont donc aussi dtermines par quatre points de
contrle. Contrairement une courbe de Bzier, une B-spline ne passe par aucun de ses points de contrle. Par
contre, les B-splines sont adaptes pour tre mises bout bout afin de former une courbe ayant de multiples points
de contrle.
Soient n+3 points P1,,Pn+3. Ils dterminent n B-spline s1,,sn de la manire suivante. Chaque B-spline si est
dtermine par les points de contrle Pi, Pi+1, Pi+2 et Pi+3.
Si les coordonnes des points de contrle sont (x1, y1), , (xn+3, yn+3), l'quation de la spline si est la suivante.
partir des quations dfinissant les splines si, on vrifie facilement les formules suivantes qui montrent que la
courbe obtenue en mettant bout bout les courbes si est de classe C2, c'est--dire deux fois drivable.
11.5.3. Conversions
Puisque seules les courbes de Bzier sont prsentes en SVG, il est ncessaire de savoir passer d'une B-Spline
une courbe de Bzier. La B-spline de points de contrle P1, P2, P3 et P4 est en fait la courbe de Bzier dont les
points de contrle P'1, P'2, P'3 et P'4 sont calculs de la manire suivante. Si les coordonnes des points P1, P2,
P3 et P4 sont (x1, y1), (x2, y2), (x3, y3) et (x4, y4), les coordonnes (x'1, y'1), (x'2, y'2), (x'3, y'3) et (x'4, y'4) des
points P'1, P'2, P'3 et P'4 sont donnes par les formules suivantes pour les premires coordonnes et des formules
similaires pour la seconde.
227
SVG
x2 = 2x'2 - x'3
x3 = -x'2 + 2x'3
228
Chapitre 12. Programmation XML
Pages [Examples] des sources des examples.
Il existe deux mthodes essentielles appeles SAX et DOM pour lire un document XML dans un fichier. Il en
existe en fait une troisime appele StAX qui n'est pas aborde ici.
12.1. SAX
12.1.1. Principe
Ap p lic a t io n
Do c u m e n t s o u rc e
source.xm l
Eve n t
Pa rs e r
Ha n d le r
La tche du programmeur est lgre puisque le parseur est fourni par l'environnement Java. Seul le gestionnaire
d'vnements doit tre crit par le programmeur. Cette criture est facilite par les gestionnaires par dfaut qu'il
est facile de driver pour obtenir un gestionnaire.
import org.xml.sax.Attributes;
import org.xml.sax.Locator;
import org.xml.sax.helpers.DefaultHandler;
/**
* Handler trivial pour SAX
* Ce handler se contente d'afficher les balises ouvrantes et fermantes.
* @author O. Carton
229
Programmation XML
* @version 1.0
*/
class TrivialSAXHandler extends DefaultHandler {
public void setDocumentLocator(Locator locator) {
System.out.println("Location : " +
"publicId=" + locator.getPublicId() +
" systemId=" + locator.getSystemId());
}
public void startDocument() {
System.out.println("Debut du document");
}
public void endDocument() {
System.out.println("Fin du document");
}
public void startElement(String namespace,
String localname,
String qualname,
Attributes atts) {
System.out.println("Balise ouvrante : " +
"namespace=" + namespace +
" localname=" + localname +
" qualname=" + qualname);
}
public void endElement(String namespace,
String localname,
String qualname) {
System.out.println("Balise fermante : " +
"namespace=" + namespace +
" localname=" + localname +
" qualname=" + qualname);
}
public void characters(char[] ch, int start, int length) {
System.out.print("Caractres : ");
for(int i = start; i < start+length; i++)
System.out.print(ch[i]);
System.out.println();
}
}
// IO
import java.io.InputStream;
import java.io.FileInputStream;
// SAX
import javax.xml.parsers.SAXParserFactory;
import javax.xml.parsers.SAXParser;
/**
* Lecture triviale d'un document XML avec SAX
* @author O. Carton
* @version 1.0
*/
class TrivialSAXRead {
public static void main(String [] args)
throws Exception
{
// Cration de la fabrique de parsers
230
Programmation XML
12.2. DOM
12.2.1. Principe
Ap p lic a t io n
Do c u m e n t s o u rc e
source.xm l
Do c u m e n t t re e
Bu ild e r
231
Programmation XML
Du texte
</item>
et encore du texte.
</table>
La figure ci-dessous reprsente sous forme d'arbre le document XML prsent ci-dessus.
Do c u m e n t
Do c u m e n t Typ e
Co m m e n t
Pro c e s s in g In s t ru c t io n
Ele m e n t
At t rib u t e
Ele m e n t
At t rib u t e
At t rib u t e
Te xt
En t it yRe fe re n c e
Te xt
Ele m e n t
Co m m e n t
Te xt
Te xt
232
Programmation XML
Do c u m e n t Typ e
Ele m e n t
At t r
CDATASe c t io n
No d e Ch a ra c t e rDa t a Te xt
Co m m e n t
En t it y
En t it yRe fe re n c e
Pro c e s s in g In s t ru c t io n
No t a t io n
No d e Lis t
// IO
import java.io.InputStream;
import java.io.FileInputStream;
// DOM
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import org.w3c.dom.Document;
/**
* Lecture triviale d'un document XML avec DOM
* @author O. Carton
* @version 1.0
*/
class TrivialDOMRead {
public static void main(String [] args)
throws Exception
{
// Cration de la fabrique de constructeur de documents
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
// Cration du constructeur de documents
DocumentBuilder documentBuilder = dbf.newDocumentBuilder();
233
Programmation XML
12.3. Comparaison
La grande diffrence entre les API, SAX et DOM est que la premire ne charge pas le document en mmoire
alors que la seconde construit en mmoire une reprsentation arborescente du document. La premire est donc
particulirement adapte aux (trs) gros documents. Par contre, elle offre des facilits de traitement plus rduites.
Le fonctionnement par vnements rend difficiles des traitements non linaires du document. Au contraire, l'API
DOM rend plus faciles des parcours de l'arbre.
12.4. AJAX
Cette page [http://developer.apple.com/internet/webcontent/xmlhttpreq.html] donne un petit historique de l'objet
XMLHttpRequest.
234
Programmation XML
if (keyEvent.type == 'keyup') {
if (input.value) {
getData(url + input.value);
} else {
var target = document.getElementById("target");
target.innerHTML = "<div></div>";
}
}
}
<body>
<h2>Google Live Search</h2>
<!-- Zone de saisie -->
<!-- La fonction getSuggest est appele chaque touche relache -->
<p><input type="text" onkeyup="JavaScript:getSuggest(event)" /></p>
<!-- Div recevant le rsultat -->
<p><div id="target"></div></p>
</body>
235
Programmation XML
</html>
236
Annexe A. Acronymes
AJAX [ ]
Asynchronous JavaScript and XML
API [ ]
Application Programming Interface
BMP [ ]
Basic Multilingual Plane [Section 2.2]
BOM [ ]
Byte Order Mark [Section 2.2.4]
CSS [ ]
Cascading Style Sheet [Chapitre 10]
DOM [ ]
Document Object Model
DTD [ ]
Document Type Definition [Chapitre 3]
FPI
Formal Public Identifier [Section 3.2.2]
Infoset
XML Information Set
ISBN [ ]
International Standard Book Number
NCName
No Colon Name (Nom local) [Chapitre 4]
PCDATA
Parsed characters DATA
PNG [ ]
Portable Network Graphics
PDF
Portable Document Format
PSVI
Post-Schema Validation Infoset
QName
Qualified Name [Chapitre 4]
RDF [ ]
Resource Description Framework
RSS [ ]
Really Simple Syndication
SAML [ ]
Security Assertion Markup Language
SAX [ ]
Simple API for XML
237
Acronymes
SGML [ ]
Standard Generalized Markup Language [Chapitre 1]
SMIL [ ]
Synchronized Multimedia Integration Language
SOAP [ ]
Simple Object Access Protocol
SVG [ ]
Scalable Vector Graphics [Chapitre 11]
SVRL [http://www.schematron.com/validators.html]
Schematron Validation Report Language [Section 7.3]
UBL [ ]
Universal Business Language
UCS [ ]
Universal Character Set [Section 2.2]
URI [ ]
Uniform Resource Identifier [Section 2.3]
URL [ ]
Uniform Resource Locator [Section 2.3]
URN [ ]
Uniform Resource Name [Section 2.3]
UTF [ ]
Universal Transformation Format [Section 2.2.4]
WSDL [ ]
Web Services Description Language
XML [ ]
eXtensible Markup Language
XSD [ ]
XML Schema Definition [Chapitre 5]
XSL [ ]
eXtensible Style Language [Chapitre 8]
XSL-FO [ ]
XSL Formating Object [Chapitre 9]
238
Bibliographie
XML
A. Michard. XML langage et applications. Eyrolles. Paris. 2001. 2-212-09206-7.
XPath
M. Kay. XPath 2.0 Programmer's Reference. Wiley Publishing, Inc.. Indianapolis. 2004.
Schmas XML
V. Lamareille. XML Schema et XML Infoset. Cpadus. 2006.
XSLT et XSL-FO
P. Drix. XSLT fondamental. Eyrolles. 2002.
M. Kay. XSLT 2.0 and XPath 2.0. Wiley Publishing, Inc.. Indianapolis. 2008. 978-0-470-19274-0.
CSS
C. Aubry. CSS 1 et CSS 2.1. Editions ENI. 2006.
SVG
J. Eisenberg. SVG Essentials. O'Reilly. 2002. 2-596-00223-8.
239
'@', 102, 143
Index '@*', 144, 165
'i', 134
'm', 134
Symboles 's', 134
##any, 67 'U+', 7
##local, 67 '[' et ']', 26, 110, 135, 143, 215
##other, 67 '\', 109, 110
##targetNamespace, 67 '\c', 111
#all, 202 '\C', 111
#current, 202 '\d', 110
#default, 202 '\D', 110
#FIXED, 38, 71 '\i', 111
#IMPLIED, 27, 37, 38, 70 '\I', 111
#PCDATA, 23, 26, 34, 37, 61 '\s', 110, 133
#REQUIRED, 28, 37, 38, 70 '\S', 110
' ', 143, 175, 175, 216 '\w', 110
'!=', 125, 138, 174 '\W', 111
'"', 15, 19, 27, 29, 29, 31, 38, 38, 130 ']]>', 18
'#', 184, 214 '^', 76, 110, 134, 134
'$', 76, 132, 134, 134 '_', 8
'%', 31, 184 '{' et '}', 110, 141, 173, 213
'&', 18, 19, 29, 29, 174 '{{' et '}}', 174
''', 15, 19, 27, 29, 29, 31, 38, 38, 130, 195, 196 '|', 32, 36, 62, 102, 109, 127, 143
'(' et ')', 32, 36, 109, 132 '|=', 215
'()', 141 '~=', 215
'*', 32, 76, 103, 109, 118, 124, 129, 144, 162, 165, 174, '', 11
194, 214 '', 11
'*/', 213 '', 184
'+', 26, 32, 109, 118, 129, 216 '', 9
',', 32, 61, 117, 135, 136, 136, 184, 184 '##', 9
'-', 8, 20, 26, 110, 110, 129, 185, 215
'-->', 21, 220 A
'.', 8, 76, 110, 119, 134, 135, 139, 143, 165, 166, 175,
absolute, 218
184, 194, 207, 214
abstract, 86, 86, 88, 90, 152, 153
'..', 143
analyse lexicale, 8, 18, 22, 57, 77
'/', 13, 102, 116, 125, 143, 144, 164
ancestor-or-self::, 122, 175
'/*', 213
ancestor::, 122
'//', 13, 26, 102, 125, 143, 143, 195, 206
anctre, 18
'/>', 17
and, 128, 136, 152
'0', 184
ANY, 35
':', 8, 12, 13, 26, 42, 213
arbre du document, 112
'::', 120
as, 194, 195, 196, 200
';', 29, 31, 184, 213
atomisation, 115, 118
'<!', 25, 28
ATTLIST, 35
'<!--', 21, 220
attribut, 18
'<', 11, 16, 17, 18, 19, 125, 125, 138, 174
dclaration, 35, 68
'</', 16
interdit, 70
'<<', 116, 140
obligatoire, 38, 70
'<=', 138, 152
optionnel, 38, 70
'<?', 22
particulier, 19
'<?xml', 15, 22, 27
attribute(), 118
'=', 19, 125, 138, 215
attribute::, 121, 124
'>', 16, 17, 18, 19, 28, 29, 125, 138, 174, 216
attributeFormDefault, 50, 106
'>=', 138, 152
axe, 120, 120, 144
'>>', 116, 140
'?', 11, 32, 109, 118
'?>', 22
240
Index
241
Index
I ne, 137
nillable, 82
ID, 8, 21, 36, 99, 116, 119
NMTOKEN, 8, 36
id, 31
NMTOKENS, 36
identificateur, 8
node(), 115, 118, 124, 125, 126, 165, 165, 173
idiv, 129
nom
IDREF, 36, 37, 99, 116
local, 42
IDREFS, 36, 37, 116
qualifi, 9, 42, 176
if, 128, 141, 174, 201, 201, 201, 202
XML, 8, 16, 19, 22, 29, 37, 111
in, 142, 142, 142
none, 218
inline, 218
normalisation
instruction de traitement, 22, 113, 178
des caractres d'espacement, 133
intersect, 127
des fins de lignes, 8
is, 140, 206
Unicode, 12, 133
is-a, 153
NOTATION, 36
ISBN, 12
nud, 18, 112
ISO 10646, 7
courant, 115, 119, 120, 120, 143, 164, 167
ISO 3166, 20, 56
ISO 639, 20, 26, 56
ISO 9070, 26 O
ISO-8859-1, 10, 15 objet
ISO-8859-15, 10 courant, 119, 125, 135, 187
item(), 117 OpenDocument, 5
itemType, 65 OpenStreetMap, 4
optional, 70
J or, 128, 136, 136, 201
Java, 48, 54, 72, 88, 140, 141, 184, 195 ordre du document, 116, 125, 127, 137, 140
jeton, 8, 36
P
L paramtre, 195
Latin-1, 10 parent, 18, 114
Latin-15, 10 parent::, 121
le, 137 parse, 23
ligature, 11 Perl, 109
link, 219 petit-boutiste, 11
list-item, 218 point de code, 6, 7, 133
lt, 137 position, 218
position(), 126
M preceding-sibling::, 122
marque d'ordre des octets, 11 preceding::, 122, 181
match, 160, 164, 166, 171 preserve, 20, 77
MathML, 4, 42 priorit, 166, 211
maxOccurs, 62, 64, 64, 65, 66 d'import, 166, 211
memberTypes, 64 priority, 166
minOccurs, 62, 64, 65, 66, 107 processContents, 66, 71
mixed, 60 processing-instruction(), 118, 124, 125, 125
ML, 141 prohibited, 70, 70
mod, 129, 135, 176 prologue, 15, 15
mode, 164, 202, 202 PUBLIC, 26, 27, 29, 31
motif
XPath, 143, 150, 164, 181, 205 Q
QNAME, 42
N qualified, 50
name, 53, 59, 68, 68, 97, 98, 152, 167, 175, 176, 194,
195, 196, 200, 205 R
namespace, 67, 71, 108 racine, 112, 116, 127
namespace::, 123 ref, 53, 61, 69, 97, 98, 106
NCNAME, 42 regexp, 210
242
Index
243
Index
244
Index
xsd:maxInclusive, 59, 74, 77, 84 xsl:for-each-group, 120, 120, 186, 189, 192
xsd:maxLength, 76, 87 xsl:function, 197, 200
xsd:maxLenth, 77 xsl:if, 19, 174, 176, 182, 186, 206
xsd:minExclusive, 74, 75, 77 xsl:import, 166, 167, 177, 210
xsd:minInclusive, 74, 77, 87 xsl:include, 210
xsd:minLength, 76, 87 xsl:key, 155, 195, 205
xsd:Name, 56 xsl:matching-substring, 120, 210
xsd:NCName, 56 xsl:namespace-alias, 171
xsd:negativeInteger, 55 xsl:next-match, 166
xsd:NMTOKEN, 57, 59, 71 xsl:non-matching-substring, 210
xsd:NMTOKENS, 59 xsl:number, 181, 184, 186, 187
xsd:nonNegativeInteger, 56, 59, 64, 84, 91 xsl:otherwise, 186
xsd:nonPositiveInteger, 55 xsl:output, 162, 162, 180, 189, 209
xsd:normalizedString, 56, 77, 133 xsl:param, 153, 168, 194, 195, 200, 211
xsd:NOTATION, 59 xsl:perform-sort, 193
xsd:pattern, 75, 76 xsl:preserve-space, 162
xsd:positiveInteger, 55, 93, 96 xsl:processing-instruction, 178
xsd:QName, 56 xsl:result-document, 209
xsd:restriction, 59, 64, 65, 68, 74, 77, 77, 84, 87, 88, 90, xsl:sequence, 117, 178, 193, 194, 194, 197, 201, 201,
91, 92, 94, 95 202
xsd:schema, 50, 51, 69, 90, 93, 94, 97, 98, 105 xsl:sort, 166, 187, 189, 192, 208
xsd:selector, 99, 99, 103 xsl:strip-space, 162
xsd:sequence, 53, 60, 60, 61, 97 xsl:stylesheet, 161, 171, 194, 195, 196, 201, 205, 210
xsd:short, 55 xsl:template, 120, 160, 160, 164, 164, 165, 166, 169,
xsd:simpleContent, 60, 69, 72, 72, 73, 74 195, 202, 210
xsd:simpleType, 51, 52, 54, 59, 74, 77, 94 xsl:text, 166, 174, 186
xsd:string, 53, 56, 68, 76, 77, 117 xsl:transform, 161
xsd:time, 57, 117 xsl:value-of, 19, 169, 174, 176, 185, 187, 189, 193, 196,
xsd:token, 56, 77 199, 201, 202, 206
xsd:totalDigits, 77 xsl:variable, 178, 193, 193, 194, 194, 198, 201, 204
xsd:union, 64, 76 xsl:when, 30, 186
xsd:unique, 99 xsl:with-param, 153, 168, 194, 196
xsd:unsignedByte, 55 xsltproc, 195
xsd:unsignedInt, 55 XUL, 4
xsd:unsignedLong, 55
xsd:unsignedShort, 55
xsd:untyped, 117
xsd:untypedAtomic, 115, 117, 118, 138
xsd:whiteSpace, 77
xsd:yearMonthDuration, 57, 117
xsi:nil, 82
xsi:noNamespaceSchemaLocation, 45, 51
xsi:schemaLocation, 51
xsi:type, 83, 84, 88, 89, 93
xsl:analyze-string, 109, 210
xsl:apply-imports, 166, 211
xsl:apply-templates, 153, 160, 160, 164, 165, 165, 169,
179, 187, 192, 196, 202
xsl:attribute, 141, 173, 175, 176, 176, 197, 206
xsl:attribute-set, 176
xsl:call-template, 153, 167, 189, 196
xsl:choose, 141, 186, 186, 191
xsl:comment, 176, 178, 196, 209
xsl:copy, 162, 179, 182, 193, 199, 206
xsl:copy-of, 178, 179, 180, 193, 195, 204, 206
xsl:decimal-format, 119, 184
xsl:element, 175, 179
xsl:for-each, 165, 166, 178, 186, 187, 192, 194, 205
245