XML 6

L'essentiel de XML
Cours XML
Olivier Carton
L'essentiel de XML: Cours XML

Olivier Carton
Version du 06/02/2013
Copyright 2007-2013 Olivier Carton
Rsum
Support du cours XML en M2 Pro l'Universit Paris Diderot.
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 ........................................................................................................ 71
5.9. Restriction de types ....................................................................................................... 73
5.10. Substitutions ............................................................................................................... 81
5.11. Groupes d'lments et d'attributs .................................................................................... 95
5.12. Contraintes de cohrence .............................................................................................. 98
5.13. Espaces de noms ....................................................................................................... 103
5.14. Imports d'autres schmas ............................................................................................. 107
5.15. Expressions rationnelles .............................................................................................. 108
6. XPath .................................................................................................................................. 111
6.1. Donnes et environnement ............................................................................................ 111
6.2. Expressions de chemins ................................................................................................ 119
iii
L'essentiel de XML
6.3. Valeurs atomiques .......................................................................................................

6.4. Listes ........................................................................................................................
6.5. Comparaisons .............................................................................................................
6.6. Structures de contrle ...................................................................................................
6.7. Syntaxe abrge ..........................................................................................................
6.8. Motifs .......................................................................................................................
6.9. Utilisation interactive de xmllint ....................................................................................
6.10. Rcapitulatif des oprateurs XPath ................................................................................
7. Schematron ...........................................................................................................................
7.1. Introduction ................................................................................................................
7.2. Premier exemple .........................................................................................................
7.3. Fonctionnement ...........................................................................................................
7.4. Structure globale d'un schematron ..................................................................................
7.5. Rgles .......................................................................................................................
7.6. Rgles abstraites ..........................................................................................................
7.7. Blocs abstraits .............................................................................................................
7.8. Phases de validations ...................................................................................................
8. XSLT ..................................................................................................................................
8.1. Principe .....................................................................................................................
8.2. Premier programme : Hello, World! ........................................................................
8.3. Modle de traitement ...................................................................................................
8.4. Entte ........................................................................................................................
8.5. Dfinition et application de rgles ..................................................................................
8.6. Construction de contenu ...............................................................................................
8.7. Structures de contrle ...................................................................................................
8.8. Tris ...........................................................................................................................
8.9. Variables et paramtres ................................................................................................
8.10. Fonctions d'extension XPath ........................................................................................
8.11. Modes ......................................................................................................................
8.12. Indexation ................................................................................................................
8.13. Documents multiples ..................................................................................................
8.14. Analyse de chanes ....................................................................................................
8.15. Import de feuilles de style ...........................................................................................
9. XSL-FO ...............................................................................................................................
9.1. Premier exemple .........................................................................................................
9.2. Structure globale .........................................................................................................
10. CSS ...................................................................................................................................
10.1. Principe ....................................................................................................................
10.2. Rgles ......................................................................................................................
10.3. Hritage et cascade ....................................................................................................
10.4. Modle de botes .......................................................................................................
10.5. Style et XML ............................................................................................................
10.6. Attachement de rgles de style .....................................................................................
10.7. Principales proprits ..................................................................................................
11. SVG ..................................................................................................................................
11.1. Un premier exemple ...................................................................................................
11.2. lments de dessins ...................................................................................................
11.3. Transformations .........................................................................................................
11.4. Indications de style ....................................................................................................
11.5. Courbes de Bzier et B-splines .....................................................................................
12. Programmation XML ............................................................................................................
12.1. SAX ........................................................................................................................
12.2. DOM .......................................................................................................................
12.3. Comparaison .............................................................................................................
12.4. AJAX ......................................................................................................................
A. Acronymes ...........................................................................................................................
Bibliographie ............................................................................................................................
Index .......................................................................................................................................
iv
127
134
136
140
142
142
143
145
146
146
146
147
148
149
151
152
155
156
156
158
158
160
162
167
184
190
191
197
199
200
203
204
205
207
207
207
208
208
208
212
213
213
214
215
217
217
217
220
220
221
224
224
226
229
229
232
234
235
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 document 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 du ses qualits. Nous allons d'abord
numrer ces caractristiques essentielles qui ont conduit ce dveloppement puis nous allons les dtailler plus
en profondeur.
Sparation stricte entre contenu et prsentation
Simplicit, universalit et extensibilit
Format texte avec gestion des caractres spciaux
Structuration forte
Modles de documents (DTD [Chapitre 3] et Schmas XML [Chapitre 5])
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
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.jussieu.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.jussieu.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
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 utiliss 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.
1.3. Langages apparents

Un des atouts indniables de XML est le nombre de technologies et de langages qui se sont dvelopps autour de
XML. Ceux-ci enrichissent les outils pour la manipulation des documents XML. La liste ci-dessous numre les
principaux langages qui font partie de l'environnement XML.
XLink [ ] et XPointer [ ] (liens entre documents)
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.
Prsentation de XML
XPath [ ] (langage de slection)

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 [ ] (langage de requte)
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.
Schmas XML [ ] (modles de documents)
Les schmas XML remplacent les DTD hrites de SGML pour dcrire des modles de documents. Ils sont
beaucoup plus souples et beaucoup plus puissants que les DTD. Ils sont abords en dtail au chapitre 5 de
cet ouvrage.
XSLT [ ] (transformation de documents)
XSLT est un langage permettant d'exprimer facilement des transformations complexes entre documents XML.
Il s'appuie sur la structuration forte des documents XML vus comme des arbres. Chaque transformation est
dcrite par des rgles pour chacun des lments du document. Il est tudi en profondeur au chapitre 8 de
cet ouvrage.
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.
RSS [ ] (Really Simple Syndication)
Abonnement des flux de donnes
XUL [ ] (XML-based User interface Language)
Langage de description d'interfaces graphiques dvelopp par le projet Mozilla.
SVG [ ] (Scalable Vector Graphics)
Description de dessins vectoriels
SMIL [ ] (Synchronized Multimedia Integration Language)
Description de contenus multimdia
MathML [ ] (Mathematical Markup Language)
Description de formules mathmatiques
WSDL [ ] (Web Services Description Language)
Description de services WEB
OpenStreetMap [ ]
Cartes libres
XML Signature [ ]
Format pour les signatures lectroniques
Prsentation de XML
SAML [ ] (Security Assertion Markup Language)

Langage d'change d'authentifications et d'autorisations
UBL [ ] (Universal Business Language)
Bibliothque de documents standards pour les changes commerciaux
OpenDocument [ ]
Format de document pour les applications bureautiques dvelopp au dpart pour OpenOffice mais aussi
utilis par d'autres logiciels libres comme KOffice
DocBook [ ]
Format de documentation technique
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.
<?xml version="1.0" encoding="iso-8859-1"?>
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.
Prsentation de XML
<!DOCTYPE root-element ... >

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. Il a quelques fois t pris la libert 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.
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.
2.1. Premier exemple

Le langage XML est un format orient texte. Un document XML est simplement une suite de caractres respectant
quelques rgles. Il peut tre stock dans un fichier et/ou manipul par des logiciel en utilisant un codage des
caractres. Ce codage prcise comment traduire chaque caractre en une suite d'octets rellement stocks ou
manipuls. Les diffrents codages possibles et leurs incidences sur le traitement des documents sont abords plus
loin dans ce chapitre [Section 2.2]. Comme un document XML est seulement du texte, il peut tre crit comme
l'exemple ci-dessous.
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.

<!DOCTYPE bibliography SYSTEM "bibliography.dtd" >
<bibliography>
<book key="Michard01" lang="fr">
<title>XML langage et applications</title>
<author>Alain Michard</author>
<year>2001</year>
<publisher>Eyrolles</publisher>
<isbn>2-212-09206-7</isbn>
<url>http://www.editions-eyrolles/livres/michard/</url>
</book>
<book key="Zeldman03" lang="en">
<title>Designing with web standards</title>
<author>Jeffrey Zeldman</author>
<year>2003</year>
<publisher>New Riders</publisher>
<isbn>0-7357-1201-8</isbn>
</book>
...
</bibliography>
Entte XML avec la version 1.0 et l'encodage iso-8859-1 des caractres.
Commentaire dlimit par les chanes de caractres .
Dclaration de DTD externe dans le fichier bibliography.dtd.
Balise ouvrante de l'lment racine bibliography
Balise ouvrante de l'lment book avec deux attributs de noms key et lang et de valeurs Michard01
et fr
Balise fermante de l'lment racine bibliography
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
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.
2.2.1. Caractres spciaux

Les cinq caractres '<' U+2C, '>' U+2E, '&' U+26, ''' U+27 et '"' U+22 ont une signification particulire
dans les documents XML. Les deux caractres '<' et '>' servent dlimiter les balises [Section 2.7.1], ainsi que
les commentaires [Section 2.7.5] et les instructions de traitement [Section 2.7.6]. Le caractre '&' marque le dbut
des rfrences aux entits gnrales [Section 3.5.1]. Pour introduire ces caractres dans le contenu du document,
il faut utiliser des sections littrales [Section 2.7.2] ou les entits prdfinies [Section 3.5.1.2]. Les caractres '''
et '"' servent galement de dlimiteurs, en particulier pour les valeurs des attributs [Section 2.7.3]. Dans ces cas,
il faut encore avoir recours aux entits prdfinies pour les introduire.
2.2.2. Caractres d'espacement

Le traitement XML des caractres d'espacement est simple dans un premier temps. Chaque caractre d'espacement
est quivalent un espace et plusieurs espaces conscutifs sont encore quivalents un seul espace. C'est le
comportement habituel des langages de programmation classiques. Dans un second temps, le traitement des
caractres d'espacement par une application est command par l'attribut xml:space [Section 2.7.4.2]. Les
caractres d'espacement sont l'espace ' ' U+20, la tabulation U+09 ('\t' en notation du langage C), le saut
de ligne U+0A ('\n' en C) et le retour chariot U+0D ('\r' en C).
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.
la suite des deux caractres U+0D U+0A
la suite des deux caractres U+0D U+85
le caractre U+85 appel Next Line
le caractre U+2028 appel Line Separator
le caractre U+0D non suivi de U+0A ou U+85
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.
2.2.3. Jetons et noms XML

Les identificateurs sont utiliss en XML pour nommer diffrents objets comme les lments, les attributs, les
instructions de traitement. Ils servent aussi identifier certains lments par l'intermdiaire des attributs de type
ID [Section 3.7.2]. XML distingue deux types d'identificateurs: les jetons et les noms XML. La seule diffrence
est que les noms XML doivent commencer par certains caractres particuliers. Dans la terminologie XML, les
jetons sont appels NMTOKEN pour name token.
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 '_'.
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].
Quelques exemples d'identificateurs sont donns ci-dessous.
Noms XML valides :
name, id-42, xsl:template, sec.dtd-3.1 et _special_
Jetons qui ne sont pas des noms :
-name, 42, 42-id et .sect.
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.
Syntaxe de XML
Reprsentation UTF-16
Signification
xxxxxxxx xxxxxxxx
2 octets codant 16 bits
110110zz zzxxxxxx
4 octets codant 20 bits
110111xx xxxxxxxx
yyyy xxxxxxxx xxxxxxxx o zzzz = yyyy-1
Tableau 2.1. Codage UTF-16

Le symbole de l'Euro '' U+20AC, est, par exemple, cod par les deux octets x20 xAC = 00100000
10101100 puisqu'il fait partie du BMP. Le symbole de la croche '##' U+1D160 est cod par les 4 octets
xD8 x34 xDD x60 = 11011000 00110100 11011101 01100000.
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.
Reprsentation UTF-8
Signification
0xxxxxxx
1 octet codant 7 bits
110xxxxx 10xxxxxx
2 octets codant 8 11 bits
1110xxxx 10xxxxxx 10xxxxxx
11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
Tableau 2.2. Codage UTF-8

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.
ISO-8859-1 (appel Latin-1) [ ]
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.
ISO-8859-15 (appel Latin-9 ou Latin-0) [ ]
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.
Codage
Squence d'octets en hexadcimal pour Htrogne
UTF-8
48 C3 A9 74 C3 A9 72 6F 67 C3 A8 6E 65
ISO-8859-1
48 E9 74 E9 72 6F 67 E8 6E 65
UTF-16
00 48 00 E9 00 74 00 E9 00 72 00 E8 00 6E 00 65
10
Syntaxe de XML
Codage
Squence d'octets en hexadcimal pour Htrogne
UTF-32
00 00 00 48 00 00 00 E9 00 00 00 74 00 00 00 65
Tableau 2.3. Comparaison des codages

Les logiciels manipulant des documents XML doivent obligatoirement grer les codages UTF-8 et UTF-16. Les
autres codages sont facultatifs. Il est essentiel que le codage d'un document soit indiqu dans l'entte [Section 2.6.1]
du document. Si un navigateur interprte, par exemple, la suite d'octets du codage UTF-8 du mot Htrogne
comme un codage en ISO-8859-1, il affiche la chane Htrogne.
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.
2.2.4.1. Marque d'ordre des octets

Pour les codages non bass sur les octets comme UTF-16 ou UCS-2, il est important de savoir dans quel ordre
sont placs les deux octets de poids fort et de poids faible d'un mots de 16 bits. Il existe deux modes appels grosboutiste et petit-boutiste (big endian et little endian en anglais). Dans le mode gros-boutiste, l'octet de poids fort
est plac avant l'octet de poids faible alors que dans le mode petit-boutiste, l'octet de poids fort est plac aprs
l'octet de poids faible.
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].
Codage
Mode
Squence d'octets en hexadcimal
UTF-8 sans BOM
3C 3F 78
UTF-8 avec BOM
EF BB BF 3C 3F 78
UTF-16 ou UCS-2
gros-boutiste
FE FF 00 3C 00 3F
UTF-16 ou UCS-2
petit-boutiste
FF FE 3C 00 3F 00
UTF-32
gros-boutiste
00 00 FE FF 00 00 00 3C
UTF-32
petit-boutiste
FE FF 00 00 3C 00 00 00
Tableau 2.4. Marques d'ordre des octets

Bien que la marque d'ordre des octets puisse tre mise dans un document cod en UTF-8, celle-ci est inutile et il est
dconseill de la mettre. La marque d'ordre des octets ne peut pas tre mise dans un document cod en ISO-8859-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+EF mais il correspond galement la
suite U+69 U+A8 forme du caractre 'i' suivi du caractre spcial trma '' U+A8. 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+69 U+A8 en
le caractre '' U+EF. La normalisation d'une chane de caractres peut tre obtenue avec la fonction XPath
normalize-unicode() [Section 6.3.3].
2.3. URI, URL et URN

XML et toutes les technologies autour de XML font un grand usage des URI et plus particulirement des URL.
Ceux-ci sont, par exemple, employs pour rfrencer des documents externes comme des DTD [Chapitre 3] ou
pour identifier des espaces de noms [Chapitre 4]. Les URL sont bien connues car elles sont utilises au quotidien
pour naviguer sur le WEB. La terminologie XML distingue galement les URI et les URN. Les significations
exactes de ces trois termes dans la terminologie XML sont les suivantes.
URI
Uniform Resource Identifier
URL
Uniform Resource Locator
URN
Uniform Resource Name
URI
URL
URN
Figure 2.1. Relations entre URI, URL et 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.liafa.jussieu.fr/~carton/
sftp://carton@liafa.jussieu.fr
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.
2.3.1. Rsolution d'URI

Un URI appel URI de base est souvent attach un document ou un fragment d'un document XML. Cet URI
est gnralement une URL. Il sert rsoudre les URL contenues dans le fragment de document, qu'elles soient
relatives ou absolues. Cette rsolution consiste combiner l'URL de base avec ces URL pour obtenir des URL
absolues qui permettent de dsigner des documents externes.
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 '/'.
Rpert oire
Prot ocole
Adresse Int ernet
Chem in d'accs
Rpert oire
Prot ocole
Fichier
Fichier
Chem in d'accs
Figure 2.2. Structure d'une URL

La combinaison d'une URL de base base avec une autre URL url pour former une URL complte est ralise
de la faon suivante qui dpend essentiellement de la forme de la seconde URL url.
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.
url="" (chane vide)
http://www.somewhere.org/Teaching/index.html
url="XML/chapter.html" (chemin relatif)
http://www.somewhere.org/Teaching/XML/chapter.html
url="XML/XPath/section.html" (chemin relatif)
http://www.somewhere.org/Teaching/XML/XPath/section.html
url="/Course/section.html" (chemin absolu)
http://www.somewhere.org/Course/section.html
url="http://www.elsewhere.org/section.html" (URL complte)
http://www.elsewhere.org/section.html
2.4. Syntaxe et structure

Il y a, en franais, l'orthographe et la grammaire. La premire est constitue de rgles pour la bonne criture
des mots. La seconde rgit l'agencement des mots dans une phrase. Pour qu'une phrase en franais soit correcte,
il faut d'abord que les mots soient bien orthographis et, ensuite, que la phrase soit bien construite. Il y aurait
encore le niveau smantique mais nous le laisserons de ct. XML a galement ces deux niveaux. Pour qu'un
document XML soir correct, il doit d'abord tre bien form et, ensuite, tre valide. La premire contrainte est
de nature syntaxique. Un document bien form doit respecter certaines rgles syntaxiques propres XML qui
sont explicites dans ce chapitre. Il s'agit, en quelque sorte, de l'orthographe d'XML. La seconde contrainte est de
nature structurelle. Un document valide doit respecter un modle de document. Un tel modle dcrit de manire
rigoureuse comment doit tre organis le document. Un modle de documents peut tre vu comme une grammaire
pour des documents XML. La diffrence essentielle avec le franais est que la grammaire d'XML n'est pas fige.
Pour chaque application, il est possible de choisir la grammaire la plus approprie. Cette possibilit d'adapter la
grammaire aux donnes confre une grande souplesse XML. Il existe plusieurs langages pour crire des modles
de document. Les DTD (Document Type Description), hrites de SGML, sont simples mais aussi assez limites.
Elles sont dcrites au chapitre suivant [Chapitre 3]. Les schmas XML sont beaucoup plus puissants. Ils sont
dcrits dans un autre chapitre [Chapitre 5].
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.
2.5. Composition globale d'un document

La composition globale d'un document XML est immuable. Elle comprend toujours les constituants suivants.
14
Syntaxe de XML
Prologue
Il contient des dclarations facultatives.
Corps du document
C'est le contenu mme du document.
Commentaires et instructions de traitement
Ceux-ci peuvent apparatre partout dans le document, dans le prologue et le corps.
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.
<?xml ... ?>
Prologue
...
<root-element>
...
Corps
</root-element>
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.
<?xml ... ?>
<!DOCTYPE root-element [
...
]>
Entte XML
Prologue
DTD
Les diffrentes parties du prologue sont dtailles dans les sections suivantes.
2.6.1. Entte XML

L'entte utilise une syntaxe <?xml ... ?> semblable celle des instructions de traitement [Section 2.7.6] bien
qu'elle ne soit pas vritablement une instruction de traitement. L'entte XML a la forme gnrale suivante.
<?xml version="..." encoding="..." standalone="..."?>
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.
2.6.2. Dclaration de type de document

La dclaration de type dfinit la structure du document. Elle prcise en particulier quels lments peut contenir
chacun des lments. Cette dclaration de type peut prendre plusieurs formes suivant que la dfinition du type
est interne, c'est--dire incluse dans le document ou externe. Elle a la forme gnrale suivante qui utilise le mot
cl DOCTYPE.
<!DOCTYPE ... >
La forme prcise de cette dclaration est explicite au chapitre consacr aux DTD [Chapitre 3].
2.7. Corps du document

Le corps du document est constitu de son contenu qui est organis de faon hirarchique la manire d'un systme
de fichiers l'exception qu'aucune distinction n'est faite entre fichiers et rpertoires. L'unit de cette organisation
est l'lment. Chaque lment peut contenir du texte simple, comme un fichier, d'autres lments, comme un
rpertoire, ou encore un mlange des deux.
Comme dans une arborescence de fichiers, il y a un lment appel lment racine qui contient l'intgralit du
document.
2.7.1. lments
Cont enu de l'lm ent nam e
Figure 2.3. Composition d'un lment

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
Cont enu vide
Figure 2.4. lment avec un contenu vide

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>
Figure 2.5. Imbrication des lments

Comme chaque lment possde une balise ouvrante et une balise fermante, les balises vont ncessairement par
paire. toute balise ouvrante correspond une balise fermante et inversement. L'imbrication des balises doit, en
outre, tre correcte. Si deux lments tag1 et tag2 ont un contenu commun, alors l'un doit tre inclus dans
l'autre. Autrement dit, si la balise ouvrante <tag2> se trouve entre les deux balises <tag1> et <tag1/>, alors
la balise fermante </tag2> doit aussi se trouver entre les deux balises <tag1> et <tag1/> (cf. figure).
<parent>
<sibling1>
<sibling2>
<self>
<child1>
<child2>
<child3>
</self>
<sibling3>
</parent>
... </sibling1>
... </sibling2>
... <desc1></desc1> ... <desc2></desc2> ... </child1>
... </child2>
... <desc3><desc4> ... </desc4></desc3> ... </child3>
... </sibling3>
parent
sibling1
sibling2
se lf
child1
child2
desc1
desc2
sibling3
child3
desc3
desc4
Figure 2.6. Liens de parent
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.
]
Balise ouvrante de l'lment racine
Corps
...
lments, commentaires et
du
...
instructions de traitement
Balise fermante de l'lment racine
...
<root-element>
</root-element>
...
document
2.7.2. Sections littrales

Les caractres spciaux '<', '>' et '&' ne peuvent pas tre inclus directement dans le contenu d'un document.
Ils peuvent tre inclus par l'intermdiaire des entits prdfinies [Section 3.5.1.2].
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.
<![CDATA[Contenu avec des caractres spciaux <, > et & ]]>
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.
<tag attribute="value"> ... </tag>
<tag attribute1="value1" attribute2="value2"> ... </tag>
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.
<hr style="color:red; height:15px; width:350px;" />
<xsd:attribute name="key" type="xsd:NMTOKEN" use="required"/>
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.
<xsl:value-of select="key('idchapter', @idref)/title"/>
<xsl:if test='@quote = "'"'>
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.
<personname id="I666" firstname="Gaston" surname="Lagaffe"/>
2.7.4. Attributs particuliers

Il existe quatre attributs particuliers xml:lang, xml:space, xml:base et xml:id qui font partie de l'espace
de noms XML [Section 4.7]. Lors de l'utilisation de schmas, ces attributs peuvent tre dclars en important
[Section 5.14] le schma l'adresse http://www.w3.org/2001/xml.xsd.
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.
<book xml:lang="fr">
<title>Livre en Franais</title>
<chapter>
<title>Chapitre en Franais</title>
<p>Paragraphe en Franais</p>
<p xml:lang="en">Paragraph in English</p>
</chapter>
<chapter xml:lang="en">
<title>Chapter in English</title>
<p xml:lang="fr">Paragraphe en Franais</p>
<p>Paragraph in English</p>
</chapter>
</book>
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.
2.7.4.1. Attribut xml:lang

L'attribut xml:lang est utilis pour dcrire la langue du contenu de l'lment. Sa valeur est un code de langue
sur deux ou trois lettres de la norme ISO 639 [ ] (comme par exemple en, fr, es, de, it, pt, ). Ce code
peut tre suivi d'un code de pays sur deux lettres de la norme ISO 3166 [ ] spar du code de langue par un
caractre tiret '-'. L'attribut xml:lang est du type xsd:language [Section 5.5.1.2] qui est spcialement
prvu pour cet attribut.
<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.
2.7.4.2. Attribut xml:space

L'attribut xml:space permet d'indiquer une application le traitement des caractres d'espacement
[Section 2.2.2]. Les deux valeurs possibles de cet attribut sont default et preserve.
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].
2.7.4.3. Attribut xml:base

chaque lment d'un document XML est associe une URI [Section 2.3] appele URI de base. Celle-ci est
utilise pour rsoudre les URL des entits externes, qui peuvent tre, par exemple des fichiers XML ou des fichiers
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.
<img src="element.png" alt="lment"/>
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.liafa.jussieu.fr/~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.
<?xml version="1.0" encoding="iso-8859-1" standalone="yes"?>
<book xml:base="http://www.somewhere.org/Teaching/index.html">
<chapter xml:base="XML/chapter.html">
<section xml:base="XPath/section.html"/>
<section xml:base="/Course/section.html"/>
<section xml:base="http://www.elsewhere.org/section.html"/>
</chapter>
</book>
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().
2.7.4.4. Attribut xml:id

L'attribut xml:id est de type xsd:ID. Il permet d'associer un identificateur tout lment indpendamment de
toute DTD ou de tout schma.
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 '' 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.
<?xml version="1.0" encoding="ISO-8859-1" standalone="no"?>

<!DOCTYPE simple [

<!ELEMENT simple (#PCDATA) >
]>

<simple>

Un exemple simplissime

</simple>

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.

2.7.6. Instructions de traitement

Les instructions de traitement sont destines aux applications qui traitent les documents XML. Elles sont l'analogue
des directives #... du langage C qui s'adressent au compilateur. Elles peuvent apparatre aux mmes endroits
que les commentaires l'exception du contenu de la DTD.
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.
<?xml-stylesheet href="list.xsl" type="text/xsl" title="En liste"?>
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.
2.8. Exemples minimaux

Quelques exemples minimalistes de documents XML sont donns ci-dessous.
22
Syntaxe de XML
2.8.1. Exemple minimal

L'exemple suivant contient uniquement un prologue avec la l'entte XML et un lment de contenu vide. Les
balises ouvrante <tag> et fermante </tag> ont t contractes en une seule balise <tag/> [Section 2.7.1]. Ce
document n'a pas de dclaration de DTD.
<?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.8.2. Exemple simple avec une DTD

Cet exemple contient une dclaration de DTD qui permet de valider le document. Cette DTD dclare l'lment
simple avec un contenu purement textuel.
<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<!DOCTYPE simple [
]>
<simple>Un exemple simplissime</simple>
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 prfrences 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">
...

<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.
Si chacun des fichiers introduction.xml et Syntax/chapter.xml a comme lment racine un lment
chapter sans attribut xml:base, le rsultat de l'inclusion de ces fichiers doit donner un document ressemblant
ceci.
<book version="5.0"
...

<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
quelles 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.
3.1. Un premier exemple

On reprend la petite bibliographie du fichier bibliography.xml dj utilise au chapitre prcdent. La
troisime ligne de ce fichier est la dclaration de la DTD qui rfrence un fichier externe bibliography.dtd.
Le nom bibliography de l'lment racine du document apparat dans cette dclaration juste aprs le mot cl
DOCTYPE.
<!DOCTYPE bibliography SYSTEM "bibliography.dtd">
On prsente maintenant le contenu de ce fichier bibliography.dtd qui contient la DTD du fichier
bibliography.xml. La syntaxe des DTD est hrite de SGML et elle est diffrente du reste du document
XML. Il n'y a pas de balises ouvrantes et fermantes. La DTD contient des dclarations d'lments et d'attributs
dlimites par les chanes de caractres '<!' et '>'. Un mot cl juste aprs la chane '<!' indique le type de
la dclaration. La syntaxe et la signification prcise de ces dclarations sont explicites dans ce chapitre.
<!ELEMENT
<!ELEMENT
<!ATTLIST
<!ATTLIST
<!ELEMENT
<!ELEMENT
<!ELEMENT
<!ELEMENT
<!ELEMENT
<!ELEMENT
bibliography (book)+>
book (title, author, year, publisher, isbn, url?)>
book key
NMTOKEN #REQUIRED>
book lang (fr | en) #REQUIRED>
title
(#PCDATA)>
author
(#PCDATA)>
year
(#PCDATA)>
publisher (#PCDATA)>
isbn
(#PCDATA)>
url
(#PCDATA)>
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.
3.2. Dclaration de la DTD

La dclaration de la DTD du document doit tre place dans le prologue. La DTD peut tre interne, externe ou
mixte. Elle est interne si elle est directement incluse dans le document. Elle est externe si le document contient
seulement une rfrence vers un autre document contenant la DTD. Elle est finalement mixte si elle est constitue
d'une partie interne et d'une partie externe.
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
<!DOCTYPE root-element ... >

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.
3.2.1. DTD interne

Lorsque la DTD est incluse dans le document, sa dclaration prend la forme suivante o son contenu est encadr
par des caractres crochets '[' et ']'.
<!DOCTYPE root-element [ declarations ]>
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 [
]>
3.2.2. DTD externe

Lorsque la DTD est externe, celle-ci est contenue dans un autre fichier dont l'extension est gnralement .dtd.
Le document XML se contente alors de donner l'adresse de sa DTD pour que les logiciels puissent y accder.
L'adresse de de la DTD peut tre donne explicitement par une URL ou par un FPI (Formal Public Indentifier).
Les FPI sont des noms symboliques donns aux documents. Ils sont utiliss avec des catalogues qui tablissent les
correspondances entre ces noms symboliques et les adresses relles des documents. Lorsqu'un logiciel rencontre
un FPI, il parcourt le catalogue pour le rsoudre, c'est--dire dterminer l'adresse relle du document. Les
catalogues peuvent contenir des adresses locales et/ou des URL. Ils constituent donc une indirection qui facilite la
maintenance. Lorsqu'un document, une DTD par exemple, est dplac, il suffit de modifier les catalogues plutt
que tous les documents qui rfrencent le document.
3.2.2.1. Adresse par FPI

Les FPI (Formal Public Identifier) sont des identifiants de document hrits de SGML. Ils sont plutt remplacs
en XML par les URI [Section 2.3] qui jouent le mme rle. Ils sont constitus de quatre parties spares par des
chanes '//' et ils obissent donc la syntaxe suivante.
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.
-//W3C//DTD XHTML 1.0 Strict//EN
-//OASIS//DTD Entity Resolution XML Catalog V1.0//EN
ISO/IEC 10179:1996//DTD DSSSL Architecture//EN
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.
<!DOCTYPE root-element PUBLIC "fpi" "url">
L'exemple suivant est la dclaration typique d'une page HTML qui utilise une des DTD de XHTML.
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
3.2.2.2. Adresse par URL

La rfrence une URL est introduite par le mot cl SYSTEM suivi de l'URL dlimite par des apostrophes '''
ou des guillemets '"'.
<!DOCTYPE root-element SYSTEM "url">
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.
<!DOCTYPE bibliography SYSTEM
"http://www.liafa.jussieu.fr/~carton/Enseignement/bibliography.dtd">
<!DOCTYPE bibliography SYSTEM "bibliography.dtd">
3.2.3. DTD mixte

Il est possible d'avoir simultanment une DTD externe adresse par URL ou FPI et des dclarations internes. La
DTD globale est alors forme des dclarations internes suivies des dclarations externes. La dclaration prend alors
une des deux formes suivantes On retrouve un mlange de la syntaxe des DTD externes avec les mots cls SYSTEM
et PUBLIC et de la syntaxe des DTD internes avec des dclarations encadres par les caractres '[' et ']'.
<!DOCTYPE root-element SYSTEM "url" [ declarations ]>
<!DOCTYPE root-element PUBLIC "fpi" "url" [ declarations ]>
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.


<!ENTITY % book.entries "">
<!ELEMENT bibliography (book)+>
<!ELEMENT book (title, author, year, publisher, isbn %book.entries;)>
<!ATTLIST book key NMTOKEN #REQUIRED>
<!ATTLIST book lang (fr | en) #IMPLIED>
<!ELEMENT title
(#PCDATA)>
<!ELEMENT author
(#PCDATA)>
27
DTD
<!ELEMENT year
(#PCDATA)>
<!ELEMENT publisher (#PCDATA)>
<!ELEMENT isbn
(#PCDATA)>
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.
<!DOCTYPE bibliography SYSTEM "mixed.dtd" [

<!ENTITY % book.entries ", url?">


<!ATTLIST book lang (fr | en) #REQUIRED>

<!ELEMENT url (#PCDATA)>
]>
<bibliography>
<year>2001</year>
<isbn>2-212-09206-7</isbn>
</book>
<book key="Marchal00" lang="fr">
<title>XML by Example</title>
<author>Benot Marchal</author>
<year>2000</year>
<publisher>Macmillan Computer Publishing</publisher>
<isbn>0-7897-2242-9</isbn>
</book>
</bibliography>
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.
<!ELEMENT book (title, author, year, publisher, isbn, url?)>
3.3. Contenu de la DTD

Une DTD est constitue de dclarations d'lments, d'attributs et d'entits. Elle peut aussi contenir des dclarations
de notations mais celles-ci ne sont pas abordes dans cet ouvrage. Chacune de ces dclarations commence par
la chane '<!' suivi d'un mot cl qui indique le type de dclaration. Les mots cls possibles sont ELEMENT,
ATTLIST et ENTITY. La dclaration se termine par le caractre '>'.
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 ''. 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.

<!ELEMENT bibliography (book)+>
28
DTD

<!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].
3.5.1. Entits gnrales

Les entits gnrales sont les entits les plus courantes et les plus utiles puisqu'elles peuvent tre utilises dans
le corps du document.
3.5.1.1. Dclaration et rfrence

La dclaration d'une entit commence par <!ENTITY suivi du nom de l'entit. Elle prend une des trois formes
suivantes o name est le nom de l'entit, fragment est un fragment de document, fpi et url sont un FPI et
une URL.
<!ENTITY name "fragment">
<!ENTITY name SYSTEM "url">
<!ENTITY name PUBLIC "fpi" "url">
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.
<tag meta="attribute: &name;">Content: &name;</tag>
3.5.1.2. Entits prdfinies

Il existe des entits prdfinies permettant d'inclure les caractres spciaux [Section 2.2.1] '<', '>', '&', '''
et '"' dans les contenus d'lments et dans les valeurs d'attributs. Ces entits sont les suivantes.
Entit
Caractre
<
<
29
DTD
Entit
Caractre
>
>
&
&
'
'
"
"
Tableau 3.1. Entits prdfinies

Les trois entits <, > et & doivent tre utilises aussi bien dans le contenus des lments que dans
les valeurs des attributs puisque les caractres '<', '>' et '&' ne peuvent pas y apparatre directement. Les
deux entits ' et " sont uniquement ncessaires pour inclure le caractre ''' ou le caractre '"'
dans la valeur d'un attribut dlimite par le mme caractre. Lors de l'utilisation XPath [Chapitre 6] avec XSLT
[Chapitre 8], il n'est pas rare d'inclure ces deux caractres dans la valeur d'un attribut. Une des deux entits '
ou " devient alors indispensable. L'exemple suivant est extrait d'une feuille de style XSLT. La valeur de
l'attribut test est une expression XPath qui teste si la valeur de la variable string contient le caractre '"'.
<xsl:when test="contains($string, '"')">
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).
3.5.1.3. Entits internes

La valeur d'une entit interne est le fragment de document associ celle-ci lors de sa dclaration. Cette valeur peut
contenir des caractres ainsi que des lments avec leurs balises. Lorsqu'elle contient des lments, le fragment
doit tre bien form [Section 2.7.1]. toute balise ouvrante doit correspondre une balise fermante et l'imbrication
des balises doit tre correcte. Quelques exemples d'entits internes sons donns ci-dessous. Le dernier exemple
utilise des apostrophes ''' pour dlimiter le fragment de document qui contient des guillemets '"' pour encadrer
les valeurs des attributs.
<!ENTITY aka
"also known as">
<!ENTITY euro "€">
<!ENTITY rceil '<phrase condition="html">⌉</phrase>
<phrase condition="fo" role="symbolfont"></phrase>'>
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.
<price currency="Euro (€)">30 €</price>
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 [

<!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
3.5.1.4. Entits externes

Une entit peut dsigner un fragment de document contenu dans un autre fichier. Ce mcanisme permet de rpartir
un mme document sur plusieurs fichiers comme dans l'exemple suivant. La dclaration utilise alors le mot cl
SYSTEM suivi d'une URL qui peut, simplement, tre le nom d'un fichier local.
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.
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE book [

<!ENTITY chapter1 SYSTEM "chapter1.xml">
<!ENTITY chapter2 SYSTEM "chapter2.xml">
]>
<book>

&chapter1;

&chapter2;
</book>
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.
3.5.2. Entits paramtres

Les entits paramtres sont des entits qui peuvent uniquement tre utilises l'intrieur de la DTD. La
terminologie est historique et provient de SGML. Ces entits ont le mme rle que les entits gnrales. Elles
sont surtout utilises pour apporter de la modularit aux DTD. La dclaration d'une entit paramtre prend une
des trois formes suivantes o name est le nom de l'entit, fragment est un fragment de document, fpi et url
sont un FPI et une URL.
<!ENTITY % name "fragment">
<!ENTITY % name SYSTEM "url">
<!ENTITY % name PUBLIC "fpi" "url">
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 utilise 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.

<!ENTITY % idatt
"id ID #REQUIRED">
<!ENTITY % langatt "xml:lang NMTOKEN 'fr'">

<!ATTLIST chapter %idatt; %langatt;>
31
DTD
<!ATTLIST section %langatt;>

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.

<!ENTITY % main SYSTEM "main.dtd">

%main;
3.6. Dclaration d'lment

Les dclarations d'lments constituent le cur des DTD car elles dfinissent la structure des documents valides.
Elles spcifient quels doivent tre les enfants de chaque lment et l'ordre de ces enfants.
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.
<!ELEMENT element type>
3.6.1. Contenu pur d'lments

Le contenu d'un lment est pur lorsqu'il ne contient aucun texte et qu'il est uniquement constitu d'lments qui
sont ses enfants. Ces enfants peuvent, leur tour, avoir des contenus textuels, purs ou mixtes. Un lment de
contenu pur peut donc indirectement contenir du texte si celui-ci fait partie du contenu d'un de ses descendants.
La dclaration d'un lment de contenu pur dtermine quels peuvent tre ses enfants et dans quel ordre ils doivent
apparatre. Cette description est indpendante du contenu de ces enfants. Elle dpend uniquement des noms des
enfants. Le contenu de chaque enfant est dcrit par sa propre dclaration. Une dclaration d'lment prend la forme
suivante.
<!ELEMENT element regexp>
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
Tableau 3.2. Oprateurs des DTD

Ces dfinitions sont illustres par les exemples suivants.
<!ELEMENT elem (elem1, elem2, elem3)>
L'lment elem doit contenir un lment elem1, un lment elem2 puis un lment elem3 dans cet ordre.
<!ELEMENT elem (elem1 | elem2 | elem3)>
L'lment elem doit contenir un seul des lments elem1, elem2 ou elem3.
<!ELEMENT elem (elem1, elem2?, elem3)>
L'lment elem doit contenir un lment elem1, un ou zro lment elem2 puis un lment elem3 dans
cet ordre.
<!ELEMENT elem (elem1, elem2*, elem3)>
L'lment elem doit contenir un lment elem1, une suite ventuellement vide d'lments elem2 et un
lment elem3 dans cet ordre.
<!ELEMENT elem (elem1, (elem2 | elem4), elem3)>
L'lment elem doit contenir un lment elem1, un lment elem2 ou un lment elem4 puis un lment
elem3 dans cet ordre.
<!ELEMENT elem (elem1, elem2, elem3)*>
L'lment elem doit contenir une suite d'lments elem1, elem2, elem3, elem1, elem2, jusqu' un
lment elem3.
<!ELEMENT elem (elem1 | elem2 | elem3)*>
L'lment elem doit contenir une suite quelconque d'lments elem1, elem2 ou elem3.
<!ELEMENT elem (elem1 | elem2 | elem3)+>
L'lment elem doit contenir une suite non vide d'lments elem1, elem2 ou elem3.
3.6.1.1. Caractres d'espacement

La prise en compte des caractres d'espacement [Section 2.2.2] lors de validation d'un lment de contenu
pur dpend du caractre interne ou externe de la DTD et de la valeur de l'attribut standalone de l'entte
[Section 2.6.1]. Bien que le contenu d'un lment soit pur, il est, nanmoins, possible d'insrer des caractres
d'espacement entre ses enfants. La validation ignore ces caractres lorsque la DTD est interne ou lorsque la valeur
de l'attribut standalone est no. Ce traitement particulier rend possible l'indentation du document. Si la DTD
est externe et que la valeur de l'attribut standalone est yes, la validation devient stricte et elle n'autorise aucun
caractre d'espacement dans un contenu pur.
La DTD suivante dclare un lment list de contenu pur. Il contient une suite non vide d'lments item
contenant chacun du texte.

<!ELEMENT list (item)+>
<!ELEMENT item (#PCDATA)>
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

<!DOCTYPE list SYSTEM "standalone.dtd">
<list>
<item>Item 1</item>
<item>Item 2</item>
</list>
3.6.1.2. Contenu dterministe

Afin de simplifier la validation de documents, les expressions rationnelles qui dcrivent les contenus purs des
lments doivent tre dterministes. Cette contrainte signifie qu'en cours d'analyse du contenu, le nom d'un lment
ne peut apparatre que sur une seule branche de l'expression. Un exemple typique d'expression ne respectant pas
cette rgle est la suivante.
<!ELEMENT item ((item1, item2) | (item1, item3))>
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.
<!ELEMENT item (item1, (item2 | item3))>
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.
<!ELEMENT item ((item1, item2)*, item1)>
3.6.2. Contenu textuel

La dclaration de la forme suivante indique qu'un lment peut uniquement contenir du texte. Ce texte est form
de caractres, d'entits qui seront remplaces au moment du traitement et de sections littrales [Section 2.7.2].
<!ELEMENT element (#PCDATA)>
Dans l'exemple suivant, l'lment text est de type #PCDATA.
<!DOCTYPE texts [
<!ELEMENT texts (text)*>
<!ELEMENT text (#PCDATA)>
]>
<texts>
<text>Du texte simple</text>
<text>Une <![CDATA[ Section CDATA avec < et > ]]></text>
<text>Des entits < et ></text>
</texts>
3.6.3. Contenu mixte

La dclaration de la forme suivante indique qu'un lment peut uniquement contenir du texte et les lments
element1, , elementN. C'est la seule faon d'avoir un contenu mixte avec du texte et des lments. Il n'y a
aucun contrle sur le nombre d'occurrences de chacun des lments et sur leur ordre d'apparition dans le contenu
de l'lment ainsi dclar. Dans une telle dclaration, le mot cl #PCDATA doit apparatre en premier avant tous
les noms des lments.
<!ELEMENT element (#PCDATA | element1 | ... | elementN)*>
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.
<!DOCTYPE book [
<!ELEMENT book (#PCDATA | em | cite)*>
<!ELEMENT em
(#PCDATA)>
<!ELEMENT cite (#PCDATA)>
]>
<book>
Du <em>texte</em>, une <cite>citation</cite> et encore du <em>texte</em>.
</book>
3.6.4. Contenu vide

La dclaration suivante indique que le contenu de l'lment element est ncessairement vide. Cet lment peut
uniquement avoir des attributs. Les lments vides sont souvent utiliss pour des liens entre lments.
<!ELEMENT element EMPTY>
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].
<!ELEMENT ref EMPTY>
<!ATTLIST ref idref IDREF #REQUIRED>
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.
3.6.5. Contenu libre

La dclaration suivante n'impose aucune contrainte sur le contenu de l'lment element. En revanche, ce contenu
doit, bien entendu, tre bien form et les lments contenus doivent galement tre dclars. Ce type de dclarations
permet de dclarer des lments dans une DTD en cours de mise au point afin de procder des essais de validation.
En revanche, ces dclarations sont dconseilles dans une DTD termine car elles conduisent des modles de
document trop laxistes.
<!ELEMENT element ANY>
3.7. Dclaration d'attribut

Pour qu'un document soit valide, tout attribut prsent dans la balise ouvrante d'un lment doit tre dclar. La
dclaration d'attribut prend la forme gnrale suivante o attribut est le nom de l'attribut et element le
nom de l'lment auquel il appartient. Cette dclaration comprend galement le type type et la valeur par dfaut
default de l'attribut. Le nom de l'attribut doit tre un nom XML [Section 2.2.3].
<!ATTLIST element attribut type default>
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.
<!ATTLIST element attribut1 type1 default1
attribut2 type2 default2
...
attributN typeN defaultN>
Les diffrents types possibles pour un attribut ainsi que les valeurs par dfaut autorises sont dtaills dans les
sections suivantes.
35
DTD
3.7.1. Types des attributs

Le type d'un attribut dtermine quelles sont ses valeurs possibles. Les DTD proposent uniquement un choix fini
de types pour les attributs. Le type doit en effet tre pris dans la liste suivante. Les types les plus utiliss sont
CDATA, ID et IDREF.
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.
(value-1 | value-2 | ... | value-N)
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.
3.7.2. Attributs de type ID, IDREF et IDREFS

Il est frquent qu'il existe des liens entre les donnes d'un document XML. Il peut s'agir, par exemple, de rfrences
d'autres parties du document. Les attributs de types ID, IDREF et IDREFS s'utilisent conjointement pour
matrialiser ces liens au sein d'un document. Un attribut de type ID permet d'identifier de faon unique un lment
du document. Les lments ainsi identifis peuvent alors tre rfrencs par d'autres lments grce aux attributs de
types IDREF et IDREFS. Ces attributs crent ainsi des liens entre des lments ayant les attributs de types IDREF
ou IDREFS et des lments ayant les attributs de type ID. Ce mcanisme permet uniquement de crer des liens
entre des lments d'un mme document. La norme XLink gnralise ce mcanisme. Elle permet de crer des liens
entre deux, voire mme plus de fragments de documents XML provenant ventuellement de documents diffrents.
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.
<!DOCTYPE book [
<!ELEMENT book
(section)*>
<!ELEMENT section (#PCDATA | ref | refs)*>
<!ATTLIST section id ID #IMPLIED>
<!ELEMENT ref
EMPTY>
<!ATTLIST ref
idref IDREF #REQUIRED>
<!ELEMENT refs
EMPTY>
<!ATTLIST refs
idrefs IDREFS #REQUIRED>
]>
<book>
<section id="sec0">Une rfrence <ref idref="sec1"/></section>
<section id="sec1">Des rfrences <refs idrefs="sec0 sec2"/></section>
<section id="sec2">Section sans rfrence</section>
<section id="sec3">Une auto-rfrence <refs idrefs="sec3"/></section>
</book>
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.
<bibliography>
<books>
<title>XML langage et appplications</title>
<year>2001</year>
<isbn>2-212-09206-7</isbn>
<published by="id2680397"/>
</book>
37
DTD
<book key="Marchal00" lang="en">

<title>XML by Example</title>
<author>Benot Marchal</author>
<year>2000</year>
<isbn>0-7897-2242-9</isbn>
<published by="id2680427"/>
</book>
...
</books>
<publishers>
<publisher id="id2680397">
<name>Eyrolles</name>
<address>Paris</address>
</publisher>
<publisher id="id2680427">
<name>Macmillan Computer Publishing</name>
<address>New York</address>
</publisher>
...
</publishers>
</bibliography>
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 xml:ID [Section 5.5.1.4] en fait).
3.7.3. Valeur par dfaut

Chaque dclaration d'attribut prcise une valeur par dfaut pour celui-ci. Cette valeur par dfaut peut prendre une
des quatre formes suivantes.
"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.
#FIXED "value" ou #FIXED 'value'
La valeur value est une chane quelconque de caractres dlimite par des apostrophes ''' ou des
guillemets '"'. La valeur de l'attribut est fixe la valeur value donne. Si l'attribut est absent, sa valeur
est implicitement value. Si l'attribut est prsent, sa valeur doit tre value pour que le document soit valide.
Cette valeur doit, bien sr, tre du type donn l'attribut.
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
<!ATTLIST tag meta CDATA "default">

La valeur de l'attribut meta peut tre une chane quelconque et sa valeur par dfaut est la chane default Les
exemples illustrent l'utilisation des entits prdfinies [Section 3.5.1.2] pour inclure des caractres spciaux
dans les valeurs d'attribut.
Attribut dans le document
Valeur
<tag meta="Hello World!">
Hello World!
<tag>
Valeur par dfaut default
<tag meta="">
Chane vide
<tag meta="=='"==">
=='"==
<tag meta='=='"=='>
=='"==
<tag meta="==<&>==">
==<&>==
<tag meta="==<&&#62==">
==<&>==
<!ATTLIST book lang (fr | en) "fr">

La valeur de l'attribut lang peut tre soit le jeton fr soit le jeton en et sa valeur par dfaut est le jeton fr.
Valeur
<book>
Valeur par dfaut fr
<book lang="fr">
Valeur par dfaut fr
<book lang="en">
Jeton en
<book lang="de">
non valide car la valeur de n'est pas numre
<!ATTLIST book name NMTOKEN #IMPLIED>

L'attribut name est optionnel et sa valeur doit tre un jeton. Il n'a pas de valeur par dfaut.
Valeur
<book>
Pas de valeur
<book name="en">
Jeton en
<book name="-id234"/>
Jeton -id234
<book name="Hello World!">
non valide car Hello World! n'est pas un jeton
<!ATTLIST entry id ID #REQUIRED>

L'attribut id est obligatoire et sa valeur doit tre un nom unique. Il n'a pas de valeur par dfaut.
Valeur
<entry>
non valide attribut absent
<entry id="id-234">
Nom id-234
<entry id="Hello World!">
non valide car Hello World! n'est pas un nom
<!ATTLIST xref ref IDREF #REQUIRED>

L'attribut ref est obligatoire et sa valeur doit tre un nom XML. Pour que le document soit valide, ce nom
doit tre la valeur d'un attribut de type ID d'un (autre) lment. Cet attribut n'a pas de valeur par dfaut.
Valeur
<xref ref="id-234"/>
id-234
<xref ref="-id234"/>
non valide car -id234 n'est pas nom.
<!ATTLIST xrefs refs IDREFS #REQUIRED>

L'attribut refs est obligatoire et sa valeur doit tre une suite de noms XML spars par des espaces. Pour
que le document soit valide, chacun des noms de la liste doit tre la valeur d'un attribut de type ID d'un (autre)
lment. Il n'a pas de valeur par dfaut.
39
DTD
Valeur
<xrefs refs="id-234"/>
Nom id-234
<xrefs refs="id-234 id-437"/>
Noms id-234 et id-437
<!ATTLIST rule style CDATA #FIXED "free">

La valeur de l'attribut style de l'lment rule est fixe la valeur free.
Valeur
<rule>
Valeur fixe free
<rule style="free">
Valeur fixe free
<rule style="libre">
non valide car valeur diffrente
3.8. Outils de validation

Il existe plusieurs outils permettant de valider un document XML par rapport une DTD. Il existe d'abord des sites
WEB dont l'avantage est une interface conviviale. L'utilisateur peut fournir son document par un simple copier/
coller ou en le tlchargeant. Comme la validation est ralise sur une machine distante, la DTD doit tre, soit
accessible via une URL, soit directement incluse dans document.
Page de validation du W3C [http://validator.w3.org/]
Page de validation du Scholarly Technology Group de l'universit de Brown [http://www.stg.brown.edu/service/
xmlvalid/]
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 celuici. 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.
<book version="5.0" xml:lang="fr"
xmlns:dc="http://purl.org/dc/elements/1.1/"

<title>Langages formels, calculabilit et complexit</title>

<metadata>
<dc:title>Langages formels, calculabilit et complexit</dc:title>
<dc:creator>Olivier Carton</dc:creator>
<dc:date>2008-10-01</dc:date>
<dc:identifier>urn:isbn:978-2-7117-2077-4</dc:identifier>
</metadata>


href="introduction.xml" parse="xml"/>
href="chapter1.xml"
parse="xml"/>
href="chapter2.xml"
parse="xml"/>
href="chapter3.xml"
parse="xml"/>
href="chapter4.xml"
parse="xml"/>
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
4.2. Identification d'un espace de noms

Un espace de noms est identifi par un URI [Section 2.3] appel URI de l'espace de noms. Cet URI est trs souvent
une URL mais il est sans importance que l'URL pointe rellement sur un document. Cet URI garantit seulement
que l'espace de noms soit identifi de manire unique. Dans la pratique, l'URL permet aussi souvent d'accder
un document qui dcrit l'espace de noms. Une liste [Section 4.9] des URI identifiant les principaux espaces de
noms est donne la fin du chapitre.
4.3. Dclaration d'un espace de noms

Un espace de noms est dclar par un pseudo attribut dont le nom prend la forme xmlns:prefix o prefix
est un nom XML [Section 2.2.3] ne contenant pas le caractre ':'. La valeur de ce pseudo attribut est l'URI qui
identifie l'espace de noms. La dclaration associe cet URI au nom prefix. Ce prfixe est ensuite utilis pour
qualifier les noms d'lments. Bien que la dclaration d'un espace de noms se prsente comme un attribut, celleci n'est pas considre comme un attribut. Le langage XPath distingue, par exemple, les attributs des dclarations
d'espaces de noms. Ces dernires sont manipules par des fonctions spcifiques [Section 6.1.1.2] de XPath.
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: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">

<foo:firstname>Gaston<foo:firstname>
<bar:surname>Lagaffe<bar:surname>
</name>
4.4. Porte d'une dclaration

La porte d'une dclaration d'un espace de noms est l'lment dans lequel elle est faite. L'exemple prcdent aurait
pu aussi tre crit de la manire suivante. Il faut remarquer que la porte de la dclaration comprend les balises
de l'lment qui la contient. Il est ainsi possible d'utiliser le prfixe html dans l'lment html pour obtenir le
nom qualifi html:html.
<html:html xmlns:html="http://www.w3.org/1999/xhtml">
<html:head>
</html:head>
<html:body>
...
<mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML">
<mml:apply>
<mml:eq/>
...
</mml:apply>
</mml:math>

...
</html:body>
</html:html>
4.5. Espace de noms par dfaut

Il existe un espace de noms par dfaut associ au prfixe vide. Son utilisation permet d'allger l'criture des
documents XML en vitant de mettre un prfixe aux lments les plus frquents. Lorsque plusieurs espaces de
noms coexistent au sein d'un document, il faut, en gnral, rserver l'espace de noms par dfaut l'espace de noms
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">

<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>

...
</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.

<head>
</head>
<body>
...
<math xmlns="http://www.w3.org/1998/Math/MathML">

<apply>
<eq/>
...
</apply>
</math>

...
</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.


<head>
</head>
<body>
44
Espaces de noms
...
<name xmlns="">


<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.
<bibliography xsi:noNamespaceSchemaLocation="bibliography.xsd"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
...
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">
4.7. Espace de noms XML

Le prfixe xml est toujours implicitement li l'espace de noms XML identifi par l'URI http://
www.w3.org/XML/1998/namespace. Cet espace de noms n'a pas besoin d'tre dclar. Les quatre attributs
particuliers [Section 2.7.4] xml:lang, xml:space, xml:base et xml:id font partie de cet espace de noms.
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.
4.8. Espaces de noms et DTD

Les DTD ne prennent pas compte les espaces de noms. Il est cependant possible de valider, avec une DTD, un
document avec des espaces de noms au prix de quelques entorses l'esprit des espaces de noms. Il y a, en effet,
quelques contraintes. D'une part, la dclaration d'espace de noms est vue comme un attribut de nom commenant
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.liafa.jussieu.fr/~carton/ qui est associ au prfixe tns.
<!DOCTYPE list SYSTEM "valid.dtd">
<tns:list xmlns:tns="http://www.liafa.jussieu.fr/~carton/">
<tns:item>Item 1</tns:item>
<tns:item>Item 2</tns:item>
</tns:list>
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.

<!ELEMENT tns:list (tns:item)+>
<!ATTLIST tns:list xmlns:tns CDATA #REQUIRED>
<!ELEMENT tns:item (#PCDATA)>
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.
<!DOCTYPE list SYSTEM "valid.dtd">
<ons:list xmlns:ons="http://www.liafa.jussieu.fr/~carton/">
<ons:item>Item 1</ons:item>
<ons:item>Item 2</ons:item>
</ons:list>
4.9. Quelques espaces de noms classiques

XML [Section 4.7]
http://www.w3.org/XML/1998/namespace
XInclude [Section 2.9]
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
SVG [Chapitre 11]
http://www.w3.org/2000/svg
Schmas [Chapitre 5]
http://www.w3.org/2001/XMLSchema
Instances de schmas [Section 5.3.2]
http://www.w3.org/2001/XMLSchema-instance
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
DocBook [Section 1.5]
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.
5.1.1. Comparaison avec les DTD

La premire diffrence entre les schmas et les DTD est d'ordre syntaxique. La syntaxe des DTD est une syntaxe
hrite de SGML qui est diffrente de la syntaxe XML pour le corps des documents. En revanche, la syntaxe
des schmas est une syntaxe purement XML. Un schma est, en effet, un document XML part entire avec un
lment racine xsd:schema et un espace de noms.
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.

Voici un exemple de schma XML dfinissant le type de document de la bibliographie [bibliography.xml]. Ce
schma est volontairement rudimentaire pour un premier exemple. Il n'est pas trs prcis sur les contenus de
certains lments. Un exemple plus complet pourrait tre donn pour la bibliographie.
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:annotation>
<xsd:documentation xml:lang="fr">
Schma XML pour bibliography.xml
</xsd:documentation>
</xsd:annotation>
<xsd:element name="bibliography" type="Bibliography"/>
<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.
5.3. Structure globale d'un schma

Un schma XML se compose essentiellement de dclarations d'lments et d'attributs et de dfinitions de types.
Chaque lment est dclar avec un type qui peut tre, soit un des types prdfinis, soit un nouveau type dfini
dans le schma. Le type spcifie quels sont les contenus valides de l'lment ainsi que ses attributs. Un nouveau
type est obtenu soit par construction, c'est--dire une description explicite des contenus qu'il autorise, soit par
drivation, c'est--dire modification d'un autre type. Un schma peut aussi contenir des imports d'autres schmas,
des dfinitions de groupes d'lments et d'attributs et des contraintes de cohrences.
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.

...
</xsd:schema>
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.
5.3.1. Attributs de l'lment xsd:schema

L'lment racine xsd:schema peut avoir les attributs suivants. Ceux-ci permettent de spcifier l'espace de noms
cible du schma et de prciser quelques comportements par dfaut du schma.
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.liafa.jussieu.fr/~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.
<xsd:schema targetNamespace="http://www.liafa.jussieu.fr/~carton"
elementFormDefault="qualified"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.liafa.jussieu.fr/~carton">
...
5.3.2. Rfrence explicite un schma

Il est possible dans un document de donner explicitement le schma devant servir le valider. On utilise un
des attributs schemaLocation ou noNamespaceSchemaLocation dans l'lment racine du document
valider. Ces deux attributs se trouvent dans l'espace de noms des instances de schmas identifi par l'URI
http://www.w3.org/2001/XMLSchema-instance. L'attribut schemaLocation est utilis lors de
l'utilisation d'espaces de noms alors que l'attribut noNamespaceSchemaLocation est utilis lorsque le
document n'utilise pas d'espace de noms
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
schemaLocation="namespace1 schema1 namespace2 ... namespaceN schemaN"
o namespacei est l'espace de noms cible du schma schemai.
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.liafa.jussieu.fr/
~carton/.
<bibliography xsi:schemaLocation="http://www.liafa.jussieu.fr/~carton/
bibliography.xsd"
...
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>
5.4. Dclarations d'lments

Pour qu'un document soit valide pour un schma, tout lment apparaissant dans le document doit tre dclar
dans le schma. Cette dclaration lui donne un type qui dtermine, d'une part, les contenus possibles et, d'autres
part, les attributs autoriss et obligatoires. Contrairement aux DTD, les attributs ne sont pas directement associs
aux lments. Ils font partie des types qui sont donns aux lments.
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.
5.4.1. Type nomm

La dclaration la plus simple d'un lment prend la forme suivante.
<xsd:element name="element" type="type"/>
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="title" type="xsd:string"/>
<xsd:element name="title" type="tns:Title"/>
5.4.2. Valeur par dfaut et valeur fixe

Lorsque le type est simple, il est possible de donner une valeur par dfaut ou une valeur fixe l'lment comme dans
les deux exemples suivants. Il faut pour cela donner des valeurs aux attributs default ou fixed de l'lment
xsd:element.
<xsd:element name="title" type="xsd:string" default="Titre par dfaut"/>
<xsd:element name="title" type="xsd:string" fixed="Titre fixe"/>
5.4.3. Type anonyme

Lors de la dclaration d'un lment, il est possible de dcrire explicitement le type. La dclaration du type est alors
le contenu de l'lment xsd:element. Le type est alors local et sa dclaration prend alors une des deux formes
suivantes o element est le nom de l'lment dclar.
<xsd:element name="element">
<xsd:simpleType>
...
</xsd:simpleType>
</xsd:element>
<xsd:element name="element">
52
Schmas XML
<xsd:complexType>
...
</xsd:complexType>
</xsd:element>
5.4.4. Rfrence un lment global

Un lment global, c'est--dire dont la dclaration par xsd:element est enfant direct de l'lment
xsd:schema, peut tre utilis par des dfinitions de type. Ces dfinitions de type se contentent de faire rfrence
l'lment global de la faon suivante. Ce mcanisme permet une certaine modularit dans l'criture des schmas
puisqu'il vite des rptitions.

<xsd:element name="title" type="Title"/>
...

<xsd:complexType ... >
...

<xsd:element ref="title"/>
...
</xsd:complexType>
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.
5.4.5. lments locaux

Deux lments dfinis non globalement dans un schma peuvent avoir le mme nom tout en ayant des types
diffrents. Il s'agit en fait d'lments diffrents mais ayant le mme nom. Cette possibilit est absente des DTD
o tous les lments sont globaux et ne peuvent avoir qu'un seul type. Le schma suivant dfinit deux lments
de mme nom local mais de types xsd:string et xsd:integer. Le premier lment apparat uniquement
dans le contenu de l'lment strings alors que le second apparat uniquement dans le contenu de l'lment
integers. C'est donc le contexte qui permet de distinguer les deux lments de nom local.
...
<xsd:element name="strings">
<xsd:complexType>
<xsd:sequence>

<xsd:element name="local" type="xsd:string" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="integers">
<xsd:complexType>
<xsd:sequence>

<xsd:element name="local" type="xsd:integer" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
Un document valide pour le schma prcdent est le suivant.
53
Schmas XML

<lists>
<strings>
<local>Une chane</local>
<local>A string</local>
</strings>
<integers>
<local>-1</local>
<local>1</local>
</integers>
</lists>
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].
5.5. Dfinitions de types

Parmi les types, les schmas XML distinguent les types simples introduits par le constructeur xsd:simpleType
et les types complexes introduits par le constructeur xsd:complexType. Les types simples dcrivent des
contenus textuels, c'est--dire ne contenant que du texte. Ils peuvent tre utiliss pour les lments comme pour
les attributs. Ils sont gnralement obtenus par drivation des types prdfinis. Au contraire, les types complexes
dcrivent des contenus purs constitus uniquement d'lments ou des contenus mixtes constitus de texte et
d'lments. Ils peuvent uniquement tre utiliss pour dclarer des lments. Seuls les types complexes peuvent
dfinir des attributs.
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.

<xsd:element name="object"/>
x s d : a n y Ty p e
x s d : c o mp l e x Ty p e
x s d : s i mp l e Ty p e
x s d : a n y At o mi c Ty p e
xs d: l i s t
xs d: uni on
xs d: e xt e ns i on
xs d: r e s t r i c t i on
xs d: s e que nc e
xs d: c hoi c e
xs d: a l l
Figure 5.1. Hirarchie de construction des types
5.5.1. Types prdfinis

54
xs d: e xt e ns i on
xs d: r e s t r i c t i on
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.
5.5.1.1. Types numriques

Beaucoup de types numriques sont prdfinis pour les nombres entiers et flottants. Certains types comme
xsd:int ou xsd:double correspondent un codage prcis et donc une prcision fixe alors que d'autres
types comme xsd:integer ou xsd:decimal autorisent une prcision arbitraire. Ces derniers types sont
privilgier sauf quand le schma dcrit des donnes avec un codage bien dtermin.
xsd:boolean
Valeur boolenne avec true ou 1 pour vrai et false ou 0 pour faux
xsd:byte
Nombre entier sign sur 8 bits
xsd:unsignedByte
Nombre entier non sign sur 8 bits
xsd:short
xsd:unsignedShort
xsd:int
xsd:unsignedInt
xsd:long
Nombre entier sign sur 64 bits. Ce type drive du type xsd:integer.
xsd:unsignedLong
xsd:integer
Nombre entier sans limite de prcision. Ce type n'est pas primitif et drive du type xsd:decimal.
xsd:positiveInteger
Nombre entier strictement positif sans limite de prcision
xsd:negativeInteger
Nombre entier strictement ngatif sans limite de prcision
xsd:nonPositiveInteger
55
Schmas XML
Nombre entier ngatif ou nul sans limite de prcision

xsd:nonNegativeInteger
Nombre entier positif ou nul sans limite de prcision
xsd:float
Nombre flottant sur 32 bits conforme la norme IEEE 754 [ ]
xsd:double
Nombre flottant sur 64 bits conforme la norme IEEE 754 [ ]
xsd:decimal
Nombre dcimal sans limite de prcision
5.5.1.2. Types pour les chanes et les noms

Les schmas possdent bien sr un type pour les chanes de caractres ainsi que quelques types pour les noms
qualifis et non qualifis.
xsd:string
Chane de caractres compose de caractres Unicode
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
Nom XML [Section 2.2.3]
xsd:QName
Nom qualifi [Chapitre 4]
xsd:NCName
Nom non qualifi [Chapitre 4], c'est--dire sans caractre ':'
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
Un URI comme http://www.liafa.jussieu.fr/~carton/. C'est le type de l'attribut particulier
xml:base [Section 2.7.4.3].
xsd:base64Binary
Donnes binaires reprsentes par une chane au format Base 64.
56
Schmas XML
xsd:hexBinary
Donnes binaires reprsentes par une chane au format Hex.
Les 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.
5.5.1.3. Types pour les dates et les heures

Quelques types des schmas imposent des formats standards pour crire les dates et les heures. Ils s'appuient sur
la norme ISO 8601. Leur grand intrt est d'imposer une criture normalise pour les dates et les heures et d'en
faciliter ainsi le traitement.
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
Date et heure au format YYYY-MM-DDThh:mm:ss comme 2008-01-16T14:07:23. Tous les champs
sont obligatoires.
xsd:duration
Dure au format PnYnMnDTnHnMnS comme P1Y6M, P1M12DT2H et P1YD3H10S.
xsd:dayTimeDuration
Dure au format PnDTnHnMnS comme P7DT4H3M2S.
xsd:yearMonthDuration
Dure au format PnYnM comme P1Y6M.
xsd:gYear
Anne du calendrier grgorien au format YYYY comme 2011.
xsd:gYearMonth
Anne et mois du calendrier grgorien au format YYYY-MM comme 1966-06 pour juin 1966.
xsd:gMonth
Mois du calendrier grgorien au format MM comme 01 pour janvier.
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.
xs d: bool e a n
x s d : d e c i ma l
xs d: doubl e
xs d: f l oa t
xs d: s t r i ng
x s d : d a t e Ti me
xs d: da t e
x s d : n o r ma l i z e d St r i n g
xs d: i nt e ge r
x s d : y e a r Mo n t h Du r a t i o n
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 URI
x s d : g Ye a r
x s d : QNa me
x s d : g Ye a r Mo n t h
Figure 5.2. Hirarchie des types atomiques
58
x s d : b a s e 6 4 Bi n a r y
x s d : g Mo n t h
xs d: dur a
x s d : d a y Ti me Du r a t i o n
xs d: t oke n
x s d : n o n Po s i t i v e I n t e g e r
x s d : t i me
x s d : g Mo n t h Da y
x s d : h e x Bi n a r y
x s d : g Da y
Schmas XML
5.5.1.4. Types hrits des DTD

Les schmas XML reprennent certains types des DTD [Section 3.7.1] pour les attributs. Ces types facilitent la
traduction automatique des DTD en schmas. Pour des raisons de compatibilit, ces types sont rservs aux
attributs.
xsd:ID
nom XML identifiant un lment [Section 3.7.2]
xsd:IDREF
rfrence un lment par son identifiant [Section 3.7.2]
xsd:IDREFS
liste de rfrences des lments par leurs identifiants [Section 3.7.2]
xsd:NMTOKEN
jeton [Section 2.2.3]
xsd:NMTOKENS
liste de jetons [Section 2.2.3] separs par des espaces
xsd:ENTITY
entit externe non XML
xsd:ENTITIES
liste d'entits externes non XML separs par des espaces
xsd:NOTATION
notation
5.5.2. Types simples

Les types simples dfinissent uniquement des contenus textuels. Ils peuvent tre utilis pour les lments ou les
attributs. Ils sont introduits par l'lment xsd:simpleType. Un type simple est souvent obtenu par restriction
d'un autre type dfini. Il peut aussi tre construit par union d'autres types simples ou par l'oprateur de listes. La
dclaration d'un type simple a la forme suivante.
<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>
5.5.3. Types complexes

Les types complexes dfinissent des contenus purs (constitus uniquement d'lments), des contenus textuels ou
des contenus mixes. Tous ces contenus peuvent comprendre des attributs. Les types complexes peuvent seulement
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].
59
Schmas XML
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.

<xsd:complexType ...>

...
</xsd:complexType>
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.

<xsd:simpleContent>

...
</xsd:simpleContent>
</xsd:complexType>

<xsd:complexContent>

...
</xsd:complexContent>
</xsd:complexType>
5.5.4. Contenu mixte

Le contenu d'un lment est pur lorsqu'il ne contient que des lments qui, eux-mmes, peuvent leur tour
contenir du texte et/ou des lments. Il est, au contraire, mixte lorsqu'il contient du texte autre que des caractres
d'espacement en dehors de ses enfants. La construction de types pour les contenus mixtes est trs facile et trs
souple avec les schmas. L'attribut mixed de l'lment xsd:complexType permet de construire un type avec
du contenu mixte. Il faut, pour cela, lui donner la valeur true.
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
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.
60
Schmas XML
<person>
Prnom : <firstname>Albert</firstname>,
Nom : <lastname>Einstein</lastname>.
</person>
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>
L'exemple prcdent est quivalent au fragment suivant de DTD.
<!ELEMENT book (#PCDATA | em | cite)* >
5.6. Constructions de types

Les constructeurs de types permettent de dfinir des nouveaux types en combinant des types dj dfinis. Ils sont
en fait assez semblables aux diffrents oprateurs des DTD [Section 3.6.1].
5.6.1. lment vide

Si un type complexe dclare uniquement des attributs, le contenu de l'lment doit tre vide. Par exemple, le type
suivant dclare un type Link. Tout lment de ce type doit avoir un contenu vide et un attribut ref de type
xsd:IDREF.
<xsd:element name="link" type="Link"/>
<xsd:complexType name="Link">
<xsd:attribute name="ref" type="xsd:IDREF" use="required"/>
</xsd:complexType>
Le fragment de document suivant est valide pour le schma prcdent.
<link ref="id-42"/>
5.6.2. Oprateur de squence

L'oprateur xsd:sequence dfinit un nouveau type form d'une suite des lments numrs. C'est l'quivalent
de l'oprateur ',' des DTD [Section 3.6.1]. Les lments numrs peuvent tre soit des lments explicites,
soit des lments rfrencs avec l'attribut ref soit des types construits rcursivement avec les autres oprateurs.
Dans l'exemple suivant, un lment book doit contenir les lments title, author, year et publisher
dans cet ordre.
<xsd:complexType>
<xsd:sequence>
<xsd:element name="publisher"
</xsd:sequence>
</xsd:complexType>
type="xsd:string"/>
type="xsd:string"/>
type="xsd:string"/>
type="xsd:string"/>
61
Schmas XML
</xsd:element>
Cette dclaration est quivalente la dclaration suivante dans une DTD.
<!ELEMENT book (title, author, year, publisher)>
Le fragment de document ci-dessous est valide pour la dclaration de l'lment book.
<book>
<year>2001</year>
</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].
5.6.3. Oprateur de choix

L'oprateur xsd:choice dfinit un nouveau type form d'un des lments numrs. C'est l'quivalent de
l'oprateur '|' des DTD [Section 3.6.1]. Dans l'exemple suivant, le contenu de l'lment publication doit
tre un des lments book, article ou report. Ces trois lments sont rfrencs et doivent donc tre dfinis
globalement dans le schma.
<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>
Cette dclaration est quivalente la dclaration suivante dans une DTD.
<!ELEMENT publication (book | article | report)>
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].
<xsd:element name="book" minOccurs="1" maxOccurs="unbounded">
<xsd:complexType>
<xsd:sequence>
<xsd:choice>
<xsd:element name="author" type="xsd:string"/>
<xsd:element name="authors">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="author" type="xsd:string"
minOccurs="2" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
62
Schmas XML
</xsd:choice>
<xsd:element name="year" type="xsd:string"/>
...
</xsd:sequence>
Le document suivant est valide pour le schma prcdent.
<bibliography>

<year>2001</year>
</book>

<book key="ChagnonNolot07" lang="fr">
<title>XML</title>
<authors>
<author>Gilles Chagnon</author>
<author>Florent Nolot</author>
</authors>
<year>2007</year>
<publisher>Pearson</publisher>
</book>
</bibliography>
5.6.4. Oprateur d'ensemble

L'oprateur xsd:all n'a pas d'quivalent dans les DTD. Il dfinit un nouveau type dont chacun des lments doit
apparatre une fois dans un ordre quelconque. Dans la dclaration ci-dessous, les lments contenus dans l'lment
book peuvent apparatre dans n'importe quel ordre.
<xsd:complexType>
<xsd:all>
</xsd:all>
</xsd:complexType>
</xsd:element>
type="xsd:string"/>
type="xsd:string"/>
type="xsd:string"/>
type="xsd:string"/>
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.
<bibliography>
<year>2001</year>
</book>
<book key="Zeldman03" lang="en">
63
Schmas XML
<year>2003</year>
</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:complexType>
<xsd:all minOccurs="0">
</xsd:all>
</xsd:complexType>
</xsd:element>
type="xsd:string"/>
type="xsd:string"/>
type="xsd:string"/>
type="xsd:string"/>
5.6.5. Oprateur d'union

L'oprateur xsd:union dfinit un nouveau type simple dont les valeurs sont celles des types lists dans l'attribut
memberTypes.
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.
<xsd:attribute name="maxOccurs" type="IntegerOrUnbounded"/>
<xsd:simpleType name="IntegerOrUnbounded">
<xsd:union memberTypes="xsd:nonNegativeInteger Unbounded"/>
</xsd:simpleType>
<xsd:simpleType name="Unbounded">
<xsd:restriction base="xsd:string">
<xsd:enumeration value="unbounded"/>
</xsd:restriction>
</xsd:simpleType>
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.
<xsd:simpleType name="IntegerOrUnbounded">
<xsd:union memberTypes="xsd:nonNegativeInteger">
<xsd:simpleType>
64
Schmas XML
<xsd:enumeration value="unbounded"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:union>
</xsd:simpleType>
5.6.6. Oprateur de liste

L'oprateur xsd:list dfinit un nouveau type simple dont les valeurs sont les listes de valeurs du type
simple donn par l'attribut itemType. Il ne s'agit pas de listes gnrales comme dans certains langages de
programmation. Il s'agit uniquement de listes de valeurs spares par des espaces. Ces listes sont souvent utilises
comme valeurs d'attributs. Les valeurs du type simple donn par itemType ne peuvent pas comporter de
caractres d'espacement [Section 2.2.2] qui perturberaient la sparation entre les valeurs. L'exemple suivant dfinit
des types pour les listes d'entiers et pour les listes de 5 entiers.

<xsd:simpleType name="IntList">
<xsd:list itemType="xsd:integer"/>
</xsd:simpleType>

<xsd:simpleType name="IntList5">
<xsd:restriction base="IntList">
<xsd:length value="5"/>
</xsd:restriction>
</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
<!ELEMENT elem (elem1, elem2?, elem3*) >
<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>
<!ELEMENT elem (elem1, (elem2 | elem3)?, elem4) >
<xsd:complexType>
<xsd:sequence>
<xsd:choice minOccurs="0">
65
Schmas XML
</xsd:choice>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<!ELEMENT elem (elem1, elem2, elem3)* >
<xsd:complexType>
<xsd:sequence minOccurs="0" maxOccurs="unbounded">
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<!ELEMENT elem (elem1 | elem2 | elem3)* >
<xsd:complexType>
<xsd:choice minOccurs="0" maxOccurs="unbounded">
</xsd:choice>
</xsd:complexType>
</xsd:element>
<!ELEMENT elem (elem1, elem2, elem3)+ >
<xsd:complexType>
<xsd:sequence minOccurs="1" maxOccurs="unbounded">
</xsd:sequence>
</xsd:complexType>
</xsd:element>
5.6.8. Joker xsd:any

L'oprateur xsd:any permet d'introduire dans un document un ou des lments externes au schma, c'est-dire non dfinis dans le schma. Le nombre d'lments externes autoriss peut-tre spcifi avec les attributs
minOccurs et maxOccurs [Section 5.6.7]. La validation de ces lments externes est contrle par l'attribut
processContents qui peut prendre les valeurs strict, lax et skip. La valeur par dfaut est strict.
Lorsque la valeur est strict, les lments externes doivent tre valids par un autre schma dtermin par
l'espace de noms de ces lments pour que le document global soit valide. Lorsque la valeur est skip, les lments
externes ne sont pas valids. La valeur lax est intermdiaire entre strict et skip. La validation des lments
externes est tente mais elle peut chouer.
Le schma suivant autorise zro ou un lment externe dans le contenu de l'lment person aprs l'lment
lastname.
66
Schmas XML
<xsd:complexType>
<xsd:sequence>
<xsd:any processContents="lax" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<person>
<firstname>Elizabeth II Alexandra Mary</firstname>
<lastname>Windsor</lastname>
<title>Queen of England</title>
</person>
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.
<xsd:complexType>
<xsd:sequence>
<xsd:any processContents="lax" namespace="http://www.w3.org/1999/xhtml"
minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<person>
<firstname>Victor</firstname>
<lastname>Hugo</lastname>
<html:ul xmlns:html="http://www.w3.org/1999/xhtml">
<html:li>Romancier</html:li>
<html:li>Pote</html:li>
<html:li>Dramaturge</html:li>
</html:ul>
</person>
Il existe galement un lment xsd:anyAttribute [Section 5.7.4] pour autoriser des attributs externes au
schma.
67
Schmas XML
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.
<xsd:element name="item">
<xsd:complexType>
<xsd:choice>
<xsd:sequence>
<xsd:element name="item1" type="xsd:string"/>
</xsd:sequence>
<xsd:sequence>
</xsd:sequence>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
5.7. Dclarations d'attributs

La dclaration d'un attribut est semblable la dclaration d'un lment mais elle utilise l'lment
xsd:attribute au lieu de l'lment xsd:element. Les attributs name et type de xsd:attribute
spcifient respectivement le nom et le type de l'attribut. Le type d'un attribut est ncessairement un type simple
puisque les attributs ne peuvent contenir que du texte. La dclaration d'un attribut prend la forme suivante.
<xsd:attribute name="name" type="type"/>
L'exemple suivant dclare un attribut format de type xsd:string.
<xsd:attribute name="format" type="xsd:string"/>
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 cidessous peut tre la chane en ou la chane fr.
<xsd:attribute name="lang">
<xsd:simpleType>
<xsd:enumeration value="en"/>
<xsd:enumeration value="fr"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
68
Schmas XML
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.
<xsd:complexType name="List">

<xsd:sequence maxOccurs="unbounded">
<xsd:element name="item" type="xsd:string"/>
</xsd:sequence>

<xsd:attribute name="form" type="xsd:string"/>
<xsd:attribute name="lang" type="Lang"/>
</xsd:complexType>

<xsd:simpleType name="Lang">
</xsd:restriction>
</xsd:simpleType>
<xsd:element name="list" type="List"/>
</xsd:schema>
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 celuici 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.

<xsd:attribute name="lang" type="xsd:language"/>
<xsd:element
name="texts" type="Texts"/>
<xsd:complexType name="Texts">
<xsd:sequence>
<xsd:element name="text" maxOccurs="unbounded">
<xsd:complexType>
<xsd:simpleContent>
<xsd:extension base="xsd:string">

<xsd:attribute ref="lang"/>
</xsd:extension>
</xsd:complexType>
</xsd:element>
69
Schmas XML
</xsd:sequence>

<xsd:attribute ref="lang"/>
</xsd:complexType>
</xsd:schema>
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.
<tns:texts tns:lang="fr" xmlns:tns="http://www.liafa.jussieu.fr/~carton/">
<text>Texte en franais</text>
<text tns:lang="en">Text in english</text>
</tns:texts>
5.7.2. Attribut optionnel, obligatoire ou interdit

Par dfaut, un attribut est optionnel. Il peut tre prsent ou absent. Il peut aussi tre rendu obligatoire ou interdit
en donnant la valeur required ou prohibited l'attribut use de l'lment xsd:attribute. L'attribut
use peut aussi prendre la valeur optional. Cette valeur est trs peu utilise car c'est la valeur par dfaut. La
valeur prohibited est utile dans les restrictions de types pour modifier l'utilisation d'un attribut.
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.
<xsd:attribute name="lang"
type="xsd:NMTOKEN" use="optional"/>
<xsd:attribute name="xml:id" type="xsd:ID"
use="required"/>
<xsd:attribute name="dummy" type="xsd:string" use="prohibited"/>
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.
<xsd:complexType name="Date">
<xsd:simpleContent>
<xsd:extension base="xsd:date">

</xsd:extension>
</xsd:complexType>
<xsd:complexType name="Date-8601">
<xsd:simpleContent>
<xsd:restriction base="Date">

<xsd:attribute name="format" type="xsd:string" use="prohibited"/>
</xsd:restriction>
</xsd:complexType>
<xsd:element name="date" type="Date-8601"/>
</xsd:schema>
70
Schmas XML
5.7.3. Valeur par dfaut et valeur fixe

Comme pour les lments, il est possible de donner une valeur par dfaut ou une valeur fixe un attribut. La valeur
de l'attribut default ou de l'attribut fixed de l'lment xsd:attribute permet de spcifier cette valeur. Il
va de soi qu'une valeur par dfaut n'est autorise que si l'attribut est optionnel. Il est galement interdit de donner
simultanment une valeur par dfaut et une valeur fixe. L'attribut fixed est quivalent #FIXED utilis dans
les dclarations d'attribut des DTD. Dans le premier exemple suivant, la valeur par dfaut de l'attribut lang est
fr et dans le second exemple, sa valeur est fixe la valeur en.
<xsd:attribute name="lang" type="xsd:NMTOKEN" default="fr"/>
<xsd:attribute name="lang" type="xsd:NMTOKEN" fixed="en"/>
5.7.4. Joker xsd:anyAttribute

De mme qu'il existe un lment xsd:any [Section 5.6.8] pour autoriser des lments externes, il existe aussi un
lment xsd:anyAttribute pour autoriser des attributs externes au schma. Il possde galement les attributs
processContents et namespace pour contrler la validation et l'espace de noms des attributs externes
ajouts dans les documents.
Dans le schma suivant, l'lment person peut avoir des attributs appartenant l'espace de noms identifi par
l'URI http://www.liafa.jussieu.fr/~carton/.
<xsd:complexType>
<xsd:sequence>
</xsd:sequence>
<xsd:anyAttribute processContents="lax"
namespace="http://www.liafa.jussieu.fr/~carton/"/>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<person tns:id="id42" xmlns:tns="http://www.liafa.jussieu.fr/~carton/">
</person>
5.8. Extension de types

L'extension est la premire faon d'obtenir un type driv partir d'un type de base. L'ide gnrale de l'extension
est de rajouter du contenu et des attributs. Elle s'apparente la drivation de types des langages de programmation
orients objet comme Java ou C++. Les contenus du type driv ne sont gnralement pas valides pour le type de
base car des lments et/ou des attributs nouveaux peuvent apparatre. L'extension s'applique aux types simples
et aux types complexes mais elle donne toujours un type complexe.
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.
71
Schmas XML

L'extension d'un type simple ne permet pas de changer le contenu mais permet uniquement d'ajouter des attributs
pour donner un type complexe contenu simple. C'est en fait la seule faon d'obtenir un tel type s'il on exclut
l'extension ou la restriction d'un type qui est dj dans cette catgorie. Lors d'une extension d'un type simple,
l'lment xsd:extension est toujours enfant d'un lment xsd:simpleContent. Les dclarations des
attributs qui sont ajouts sont places dans le contenu de l'lment xsd:extension.
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">

<xsd:attribute name="currency" type="xsd:string"/>
</xsd:extension>
</xsd:complexType>
<xsd:element name="price" type="Price"/>
<price currency="euro">3.14</price>
5.8.2. Types complexes contenu simple

Il est possible d'tendre un type complexe contenu simple pour lui ajouter de nouveaux attributs. On obtient
alors un nouveau type complexe contenu simple qui possde les attributs du type de base et ceux dclars par
l'extension. L'extension d'un tel type est similaire l'extension d'un type simple. L'lment xsd:extension est
encore enfant d'un lment xsd:simpleContent. Les dclarations des attributs qui sont ajouts sont places
dans le contenu de l'lment xsd:extension.
Dans le schma suivant, le type Price est tendu en un type LocalType qui possde un nouvel attribut
country de type xsd:string.

<xsd:complexType name="Price">
<xsd:simpleContent>

</xsd:extension>
</xsd:complexType>

<xsd:complexType name="LocalPrice">
<xsd:simpleContent>
<xsd:extension base="Price">

<xsd:attribute name="country" type="xsd:string"/>
</xsd:extension>
</xsd:complexType>
<xsd:element name="price" type="LocalPrice"/>
</xsd:schema>
72
Schmas XML

<price currency="euro" country="France">3.14</price>
5.8.3. Types complexes contenu complexe

L'extension d'un type complexe contenu complexe consiste ajouter du contenu et/ou des attributs. Le contenu
est ajout aprs le contenu du type de base. L'ajout d'attribut est semblable au cas des types complexes contenu
simple.
Dans le schma suivant le type Fullname tend le type Name en lui ajoutant un lment title et un attribut id.

<xsd:complexType name="Name">
<xsd:sequence>
</xsd:sequence>
</xsd:complexType>

<xsd:complexType name="Fullname">
<xsd:extension base="Name">
<xsd:sequence>

</xsd:sequence>

<xsd:attribute name="id" type="xsd:ID"/>
</xsd:extension>
</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.
<names>
<fullname id="id40">
<firstname>Alexander III Alexandrovich</firstname>
<lastname>Romanov</lastname>
<title>Tsar of Russia</title>
</fullname>
<fullname id="id52">
</fullname>
</names>
5.9. Restriction de types

La restriction est la deuxime faon d'obtenir un type driv partir d'un type de base. L'ide gnrale de la
restriction est de dfinir un nouveau type dont les contenus au sens large sont des contenus du type de base. Par
73
Schmas XML
contenus au sens large, on entend les contenus proprement dits ainsi que les valeurs des attributs. La restriction
s'applique aux types simples et aux types complexes mais elle prend des formes diffrentes suivant les cas.
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.

Les schmas dfinissent un certain nombre de types de base [Section 5.5.1]. Tous les autres types simples
sont obtenus par restriction directe ou multiple de ces diffrents types de base. La restriction des types simples
est effectue par l'intermdiaire de facettes qui imposent des contraintes aux contenus. Toutes les facettes ne
s'appliquent pas tous les types simples. On donne d'abord quelques exemples de restrictions classiques l'aide
des principales facettes puis une liste exhaustive des facettes [Section 5.9.1.4].
5.9.1.1. Restriction par intervalle

Il est possible de restreindre les contenus en donnant une valeur minimale et/ou une valeur maximale avec les
lments xsd:minInclusive, xsd:minExclusive, xsd:maxInclusive et xsd:maxExclusive.
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:restriction>
</xsd:simpleType>
</xsd:element>
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">

<xsd:minExclusive value="2001-12-31"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
5.9.1.2. Restriction par numration

Il est possible de donner explicitement une liste des valeurs possibles d'un type prdfini ou dj dfini avec
l'lment xsd:enumeration. Dans l'exemple suivant, le type donn l'lment language comprend
uniquement les trois chanes de caractres de, en et fr. Le type utilis est un type nomm Language.
<xsd:element name="language" type="Language"/>
<xsd:simpleType name="Language">
<xsd:restriction base="xsd:language">
<xsd:enumeration value="de"/>
<xsd:enumeration value="en"/>
<xsd:enumeration value="fr"/>
</xsd:restriction>
74
Schmas XML
</xsd:simpleType>
5.9.1.3. Restriction par motif

Il est possible de restreindre les valeurs en donnant, avec l'lment xsd:pattern, une expression rationnelle
[Section 5.15] qui dcrit les valeurs possibles d'un type prdfini ou dj dfini. Le contenu est valide s'il est
conforme l'expression rationnelle. Dans l'exemple suivant, le type ISBN dcrit explicitement toutes les formes
possibles des numros ISBN 10 chiffres.
<xsd:simpleType name="ISBN">
<xsd:pattern value="\d-\d{2}-\d{6}-[\dX]"/>
</xsd:restriction>
</xsd:simpleType>
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:pattern value="[:_A-Za-z][-.:_0-9A-Za-z]*"/>
</xsd:restriction>
</xsd:simpleType>
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}.*.
5.9.1.4. Liste des facettes

Il faut remarquer que les restrictions par numration ou par motif se combinent avec un ou logique. Le contenu
doit tre une des valeurs numres ou il doit tre dcrit par un des motifs. Au contraire, les autres restrictions
comme minInclusive et maxInclusive se combinent avec un et logique. Le contenu doit vrifier toutes
les contraintes pour tre valide.
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.
xsd:length, xsd:minLength et xsd:maxLength
75
Schmas XML
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].
xsd:minInclusive, xsd:minExclusive, xsd:maxInclusive et xsd:maxExclusive
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.
5.9.2. Types complexes contenu simple

Les types complexes contenu simple sont toujours obtenus par extension d'un type simple en lui ajoutant des
attributs. La restriction d'un de ces types peut porter sur le type simple du contenu ou/et sur les attributs. Il est
possible de remplacer le type du contenu par un type obtenu par restriction. Il est aussi possible de changer le
type d'un attribut ou de modifier son utilisation. Un attribut optionnel peut, par exemple, devenir obligatoire. La
restriction d'un type complexe contenu simple donne toujours un type complexe contenu simple.
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.
76
Schmas XML
<xsd:complexType name="Base">
<xsd:simpleContent>
</xsd:extension>
</xsd:complexType>

<xsd:complexType name="Derived">
<xsd:simpleContent>
<xsd:restriction base="Base">

<xsd:simpleType>
<xsd:maxLength value="32"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:restriction>
</xsd:complexType>
...
</xsd:schema>
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.
<xsd:simpleContent>
<xsd:attribute name="decimal" type="xsd:decimal"/>
<xsd:attribute name="string"
type="xsd:string"/>
<xsd:attribute name="optional" type="xsd:string"/>
<xsd:attribute name="required" type="xsd:string" use="required"/>
<xsd:attribute name="fixed"
type="xsd:string" fixed="Fixed"/>
</xsd:extension>
</xsd:complexType>
<xsd:simpleContent>

<xsd:attribute name="decimal" type="xsd:integer"/>

<xsd:attribute name="decimal" type="xsd:string"/>

<xsd:attribute name="string">
<xsd:simpleType>
77
Schmas XML
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>

<xsd:attribute name="optional" type="xsd:string" use="required"/>

<xsd:attribute name="required" type="xsd:string"/>

<xsd:attribute name="fixed"
type="xsd:string"/>

<xsd:attribute name="newattr" type="xsd:string"/>
</xsd:restriction>
</xsd:complexType>
...
</xsd:schema>
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.
<xsd:simpleContent>
<xsd:attribute name="decimal"
type="xsd:decimal"/>
<xsd:attribute name="unchanged" type="xsd:string"/>
</xsd:extension>
</xsd:complexType>
<xsd:simpleContent>
<xsd:simpleType>

</xsd:restriction>
</xsd:simpleType>

<xsd:attribute name="decimal" type="xsd:integer"/>

</xsd:restriction>
</xsd:complexType>
...
</xsd:schema>
5.9.3. Types complexes contenu complexe

La restriction d'un type complexe permet d'imposer des contraintes aussi bien au contenu qu'aux attributs. La
restriction doit rester fidle au principe que tous les contenus possibles du type restreint doivent tre valides pour
le type de base. Il est, par exemple, possible de changer le type d'un lment en un type restreint ou de changer le
nombre d'occurrences d'un lments ou d'un bloc avec les attributs minOccurs et maxOccurs [Section 5.6.7].
Les restrictions portant sur les attributs sont identiques celles possibles pour un type complexe contenu simple.
78
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.
<xsd:element name="names">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="name"
type="Name"/>
<xsd:element name="shortname" type="Shortname"/>
</xsd:choice>
</xsd:complexType>
</xsd:element>
<xsd:sequence>

<xsd:element name="firstname" type="xsd:string" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>

<xsd:complexType name="Shortname">
<xsd:restriction base="Name">
<xsd:sequence>

<xsd:element name="firstname" type="xsd:string" maxOccurs="1"/>
</xsd:sequence>

<xsd:attribute name="id" type="xsd:ID" use="required"/>
</xsd:restriction>
</xsd:complexType>
</xsd:schema>
<names xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<name>
<firstname>Elizabeth II</firstname>
<firstname>Alexandra</firstname>
<firstname>Mary</firstname>
</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].
79
Schmas XML

<xsd:sequence>
<xsd:element name="integer" type="xsd:integer"/>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="Restriction">
<xsd:sequence>
<xsd:element name="integer" type="xsd:nonNegativeInteger"/>
</xsd:sequence>
</xsd:restriction>
</xsd:complexType>
...
</xsd:schema>
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.
<xsd:complexType name="Number">
<xsd:choice>
<xsd:element name="float"
type="xsd:float"/>
<xsd:element name="double" type="xsd:double"/>
</xsd:choice>
</xsd:complexType>
<xsd:complexType name="Float">
<xsd:restriction base="Number">
<xsd:choice>

<xsd:element name="float"
type="xsd:float"/>
<xsd:element name="double" type="xsd:double"/>
</xsd:choice>
</xsd:restriction>
</xsd:complexType>
...
</xsd:schema>
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.
<numbers xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<number>
<integer>42</integer>
</number>
<number xsi:type="Float">

<float>3.14</float>
80
Schmas XML
</number>
</numbers>
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.
<xsd:element name="list">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="item" nillable="true"
maxOccurs="unbounded" type="xsd:integer"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
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.
<list xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

<item>123</item>

<item></item>

<item xsi:nil="true"></item>

<item xsi:nil="true">
</item>
<item>789</item>
</list>
5.10.2. Substitution de type

81
Schmas XML
Un type peut remplacer, dans une instance de document, un autre type dont il drive directement ou non. Soit, par
exemple, un lment elem dclar d'un type BaseType. Si un type ExtentedType a t dfini par extension
ou restriction du type BaseType, il est possible, dans une instance de document, de mettre un lment elem avec
un contenu de type ExtentedType. Pour que le document reste valide, l'lment elem doit avoir un attribut
xsi:type qui prcise le type de son contenu. Cet attribut est dans l'espace de noms [Chapitre 4] des instances
de schmas. La substitution de type est autorise par dfaut. Aucune dclaration n'est ncessaire dans le schma
pour qu'elle puisse avoir lieu dans les documents. La substitution de type peut, en revanche, tre force ou bloque
par les attributs abstract et block [Section 5.10.4]. Dans l'exemple suivant, un type Name est d'abord dclar
puis un type Fullname tend ce type en ajoutant un lment title et un attribut id.
<xsd:schema targetNamespace="http://www.liafa.jussieu.fr/~carton/"
xmlns="http://www.liafa.jussieu.fr/~carton/">
<xsd:element name="name" type="Name"/>
...
<xsd:sequence>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="Fullname">
<xsd:extension base="Name">
<xsd:sequence>
</xsd:sequence>
</xsd:extension>
</xsd:complexType>
</xsd:schema>
Le document suivant est valide pour ce schma.
<tns:names xmlns:tns="http://www.liafa.jussieu.fr/~carton/"

<tns:name>
<firstname>Bessiewallis</firstname>
<lastname>Warfield</lastname>
</tns:name>

<tns:name id="id52" xsi:type="tns:Fullname">
</tns:name>
</tns:names>
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.
82
Schmas XML
xmlns="http://www.liafa.jussieu.fr/~carton/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:element name="value" type="xsd:integer"/>
...
<xsd:simpleType name="Byte">
<xsd:restriction base="xsd:nonNegativeInteger">
</xsd:restriction>
</xsd:simpleType>
</xsd:schema>
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.
<tns:values xmlns:tns="http://www.liafa.jussieu.fr/~carton/"
<tns:value>-1</tns:value>
<tns:value xsi:type="xsd:nonNegativeInteger">256</tns:value>
<tns:value xsi:type="tns:Byte">255</tns:value>
</tns:values>
5.10.3. Groupes de substitution

Il est possible de spcifier qu'un lment peut tre remplac par un autre lment dans les documents instance. Ce
mcanisme est diffrent de l'utilisation de l'attribut xsi:type puisque c'est l'lment mme qui est remplac et
pas seulement le type. Le type de l'lment substitu doit avoir un type driv du type de l'lment original.
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.


<xsd:element name="positive" type="xsd:positiveInteger"
substitutionGroup="integer"/>
<xsd:element name="negative" type="xsd:negativeInteger"
<xsd:element name="integers">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="integer" maxOccurs="unbounded"/>
83
Schmas XML
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
Le document suivant est valide pour ce schma. L'lment integers contient des lments positive et
negative remplacent des lments integer.
<integers>

<positive>1</positive>

<negative>-1</negative>
<integer>-42</integer>
</integers>
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, luimme, 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.

<xsd:element name="head" type="xsd:string"/>

<xsd:element name="subs" type="xsd:string" substitutionGroup="head"/>

<xsd:element name="subsubs" type="xsd:string" substitutionGroup="subs"/>
<xsd:element name="heads">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="head" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<heads>
<head>lment head original</head>
<subs>Substitution de head par subs</subs>
<subsubs>Substitution de head par subsubs</subsubs>
<head>Autre lment head original</head>
</heads>
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.
<xsd:element name="head" type="xsd:string" substitutionGroup="subs"/>
84
Schmas XML
<xsd:element name="subs" type="xsd:string" substitutionGroup="head"/>

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.
<xsd:element name="properties">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="property" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="property">
<xsd:complexType>
<xsd:all>
<xsd:element name="key" type="xsd:string"/>
<xsd:element ref="number"/>
<xsd:element name="condition" type="xsd:string" minOccurs="0"/>
</xsd:all>
</xsd:complexType>
</xsd:element>
<xsd:element name="number" type="xsd:anyType" abstract="true"/>
<xsd:element name="integer" type="xsd:integer" substitutionGroup="number"/>
<xsd:element name="double" type="xsd:double" substitutionGroup="number"/>
</xsd:schema>
5.10.4. Contrle des substitutions et drivations

Il existe diffrents moyens de contrler les substitutions de types et d'lments. Les types et lments abstraits
introduits par l'attribut abstract permettent de forcer une substitution en empchant un type ou un lment
d'apparatre dans un document. Les attributs block et final permettent, au contraire, de limiter les substitutions
et les dfinitions de types drivs.
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.
Le tableau suivant rcapitule les utilisations des trois attributs abstract, block et final pour les types et
les lments.
Attribut
Type
lment
abstract
bloque l'utilisation du type dans les bloque la prsence de l'lment dans les
documents
documents
block
bloque la substitution du type dans les bloque la substitution de type pour cet
documents
lment dans les documents
final
bloque la drivation de types dans le schma bloque l'ajout d'lments dans le groupe de
substitution dans le schma
85
Schmas XML
5.10.4.1. Facette fixe

Les types simples sont obtenus par restrictions successives des types prdfinis [Section 5.5.1] en utilisant des
facettes [Section 5.9.1]. Il est possible d'imposer, avec l'attribut fixed, qu'une facette ne puisse plus tre modifie
dans une restriction supplmentaire.
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.

<xsd:simpleType name="ShortString">

<xsd:maxLength value="32" fixed="true"/>
</xsd:restriction>
</xsd:simpleType>

<xsd:simpleType name="VeryShortString">
<xsd:restriction base="ShortString">

<xsd:minLength value="2"/>

</xsd:restriction>
</xsd:simpleType>
</xsd:schema>
...
<strings xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<string>Une chane assez courte</string>
<string xsi:type="VeryShortString">Trs courte</string>
</strings>
5.10.4.2. Type abstrait

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].
86
Schmas XML
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.

<xsd:complexType name="Price" abstract="true">
<xsd:simpleContent>
</xsd:extension>
</xsd:complexType>

<xsd:complexType name="InternPrice">
<xsd:simpleContent>
<xsd:restriction base="Price">
<xsd:attribute name="currency" type="xsd:string" use="required"/>
</xsd:restriction>
</xsd:complexType>

<xsd:element name="price" type="Price"/>

<xsd:element name="internprice" type="InternPrice" substitutionGroup="price"/>
<xsd:element name="prices">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="price" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
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.
<prices xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

<price>78.9</price>

<price xsi:type="InternPrice" currency="euro">12.34</price>

<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.
87
Schmas XML
<xsd:element name="value" type="Abstract"/>

<xsd:element name="values">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="value" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:complexType name="Abstract" abstract="true"/>
<xsd:complexType name="Derived1">
<xsd:extension base="Abstract">
<xsd:sequence>
<xsd:element name="string" type="xsd:string"/>
</xsd:sequence>
<xsd:attribute name="att" type="xsd:string"/>
</xsd:extension>
</xsd:complexType>
<xsd:complexType name="Derived2">
<xsd:extension base="Abstract">
<xsd:sequence>
<xsd:element name="string" type="xsd:string"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexType>
</xsd:schema>
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.
<tns:values xmlns:tns="http://www.liafa.jussieu.fr/~carton/"

<tns:value xsi:type="tns:Derived1" att="avec un attribut">
<string>Une chane</string>
</tns:value>
<tns:value xsi:type="tns:Derived2">
<string>Un entier</string>
</tns:value>
</tns:values>
5.10.4.3. lment abstrait

Un lment peut tre dclar abstrait en donnant la valeur true l'attribut abstract de l'lment
xsd:element. Un lment dclar abstrait peut tre utilis dans la construction d'un type pour un autre lment.
En revanche, il ne peut pas apparatre dans un document instance. L'lment doit ncessairement tre remplac
par un autre lment. Cette substitution est uniquement possible lorsque l'lment abstrait est le chef d'un groupe
de substitution [Section 5.10.3]. Il peut alors tre remplac par n'importe quel membre du groupe.
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.
88
Schmas XML
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.

<xsd:element name="value" type="xsd:string" abstract="true"/>

<xsd:element name="other" type="String27" substitutionGroup="value"/>

<xsd:simpleType name="String27">
</xsd:restriction>
</xsd:simpleType>
...
Le document suivant est valide pour le schma prcdent. L'lment abstrait value n'apparat pas. Il est
systmatiquement remplac par l'lment other.
<values xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

<value>Une chane d'une autre longueur</value>

<value xsi:type="String27">Une chane de 27 caractres</value>

<other>Une chane de mme longueur</other>
</values>
5.10.4.4. Type bloqu

Il est possible, dans un schma de limiter dans les documents les substitutions de types. L'attribut block de
l'lment xsd:complexType permet d'empcher qu'un lment du type dfini puisse prendre un autre type
driv dans un document instance. La valeur de cet attribut est soit la chane #all soit une liste de valeurs parmi
les valeurs extension et restriction. Les valeurs numres ou toutes pour #all bloquent les diffrents
types qui peuvent remplacer le type pour un lment. La valeur par dfaut de cet attribut est donne par la valeur
de l'attribut blockDefault de l'lment xsd:schema [Section 5.3.1].
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.
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.
<xsd:element name="value" type="Base"/>

<xsd:element name="sametype" type="Base"
substitutionGroup="value"/>

<xsd:element name="subst" type="Extension" substitutionGroup="value"/>
...

89
Schmas XML
<xsd:complexType name="Base" block="#all">

<xsd:sequence>
</xsd:sequence>
</xsd:complexType>

<xsd:complexType name="Extension">
<xsd:extension base="Base">
</xsd:extension>
</xsd:complexType>

<xsd:sequence>
</xsd:sequence>
</xsd:restriction>
</xsd:complexType>
</xsd:schema>
<values xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<value>
</value>

<sametype>
</sametype>

<subst att="Un attribut">
</subst>

<value xsi:type="Extension" att="Un attribut">
</value>

<value xsi:type="Restriction">
</value>
</values>
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 drive est bloque si l'attribut block, dans dfinition du type de base, mentionne
une drivation utilise par le type drive. 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
90
Schmas XML
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.

<xsd:complexType name="List" block="extension">
<xsd:sequence>
<xsd:element name="item" type="xsd:string" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="ShortList">
<xsd:restriction base="List">
<xsd:sequence>

<xsd:element name="item" type="xsd:string" maxOccurs="8"/>
</xsd:sequence>
</xsd:restriction>
</xsd:complexType>

<xsd:complexType name="AttrShortList">
<xsd:extension base="ShortList">

<xsd:attribute name="length" type="xsd:integer"/>
</xsd:extension>
</xsd:complexType>
</xsd:schema>

<list xsi:type="ShortList"
xsi:type="AttrShortList" length="3"
<item>Premier item</item>
<item>Deuxime item</item>
<item>Troisime item</item>
</list>
5.10.4.5. lment bloqu

L'attribut block peut aussi apparatre dans la dclaration d'un lment. L'attribut block de l'lment
xsd:element permet d'empcher que cet lment puisse prendre un autre type driv dans un document
instance. La valeur de cet attribut est soit la chane #all soit une liste de valeurs parmi les valeurs extension,
restriction et substitution. Les valeurs numres ou toutes pour #all bloquent les diffrents types
qui peuvent remplacer le type pour un lment. La valeur par dfaut de cet attribut est donne par la valeur de
l'attribut blockDefault de l'lment xsd:schema [Section 5.3.1].
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
91
Schmas XML
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.
<xsd:element name="integer" type="xsd:integer"
block="restriction extension"/>

<xsd:element name="sametype" type="xsd:integer"

...
</xsd:schema>
<integers xmlns:xsd="http://www.w3.org/2001/XMLSchema"

<sametype>1</sametype>

<integer xsi:type="xsd:positiveInteger">1</integer>

</integers>
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.
<xsd:element name="integer" type="xsd:integer" block="substitution"/>

<xsd:element name="sametype" type="xsd:integer"

...
</xsd:schema>
<integers xmlns:xsd="http://www.w3.org/2001/XMLSchema"

92
Schmas XML
<integer xsi:type="xsd:positiveInteger">1</integer>

<sametype>1</sametype>

</integers>
5.10.4.6. Type final

Il est possible, dans un schma, de restreindre l'utilisation d'un type pour dfinir d'autres types. Ce mcanisme
s'apparente la possiblit des langages de programmation orients objet de bloquer la drivation d'une classe
avec le qualificatif final. Le mcanisme des schmas est plus prcis car il permet de bloquer slectivement les
diffrentes drivations : restriction, extension, union et liste.
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.
...

<xsd:complexType name="Base" final="#all">
<xsd:sequence>
</xsd:sequence>
</xsd:complexType>

<xsd:complexType name="Extension">
<xsd:extension base="Base">
</xsd:extension>
</xsd:complexType>

<xsd:sequence>
</xsd:sequence>
</xsd:restriction>
</xsd:complexType>
</xsd:schema>
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.
93
Schmas XML


<xsd:complexType name="List" final="extension">
<xsd:sequence>
<xsd:element name="item" type="xsd:string" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="ShortList">
<xsd:restriction base="List">
<xsd:sequence>

<xsd:element name="item" type="xsd:string" maxOccurs="8"/>
</xsd:sequence>
</xsd:restriction>
</xsd:complexType>

<xsd:complexType name="AttrShortList">
<xsd:extension base="ShortList">

<xsd:attribute name="length" type="xsd:integer"/>
</xsd:extension>
</xsd:complexType>
</xsd:schema>
<list length="3" xsi:type="AttrShortList"
<item>Premier item</item>
<item>Deuxime item</item>
<item>Troisime item</item>
</list>
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.
5.10.4.7. lment final

Il est possible, dans un schma, de limiter les lments susceptibles de se substituer un lment donn. Il est
en effet possible d'empcher slectivement les lments d'appartenir un groupe de substitution en fonction de
leur type.
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
94
Schmas XML
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.
<xsd:element name="integer" type="xsd:integer" final="extension"/>



<xsd:element name="attributed" type="Attributed"

<xsd:complexType name="Attributed">
<xsd:simpleContent>
<xsd:extension base="xsd:integer">
</xsd:extension>
</xsd:complexType>
...
</xsd:schema>
Le document suivant est valide pour le schma prcdent. L'lment attributed ne peut pas remplacer
l'lment integer.
<integers>


<attributed att="Un attribut">-1</attributed>
</integers>
5.11. Groupes d'lments et d'attributs

Il est possible de nommer des groupes d'lments et des groupes d'attributs afin de pouvoir les rutiliser. Ce
mcanisme aide structurer un schma complexe et vise obtenir une meilleure modularit dans l'criture
des schmas. Les groupes d'lments et d'attributs sont respectivement dfinis par les lments xsd:group et
xsd:attributeGroup.
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.
5.11.1. Groupe d'lments

L'lment xsd:group permet de dfinir un groupe d'lments dont le nom est donn par l'attribut name.
L'lment xsd:group doit tre enfant de l'lment racine xsd:schema du schma. Ceci signifie que la porte
de la dfinition du groupe est le schma tout entier. Le contenu de l'lment xsd:group est un fragment de type
ncessairement inclus dans un lment xsd:sequence, xsd:choice ou xsd:all [Section 5.6].
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.
95
Schmas XML
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.
<xsd:group name="FirstLast">
<xsd:sequence>
</xsd:sequence>
</xsd:group>
<xsd:group name="Name">
<xsd:choice>
<xsd:element name="name" type="xsd:string"/>

<xsd:group
ref="FirstLast"/>
</xsd:choice>
</xsd:group>
<xsd:complexType name="Person">
<xsd:sequence>
<xsd:element name="surname" type="xsd:string" minOccurs="0"/>

<xsd:group
ref="Name"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="characters">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="character" maxOccurs="unbounded">
<xsd:complexType>
<xsd:sequence>

<xsd:group
ref="Name"/>
<xsd:element name="creator" type="Person"
minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<characters>
<character>
<lastname>Lagaffe</lastname>
<creator>
<firstname>Andr</firstname>
<lastname>Franquin</lastname>
</creator>
</character>
<character>
<name>Astrix</name>
<creator>
<surname>Al Uderzo</surname>
96
Schmas XML
<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.
5.11.2. Groupe d'attributs

Les groupes d'attributs jouent, pour les attributs, un rle similaire aux groupes d'lments. Ils permettent de
regrouper plusieurs dclarations d'attributs dans le but d'une rutilisation. L'lment xsd:attributeGroup
permet de dfinir un groupe d'attributs dont le nom est donn par l'attribut name. L'lment
xsd:attributeGroup doit tre enfant de l'lment racine xsd:schema du schma. Ceci signifie que la
porte de la dfinition du groupe est le schma tout entier. Le contenu de l'lment xsd:attributeGroup est
constitu de dclarations d'attributs introduites par l'lment xsd:attribute [Section 5.7].
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">

...
<xsd:attributeGroup ref="LangType"/>
</xsd:complexType>
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"/>
97
Schmas XML
</xsd:attributeGroup>
Le schma l'adresse http://www.w3.org/2001/xml.xsd dclare les quatre attributs particuliers
[Section 2.7.4] xml:lang, xml:space, xml:base et xml:id. Il dfinit galement un groupe d'attributs
xml:specialAttrs permettant de dclarer simultanment ces quatre attributs. Un exemple d'utilisation de
celui-ci est donn dans la partie sur l'import de schmas [Section 5.14]. Cet exemple montre que les noms des
groupes d'lments et des groupes d'attributs sont des noms qualifis dans l'espace de noms cible du schma.
5.12. Contraintes de cohrence

Les schmas permettent de spcifier des contraintes globales de cohrence. Celles-ci doivent tre vrifies par un
document pour que celui-ci soit valide. Elles ressemblent aux contraintes des DTD portant sur les attributs des
types ID, IDREF et IDREFS [Section 3.7.2] mais elles sont beaucoup plus gnrales. Elle peuvent porter sur
des lments ou des attributs. La porte de ces contraintes peut tre n'importe quel contenu d'lment et non pas
l'intgralit du document comme dans les DTD.
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.
5.12.1. Contraintes d'unicit

Une contrainte d'unicit spcifie que dans le contenu d'un lment donn, il ne peut exister qu'un seul lment
ayant une proprit fixe. Cette proprit est trs souvent la valeur d'un attribut mais elle peut aussi tre forme
des valeurs de plusieurs enfants ou attributs. Cette notion est similaire la notion de cl des bases de donnes. Elle
gnralise les attributs de types ID dont la valeur est unique dans tout le document.
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:selector 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
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.

<xsd:element name="bibliography" type="Bibliography">

<xsd:key name="dummy">
<xsd:selector xpath="book"/>
<xsd:field
xpath="@key"/>
</xsd:key>
</xsd:element>
98
Schmas XML
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.
5.12.1.1. Porte des contraintes

Le schma suivant illustre la notion de porte. Il contient deux exemples de contrainte d'unicit. Une premire
contrainte group.num porte sur les attributs num des lments group. Cette contrainte est dclare dans
l'lment groups qui est l'lment racine du document ci-dessous. Deux lments group du document ne
peuvent pas avoir la mme valeur d'attribut num. La seconde contrainte person.id porte sur les lments
person contenus dans un lment group. Comme cette contrainte est dclare dans l'lment group, deux
lments person contenus dans le mme lment group ne peuvent pas avoir la mme valeur d'attribut id. En
revanche, deux lments person contenus dans des lments group diffrents peuvent avoir la mme valeur
d'attribut id.
<xsd:element name="groups">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="group" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>

<xsd:unique name="group.num">
<xsd:selector xpath="group"/>
<xsd:field
xpath="@num"/>
</xsd:unique>
</xsd:element>
<xsd:element name="group">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="person" maxOccurs="unbounded">
<xsd:complexType>
<xsd:sequence>
</xsd:sequence>
<xsd:attribute name="id" type="xsd:string"/>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
<xsd:attribute name="num" type="xsd:integer"/>
</xsd:complexType>

<xsd:key name="person.id">
<xsd:selector xpath="person"/>
<xsd:field
xpath="@id"/>
</xsd:key>
</xsd:element>
</xsd:schema>
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.
<groups>
<group num="1">
<person id="AC">
99
Schmas XML
<lastname>Cohen</lastname>
</person>
<person id="VH">
</person>
</group>
<group num="2">
<person id="AC">
<firstname>Anders</firstname>
<lastname>Celsius</lastname>
</person>
<person id="SH">
<firstname>Stephen</firstname>
<lastname>Hawking</lastname>
</person>
</group>
</groups>
5.12.1.2. Valeurs champs multiples

La valeur qui dtermine l'unicit peut tre constitue de plusieurs champs. Il suffit pour cela de mettre plusieurs
lments xsd:field dans l'lment xsd:key ou xsd:unique. Deux valeurs sont alors considres comme
diffrentes si elles diffrent en au moins un champ.
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: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.
<groups>
<group num="1">
<person id="AC">
<lastname>Cohen</lastname>
</person>
<person id="VH">
</person>
<person id="AC">
<firstname>Anders</firstname>
<lastname>Celsius</lastname>
</person>
100
Schmas XML
<person id="AE">
<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:field
xpath="@id"/>
</xsd:key>
<xsd:key name="person.names">
<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.
5.12.1.3. Diffrence entre xsd:key et xsd:unique

Le schma prcdent illustre galement la diffrence entre les contraintes introduites par les lments xsd:key et
xsd:unique. Une contrainte introduite par xsd:key impose que tous les champs de la valeur soient prsents.
La contrainte person.id impose donc que l'attribut id soit prsent dans chaque lment person mme si cet
attribut est dclar optionnel [Section 5.7.2]. Au contraire, une contrainte introduite par xsd:unique n'impose
pas que tous les champs de la valeurs soient prsents. Seuls les lments ayant tous les champs sont pris en compte
dans la vrification de la contrainte. Deux lments ayant tous les champs ne peuvent avoir tous les champs gaux.
5.12.1.4. Expressions XPath

Les valeurs des attributs xpath des lments xsd:selector et xsd:field sont des expressions XPath
restreintes [Chapitre 6]. L'expression XPath de xsd:selector est relative l'lment dont la dclaration
contient l'lment xsd:unique ou xsd:key. Elle slectionne uniquement des lments descendants de cet
lment. L'expression XPath de xsd:field est relative aux lments slectionns par xsd:selector. Elle
slectionne uniquement des lments ou des attributs descendants de ces lments.
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,
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>
5.12.2. Contraintes d'existence

Une contrainte d'existence spcifie que dans le contenu d'un lment donn, il doit exister un lment ayant une
proprit fixe. Comme pour les contraintes d'unicit, cette proprit est trs souvent la valeur d'un attribut mais
101
Schmas XML
elle peut aussi tre forme des valeurs de plusieurs enfants ou attributs. L'ide gnrale est de rfrencer un lment
par une valeur appele cl et que cet lment doit exister. Cette ide gnralise les attributs de types IDREF et
IDREFS [Section 3.7.2] des DTD.
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.
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.

<xsd:key name="idchapter">
<xsd:selector xpath="chapter"/>
<xsd:field
xpath="@id"/>
</xsd:key>

<xsd:keyref name="idref" refer="idchapter">
<xsd:selector xpath=".//ref"/>
<xsd:field
xpath="@idref"/>
</xsd:keyref>
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.
5.12.3. Exemple complet

Voici un exemple de document XML reprsentant une liste de commandes. Chaque commande concerne un certain
nombre d'articles qui sont rfrencs dans le catalogue donn la fin.
<list period="P2D">
<orders>
<order date="2008-01-08" time="17:32:28">
<product serial="101-XX" number="12"/>
<product serial="102-XY" number="23"/>
<product serial="101-ZA" number="10"/>
</order>
<order date="2008-01-09" time="17:32:28">
</order>
<order date="2008-01-09" time="17:32:29">
</order>
</orders>
<catalog>
<product serial="101-XX">Product n 1</product>
102
Schmas XML
<product serial="101-ZA">Product n 2</product>

<product serial="102-XY">Product n 3</product>
<product serial="102-XA">Product n 4</product>
</catalog>
</list>
Le schma correspondant impose trois contraintes suivantes sur le fichier XML.
1. Deux commandes orders n'ont pas la mme date et la mme heure.
2. Deux produits du catalogue n'ont pas le mme numro de srie.
3. Tous les produits rfrencs dans les commandes sont prsents dans le catalogue.
Le dbut de ce schma XML est le suivant.
<xsd:element name="list">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="orders" type="Orders"/>
<xsd:element name="catalog" type="Catalog"/>
</xsd:sequence>
<xsd:attribute name="period" type="xsd:duration"/>
</xsd:complexType>

<xsd:unique name="dummy">
<xsd:selector xpath="orders/order"/>
<xsd:field
xpath="@date"/>
<xsd:field
xpath="@time"/>
</xsd:unique>

<xsd:key name="serial">
<xsd:selector xpath="catalog/product"/>
<xsd:field
xpath="@serial"/>
</xsd:key>

<xsd:keyref name="unused" refer="serial">
<xsd:selector xpath="orders/order/product"/>
<xsd:field
xpath="@serial"/>
</xsd:keyref>
</xsd:element>

...
5.13. Espaces de noms

Un des avantages des schmas par rapport aux DTD est la prise en charge des espaces de noms [Chapitre 4].
L'attribut targetNamespace de l'lment xsd:schema [Section 5.3.1] permet de prciser l'espace de noms
des lments et des types dfinis par le schma.
5.13.1. Schma sans espace de noms

Pour une utilisation plus simple, il est possible d'ignorer les espaces de noms. Il est alors possible de valider des
documents dont tous les lments n'ont pas d'espace de noms. Il suffit, pour cela, que les noms des lments du
103
Schmas XML
document ne soit pas qualifis (sans le caractre ':') et que l'espace de noms par dfaut [Section 4.5] ne soit
pas spcifi.
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, ).
5.13.2. Espace de noms cible

Pour spcifier un espace de noms cible dans lequel sont dfinis les lments, l'attribut targetNamespace de
l'lment xsd:schema [Section 5.3.1] doit contenir l'URI associ cet espace de noms. La valeur de l'attribut
elementFormDefault de l'lment xsd:schema dtermine quels lments sont effectivement dfinis dans
l'espace de noms.
La valeur par dfaut de l'attribut elementFormDefault est unqualified. Quand la valeur de
elementFormDefault est unqualified, seuls les lments dfinis globalement, c'est--dire quand
l'lment xsd:element est directement enfant de l'lment xsd:schema sont dans l'espace de noms cible.
Les autres lments sont sans espace de noms. Dans le schma suivant, l'lment global name est dans l'espace de
noms identifi par l'URI http://www.liafa.jussieu.fr/~carton/ alors que les deux lments locaux
firstname et lastname sont sans espace de noms.

elementFormDefault="unqualified"
<xsd:element name="name">
<xsd:complexType>
<xsd:sequence>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<tns:name xmlns:tns="http://www.liafa.jussieu.fr/~carton/">
</tns:name>
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.liafa.jussieu.fr/~carton/.
<xsd:complexType>
<xsd:sequence>
</xsd:sequence>
</xsd:complexType>
104
Schmas XML
</xsd:element>
</xsd:schema>
<tns:firstname>Gaston</tns:firstname>
<tns:lastname>Lagaffe</tns:lastname>
</tns:name>
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.
<xsd:complexType>
<xsd:sequence>
<xsd:element name="firstname" type="xsd:string" form="qualified"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<tns:firstname>Gaston</tns:firstname>
</tns:name>
5.13.3. Noms qualifis

Lorsqu'un lment [Section 5.4.4], un attribut [Section 5.7], un groupe d'lments, un groupe d'attributs
[Section 5.11] ou encore un type dfini globalement est rfrenc par un attribut ref ou type, la valeur de cet
attribut doit contenir le nom qualifi. Ceci oblige associer un prfixe l'espace de noms cible et l'utiliser pour
qualifier l'lment ou le type rfrenc comme dans le schma suivant.
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.
105
Schmas XML
xmlns:tns="http://www.liafa.jussieu.fr/~carton/">


<xsd:element name="name" type="tns:Name" />

<xsd:sequence>
</xsd:sequence>
</xsd:complexType>
</xsd:schema>
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.
xmlns:tns="http://www.liafa.jussieu.fr/~carton/"

<xsd:element name="name" type="xsd:string"/>

<xsd:element name="tree" type="tns:Tree"/>
<xsd:complexType name="Tree">
<xsd:sequence>

<xsd:element ref="tns:name"/>


<xsd:element name="child" type="tns:Tree" minOccurs="0" maxOccurs="2"/>
</xsd:sequence>
</xsd:complexType>
</xsd:schema>
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.
<tns:tree xmlns:tns="http://www.liafa.jussieu.fr/~carton/">
<tns:name>Racine</tns:name>
<child>
<tns:name>Fils Gauche</tns:name>
<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
106
Schmas XML
l'exemple suivant, l'espace de noms cible identifi par l'URI http://www.liafa.jussieu.fr/~carton/

est dclar comme l'espace de noms par dfaut et il est galement associ au prfixe tns.
xmlns:tns="http://www.liafa.jussieu.fr/~carton/">

<xsd:element name="name" type="Name" />

<xsd:sequence>
</xsd:sequence>
</xsd:complexType>
</xsd:schema>
5.14. Imports d'autres schmas

Dans un souci de modularit, il est possible d'importer d'autres schmas dans un schma l'aide des lments
xsd:include et xsd:import. L'lment xsd:include est employ lorsque l'espace de noms cible est
identique pour le schma import. L'lment xsd:import est employ lorsque l'espace de noms cible du schma
import est diffrent de celui qui ralise l'import. Les deux lments xsd:include et xsd:import possdent
un attribut schemaLocation pour donner l'URL du schma. L'lment xsd:import a, en outre, un attribut
namespace pour spcifier l'URI qui identifie l'espace de noms cible du schma import.
Le schma l'adresse http://www.w3.org/2001/xml.xsd contient les dfinitions des quatre attributs
particuliers [Section 2.7.4] xml:lang, xml:space, xml:base et xml:id de l'espace de noms XML
[Section 4.7]. Le schma suivant importe ce schma et utilise le groupe d'attributs xml:specialAttrs pour
ajouter des attributs l'lment name.
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.liafa.jussieu.fr/~carton/">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace"
schemaLocation="http://www.w3.org/2001/xml.xsd"/>
<xsd:complexType>
<xsd:simpleContent>


<xsd:attributeGroup ref="xml:specialAttrs"/>
</xsd:extension>
</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.
<tns:name xml:lang="fr" xmlns:tns="http://www.liafa.jussieu.fr/~carton/">
lment avec un attribut xml:lang
107
Schmas XML
</tns:name>
5.15. Expressions rationnelles

Une expression rationnelle dsigne un ensemble de chanes de caractres. Une chane donne est conforme
une expression si elle fait partie des chanes dcrites. Les expressions rationnelles sont construites partir des
caractres et des oprateurs d'union '|', de concatnation et de rptition '?', '*' et '+'.
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 obtenue 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'.
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'.
108
Schmas XML
5.15.3. Ensembles de caractres

Il est souvent ncessaire de dsigner des ensembles de caractres pour construire des expressions rationnelles. Il
existe plusieurs faons de dcrire ces ensembles.
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
caractres d'espacement [Section 2.2.2], c'est--dire l'ensemble [ \t\n\r]
\S
caractres autres que les caractres d'espacement, c'est--dire l'ensemble [^ \t\n\r]
\d
chiffres, c'est--dire [0-9]
\D
caractres autres que les chiffres, c'est--dire [^0-9]
\w
caractres alphanumriques et le tiret '-', c'est--dire [-0-9a-zA-Z]
\W
caractres autres que les caractres alphanumriques et le tiret, c'est--dire [^-0-9a-zA-Z]
\i
premiers caractres des noms XML [Section 2.2.3], c'est--dire [:_a-zA-Z]
109
Schmas XML
\I
caractres autres que les premiers caractres des noms XML, c'est--dire [^:_a-zA-Z]
\c
caractres des noms XML [Section 2.2.3], c'est--dire [-.:_0-9a-zA-Z]
\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
lettres
Lu
lettres majuscules
Ll
lettres minuscules
chiffres
caractre de ponctuation
Sparateurs
Tableau 5.1. Catgories Unicode
110
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.
6.1. Donnes et environnement

Une expression XPath est gnralement value par rapport un document XML pour en slectionner certaines
parties. Le document XML est vu comme un arbre form de nuds. Les principaux nuds de cet arbre sont les
lments, les attributs et le texte du document mais les commentaires et les instructions de traitement apparaissent
aussi comme des nuds. L'objet central de XPath est donc le nud d'un document XML. XPath prend aussi
en compte les contenus des lments et les valeurs des attributs pour effectuer des slections. Dans ce but,
XPath manipule aussi des valeurs atomiques des types prdfinis [Section 5.5.1] des schmas : xsd:string,
xsd:integer, xsd:decimal, xsd:date, xsd:time .
6.1.1. Arbre d'un document XML

Il a t vu au chapitre sur la syntaxe [Chapitre 2] que les lments d'un document XML sont relis par des liens de
parent. Un lment est le parent d'un autre lment s'il le contient. Ces relations de parent constituent l'arbre des
lments. Cette structure d'arbre est tendue tous les constituants d'un document pour former l'arbre du document
qui inclut les lments et leurs contenus, les attributs, les instructions de traitement et les commentaires. C'est sous
cette forme d'arbre que le document XML est manipul par XPath et XSLT.
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.
document node (root node)
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.
111
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.
processing instruction node
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.

<?xml-stylesheet href="tree.xsl" type="text/xsl"?>
<list type="technical">
<item key="id001" lang="fr">
XML & Co
</item>
<item>

Du texte
</item>
et encore du texte la fin.
</list>
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.
112
XPath
Docum ent
XML ... fin.
Com m ent
PI
xm l-st yle
Elem ent
list
Tim e ... 00"
href ... /xsl
XML ... fin.
At t ribut e
t ype
Elem ent
it em
Elem ent
it em
Text
t echnical
XML & Co
Du t ext e
et ... fin.
At t ribut e
key
At t ribut e
lang
Text
Com m ent
Text
id0001
fr
XML & Co
Un ... ut ile
Du t ext e
Figure 6.1. Arbre d'un document XML
6.1.1.1. Proprits des nuds

Les nuds de l'arbre d'un document sont caractriss par un certain nombre de proprits. Ces proprits
interviennent de faon essentielle dans la slection des nuds effectue par Xpath. Suivant les types de nuds,
certaines proprits n'ont pas de sens et elles n'ont alors pas de valeur. titre d'exemple, le nud d'un commentaire
n'a pas de nom.
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
<p>Texte en <i>italique</i> et en <b>gras <i>italique</i></b></p>
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].
113
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].
Fonctions sur les nuds

xsd:string name(node()? node)
retourne le nom complet du nud node ou du nud courant si node est absent.
xsd:string local-name(node()? node)
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.
xsd:QName node-name(node()? node)
retourne le nom qualifi du nud node ou du nud courant si node est absent.
xsd:string string(node()? node)
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.
xsd:anyAtomicType* data(node()* list)
retourne les valeurs types des nuds de la liste list.
114
XPath
node() root(node()? node)

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.
xsd:anyURI base-uri(node()? node)
retourne l'URI de base [Section 2.7.4.3] du nud node ou du nud courant si node est absent.
xsd:anyURI document-uri(node()? node)
retourne l'URI de base [Section 2.7.4.3] du document contenant le nud node ou le nud courant si node
est absent.
xsd:anyURI resolve-uri(xsd:string? url, xsd:string? base)
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.
xsd:string* namespace-uri(node()? node)
retourne l'URI qui dfinit l'espace de noms dans lequel se trouve le nud node ou le nud courant si node
est absent.
xsd:string* in-scope-prefixes(node() node)
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.
xsd:string namespace-uri-for-prefix(xsd:string prefix, node() node)
retourne l'URI qui dfinit l'espace de noms auquel est associ le prfixe prefix dans le nud node.
for $i in in-scope-prefixes(.) return concat($i, '=', namespace-uri-forprefix($i, .))
donne une chane forme d'un bloc de la forme prefixe=uri pour chaque espace de noms dclar dans
le nud courant.
6.1.2. Ordre du document

Tous les nuds d'un document XML sont classs suivant un ordre appel ordre du document. Pour les lments,
cet ordre est celui du parcours prfixe de l'arbre du document. Ceci correspond l'ordre des balises ouvrantes
dans le document. Un lment est toujours plac aprs ses anctres et ses frres gauches et avant ses enfants et ses
frres droits. Les attributs et les dclarations d'espaces de noms sont placs juste aprs leur lment et avant tout
autre lment. Les dclarations d'espaces de noms sont places avant les attributs. L'ordre relatif des dclarations
d'espaces de noms et l'ordre relatif des attributs sont arbitraires mais ils restent fixes tout au long du traitement
du document par une application.
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.
115
XPath
6.1.3. Modle de donnes

Les expressions XPath manipulent des valeurs qui sont soit des nuds de l'arbre d'un document XML, soit des
valeurs atomiques. Les principales valeurs atomiques sont les entiers, les nombres flottants et les chanes de
caractres. La donne universelle de XPath est la liste de valeurs. Ces listes ne peuvent pas tre imbriques. Une
liste contient uniquement des valeurs et ne peut pas contenir une autre liste. La longueur de la liste est le nombre
de valeurs qu'elle contient. Les valeurs de la liste sont ordonnes et chaque valeur a une position allant de 1 (et
non pas 0) pour la premire valeur la longueur de la liste pour la dernire valeur.
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:duration, xsd:yearMonthDuration et xsd:dayTimeDuration
Dure : P6Y4M2DT11H22M44S de 6 ans, 4 mois, 2 jours, 11 heures 22 minutes et 44 secondes.
xsd:date, xsd:time et xsd:dateTime
Date et heure : 2009-03-02T11:44:22
xsd:anyURI
URI : http://www.liafa.jussieu.fr/~carton/
xsd:anyType, xsd:anySimpleType et xsd:anyAtomicType
Types racine de la hirarchie
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.
116
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.
6.1.5.1. Contexte statique

On rappelle que la porte d'une dclaration est l'lment qui contient cette dclaration. Pour une dclaration
d'espace de noms [Section 4.2], c'est l'lment contenant l'attribut xmlns. Pour une dclaration de variable
XSLT [Section 8.9], la porte est l'lment parent de l'lment xsl:variable. La porte d'une dfinition d'une
fonction d'extension [Section 8.10] est toute la feuille de style car ces dfinitions sont enfants de l'lment racine.
On dit qu'un objet est en porte dans une expression XPath si l'expression est incluse dans la porte de l'objet en
question. Le contexte statique comprend les objets suivants
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
Toutes les collations [Section 2.2.5] en porte.
URI de base
117
XPath
URI de base [Section 2.7.4.3] de l'lment.
6.1.5.2. Contexte dynamique

La partie importante du contexte dynamique est appele le focus et elle comprend trois valeurs appeles objet
courant (context item dans la terminologie du W3C), position dans le contexte et taille du contexte. Le focus peut
voluer au cours de l'valuation d'une expression.
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.
Valeurs des variables
Les valeurs de toutes les variables [Section 8.9] en porte.
Dfinition des fonctions
Toutes les dfinitions des fonctions d'extension [Section 8.10].
6.1.6. Fonctions de conversion

XSLT 1.0 possde une fonction number() pour convertir une valeur quelconque en un entier.
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].
6.1.7. Fonctions externes

Certaines fonctions pouvant tre utilises dans les expressions XPath sont, en ralit, fournies par le langage hte.
Le langage XSLT [Chapitre 8] fournit, en particulier, quelques fonctions trs utiles. Il permet galement de dfinir
de nouvelles fonctions [Section 8.10].
xsd:string format-number(number n, xsd:string format, xsd:ID id)
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.
xsd:string generate-id(node()? node)
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
118
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-eachgroup [Section 8.7.4].
xsd:string current-grouping-key()
retourne la cl courante lors de l'utilisation de l'lment XSLT xsl:for-each-group [Section 8.7.4].
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].
6.2. Expressions de chemins

Le premier objectif de XPath est, comme son nom l'indique, d'crire des chemins dans l'arbre d'un document XML.
Ces chemins dcrivent des ensembles de nuds du document qu'il est ainsi possible de manipuler. Le cur de
XPath est constitu des oprateurs de chemins qui permettent l'criture des chemins.
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.
6.2.1. Expressions de cheminement

Les expressions de cheminement permettent de se dplacer dans l'arbre d'un document en passant d'un nud
d'autres nuds. Une expression de cheminement a la forme axe::type. Elle retourne l'ensemble des nuds du
type de nud type qui sont relis au nud courant par la relation axe. Parmi tous les nuds, l'axe effectue une
premire slection base sur la position des nuds dans l'arbre par rapport au nud courant. Le type raffine ensuite
cette slection en se basant sur le type et le nom des nuds [Section 6.1.1]. La slection peut encore tre affine
par des filtres [Section 6.2.2]. Si l'objet courant n'est pas un nud, l'valuation d'une telle expression provoque une
erreur. Les diffrents types correspondent aux diffrents nuds pouvant apparatre dans l'arbre d'un document.
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.
119
XPath
self
Le nud lui-mme (galit)
child
Enfant direct
parent
Parent
attribute
Attribut du nud
descendant
Descendant strict
descendant-or-self
Descendant ou le nud lui-mme
120
XPath
ancestor
Anctre strict
ancestor-or-self
Anctre ou le nud lui-mme
preceding-sibling
Frre gauche (enfant du mme parent)
following-sibling
Frre droit (enfant du mme parent)
preceding
gauche
following
droite
121
XPath
namespace
Espace de noms du nud
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.
Les cinq axes self, parent, child, preceding-sibling et following-sibling slectionnent le
nud lui-mme et les nuds proches comme le montre la figure ci-dessous. Les nuds slectionns par ces cinq
axes sont le nud lui-mme pour self, le nud juste au dessus pour parent, les nuds juste en dessous pour
child, les nuds juste gauche pour preceding-sibling et les nuds juste droite pour followingsibling.
parent
self
preceding-sibling
following-sibling
child
Figure 6.2. Nuds proches

Au contraire, les quatre axes ancestor, preceding, descendant et following slectionnent des nuds
qui peuvent tre trs loigns du nud courant. Avec l'axe self, ces quatre axes partitionnent l'ensemble de tous
les nuds du document en cinq zones disjointes comme le montre la figure ci-dessous.
Root
Ancest or
Self
Preceding
Following
Descendant
Figure 6.3. Partitionnement des lments selon les cinq axes
122
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.
*
tous les lments ou tous les attributs suivant l'axe utilis
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()
tous les nuds
text()
tous les nuds textuels
comment()
tous les commentaires
processing-instruction() ou processing-instruction(name)
toutes les instructions de traitement ou les instructions de traitement de nom name
Les types node(), text(), comment() et processing-instruction() se prsentent comme des
pseudo fonctions sans paramtre. Les parenthses sont indispensables car les expressions text et text()
s'valuent diffremment. L'expression text retourne les lments de nom text qui sont enfants du nud courant
alors que l'expression text() retourne les nuds textuels qui sont enfants du nud courant. Il faut, galement,
distinguer l'expression string qui s'value en une liste de nuds de nom string des expressions 'string'
et "string" qui s'valuent en une chane de caractres.
child::* ou *
tous les lments qui sont enfants du nud courant
attribute::* ou @*
tous les attributs du nud courant
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()
tous les nuds textuels qui sont enfants du nud courant
123
XPath
descendant::comment()
tous les commentaires qui sont descendants du nud courant, c'est--dire contenus dans le nud courant
following::processing-instruction()
toutes les instructions de traitement qui suivent le nud courant.
child::processing-instruction('xml-stylesheet')
toutes les instructions de traitement de nom xml-stylesheet qui sont enfants du nud courant.
6.2.2. Filtres des expressions de cheminement

Les filtres [Section 6.4.2] permettent de d'extraire d'une liste les objets qui satisfont une condition pour former
une nouvelle liste. Ils apparaissent beaucoup dans les expressions de chemin pour restreindre le rsultat d'une
expression de cheminement. Nous donnons ici quelques exemples d'utilisation de ces filtres. Lorsque ces
expressions XPath apparaissent comme valeur d'attributs, il est ncessaire de remplacer les caractres spciaux
'<' et '>' par les entits prdfinies [Section 3.5.1.2].
child::*[position() < 4] ou *[position() < 4]
les trois premiers lments enfants du nud courant
attribute::*[name() != 'id'] ou @*[name() != 'id']
tous les attributs autres que id. Cette expression peut aussi tre crite @* except @id.
child::node()[position() = 4] ou node()[4]
le quatrime enfant du nud courant
child::section[position() = last()] ou section[position() = last()]
dernier enfant section du nud courant
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]
lment chapter ayant au moins deux lments section comme enfants.
6.2.3. Oprateur '/' de composition de chemins

L'oprateur '/' permet de composer des expressions de cheminement pour crer de vritables chemins dans un
arbre XML. C'est un des oprateurs cl de XPath. Sa smantique est proche du mme oprateur '/' des shell
Unix mais il est plus gnral et pas toujours facile apprhender
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
124
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]
sibling::em[1]
premier frre em d'un lment p descendant du nud courant.
ou
.//p/following-
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
125
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
6.2.4. Expressions ensemblistes

Les oprateurs sur les ensembles ralisent les oprations d'union, d'intersection et de diffrences sur les ensembles
de nuds reprsents par des listes classes dans l'ordre du document. L'oprateur d'union est trs souvent utilis
alors que les deux autres oprateurs le sont plus rarement.
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.
child::* union attribute::* ou * | @*
tous les attributs et tous les lments enfants du nud courant
*:* except xsl:*
tous les lments enfants du nud courant qui ne sont pas dans l'espace de noms associ au prfixe xsl
@* except @id
tous les attributs except l'attribut id
descendant::* intersect descendant::p/following::*
tous les lments descendants du nud courant qui suivent un lment p galement descendant du nud
courant
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
126
XPath
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.
6.3. Valeurs atomiques

Bien que XPath traite principalement des nuds d'un document XML, il lui faut aussi manipuler des valeurs
atomiques afin de slectionner de faon prcise les nuds. Cette partie dtaille les diffrents types pour les valeurs
atomiques ainsi que les fonctions oprant sur ces valeurs.
6.3.1. Expressions boolennes

Le type boolen xsd:boolean [Section 5.5.1.1] contient les deux valeurs true et false. Ces deux valeurs
sont retournes par les fonctions true() et false() sans paramtre. Les parenthses sont obligatoires car
l'expression XPath true donne les lments true enfants du nud courant.
Les valeurs boolennes peuvent tre manipules l'aide des oprateurs and et or et de la fonction not().
true() and false()
false
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 vide est convertie en false.
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.
Un nombre est converti en true sauf s'il vaut 0 ou NaN.
Une chane de caractres est convertie en true sauf si elle est vide.
Les autres cas provoquent une erreur.
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
127
XPath
xsd:boolean('string')
donne true car la chane de caractres n'est pas vide
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].
Fonctions sur les nombres

Oprateurs '+', '-' et '*'
Ces oprateurs calculent respectivement la somme, la diffrence et le produit de deux nombres entiers,
dcimaux ou flottants.
2+3, 2-3, 2*3
5, -1, 6
Oprateur div
Cet oprateur calcule le quotient de la division de deux nombres entiers, dcimaux ou flottants.
3 div 2, 4.5 div 6.7
1.5, 0.671641791044776119
Oprateurs idiv et mod
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.
floor(1), floor(2.5), floor(2,7), floor(-2.5)
1, 2, 2, -3
number ceiling(number x)
retourne la valeur entire approche par valeur suprieure d'un nombre dcimal ou flottant.
ceiling(1), ceiling(2.5), ceiling(2.3), ceiling(-2.5)
1, 3, 3, -2
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(1), round(2.4), round(2.5), round(-2.5)
1, 2, 3, -2
number round-half-to-even(number x, xsd:integer? precision)
retourne le multiple de 10-precision le plus proche du nombre dcimal ou flottant x. La valeur par dfaut de
precision est 0. Dans ce cas, la fonction retourne l'entier le plus proche de x. Si x est gale distance de
deux multiples, c'est--dire si sa valeur est de la forme (n+1/2)10-precision, la fonction retourne le multiple pair.
128
XPath
round-half-to-even(12.34,-1), round-half-to-even(12.34,1)
10, 12.3
round-half-to-even(2.5), round-half-to-even(3.5)
2, 4
xsd:anyAtomicType min(xsd:anyAtomicType* list, xsd:string? col)
retourne le minimum d'une liste de valeurs comparables pour l'ordre lt. Le paramtre optionnel col
spcifie la collation [Section 2.2.5] utiliser pour comparer des chanes de caractres. Les valeurs sans type,
c'est--dire de type xs:untypedAtomic, sont converties, au pralable, en flottants par xsd:double()
[Section 6.1.6].
min(1 to 6), min(('Hello', 'new', 'world'))
1, 'Hello'
xsd:anyAtomicType max(xsd:anyAtomicType* list, xsd:string? col)
retourne le maximum d'une liste de valeurs comparables pour l'ordre lt. Le paramtre optionnel col spcifie
la collation utiliser pour comparer des chanes de caractres. Les valeurs sans type, c'est--dire de type
xs:untypedAtomic, sont converties, au pralable, en flottants par xsd:double().
number sum(xsd:anyAtomicType* list)
retourne la somme d'une liste de nombres. Les valeurs qui ne sont pas des nombres sont converties au pralable
en flottants avec xsd:double().
sum(1 to 6)
21
number avg(xsd:anyAtomicType* list)
retourne la moyenne d'une liste de nombres. Les valeurs qui ne sont pas des nombres sont converties, au
pralable, en flottants avec xsd:double().
avg(1 to 6)
3.5
6.3.3. Chanes de caractres

Les chanes de caractres XPath contiennent, comme les documents XML, des caractres Unicode.
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
'Une apostrophe '' et un guillemet "'
donne Une apostrophe ' et un guillemet "
"Une apostrophe ' et un guillemet """
donne Une apostrophe ' et un guillemet "
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.
129
XPath
Fonctions sur les chanes de caractres

xsd:integer string-length(xsd:string s)
retourne la longueur de la chane de caractres, c'est--dire le nombre de caractres qui la composent.
string-length('Hello world')
11
xsd:string concat(xsd:string s1, xsd:string s2, xsd:string s3, ...)
retourne la concatnation des chanes de caractres s1, s2, s3, . Le nombre de paramtres de cette fonction
est variable.
concat('Hello', 'new', 'world')
'Hellonewworld'
xsd:string string-join(xsd:string* list, xsd:string sep)
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.
string-join(('Hello', 'new', 'world'), ' ')
'Hello new world'
xsd:integer compare(xsd:string s1, xsd:string s2, xsd:anyURI? col)
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. Celleci est base sur les codes Unicode.
compare('Hello', 'world')
-1
compare('hello', 'World')
1
xsd:boolean starts-with(xsd:string s, xsd:string prefix)
retourne true si la chane s commence par la chane prefix et false sinon.
xsd:boolean ends-with(xsd:string s, xsd:string suffix)
retourne true si la chane s se termine par la chane suffix et false sinon.
xsd:boolean contains(xsd:string s, xsd:string factor)
retourne true si la chane factor apparat comme sous-chane dans la chane s et false sinon.
contains('Hello', 'lo')
true
xsd:boolean matches(xsd:string s, xsd:string regexp, xsd:string? flags)
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 world', '\w+')
true
130
XPath
matches('Hello world', '^\w+$')

false
matches('Hello', '^\w+$')
true
xsd:string substring(xsd:string s, xsd:double start xsd:double length)
retourne la sous-chane commenant la position start et de longueur length ou moins si la fin de la
chane s est atteinte. Les positions dans la chane s1 sont numrotes partir de 1. Les paramtres start
et length sont des flottants par compatibilit avec XPath 1.0. Ils sont convertis en entiers avec round().
substring('Hello world', 3, 5)
'llo w'
substring('Hello world', 7, 10)
'world'
xsd:string substring-before(xsd:string s1, xsd:string s2)
retourne la sous-chane de s1 avant la premire occurrence de la chane s2 dans s1.
substring-before('Hello world', 'o')
'Hell'
substring-before('Hello world', 'ol')
''
xsd:string substring-after(xsd:string s1, xsd:string s2)
retourne la sous-chane de s1 aprs la premire occurrence de la chane s2 dans s1.
substring-after('Hello world', 'o')
' world'
substring-after('Hello world', 'ol')
''
xsd:string translate(xsd:string s, xsd:string from, xsd:string to)
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.
translate('Hello world', 'lo', 'ru')
'Herru wurrd'
translate('01-44-27-45-19', '-', '')
'0144274519'
xsd:string replace(xsd:string
xsd:string? flags)
s,
xsd:string
regexp,
xsd:string
repl,
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, .
replace('Hello world', 'o', 'u')
'Hellu wurld' o chaque caractre 'o' a t remplac par le caractre 'u'
replace('="\'\"=', '(["\\])', '\\$1')
'=\"\\'\\\"=' o un caractre '\' a t insr devant chaque caractre '"' ou '\'
131
XPath
replace('(code,1234)', '$([^,]*),([^$]*)\)', '($2,$1)')

'(1234,code)' o les textes dlimits par '(', ',' et ')' ont t changs
xsd:string* tokenize(xsd:string s, xsd:string regexp)
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 new world', '\s+')
('Hello', 'new', 'world')
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].
normalize-space(' Hello &x0A; world ')
'Hello world' o les deux espaces et le retour la ligne au milieu ont t remplacs par un seul
espace et o les espaces au dbut et la fin ont t supprims
xsd:string lower-case(xsd:string s)
retourne la chane s mise en minuscule.
lower-case('Hello world')
'hello world'
xsd:string upper-case(xsd:string s)
retourne la chane s mise en majuscule.
upper-case('Hello world')
'HELLO WORLD'
xsd:string codepoints-to-string(xsd:integer* list)
convertit une liste de points de code [Section 2.2] en une chane de caractres.
codepoints-to-string((65, 8364, 48))
'A0'
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)
xsd:string normalize-unicode(xsd:string s, xsd:string? norm)
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.
string-to-codepoints(normalize-unicode(codepoints-to-string((105,
776))))
(239)
132
XPath
6.3.4. Expressions rationnelles

Quelques fonctions XPath comme matches(), replace() et tokenize() prennent en paramtre une
expression rationnelle. La syntaxe de ces expressions est identique celle des expressions rationnelles des schmas
[Section 5.15] avec seulement quelques diffrences.
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.
matches('Hello world', '\w+')
donne true car les fragments Hello ou world sont conformes l'expression \w+.
matches('Hello world', '^\w+$')
donne false car la chane contient un espace.
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.
matches('Hello world', 'hello')
donne false.
matches('Hello world', 'hello', 'i')
donne true.
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.
matches('Hello
world', '^Hello$', 'm')
donne true.
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.
matches('Hello
world', '^.*$', 's')
donne true.
133
XPath
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.
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, 'Two', 3.14, true()
donne la liste (1, 'Two', 3.14, true) constitue d'un entier, d'une chane de caractres, d'un nombre
flottant et d'une valeur boolenne.
(1, 2), 3, (4, (5))
donne la liste (1, 2, 3, 4, 5) sans imbrication.
(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.
134
XPath
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]
donne la liste (2,4) des entiers pairs de la liste
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.
text[position() > 1 and position() < 4]
donne les enfants text du nud courant aux positions 2 et 3
text[position() > 1][position() < 4]
donne les enfants text du nud courant aux positions 2, 3 et 4
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)
retourne true si la liste l est vide et false sinon.
empty(1 to 5)
false
xsd:boolean exists(item()* l)
retourne true si la liste l est non vide et false sinon.
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.
135
XPath
distinct-values((1, 'Hello', 0, 1, 'World'))

(1, 'Hello', 0, 'World')
xsd:integer* index-of(item()* l, item() value)
retourne la liste des positions de la valeur value dans la liste l.
index-of((1, 'Hello', 0, 1, 'World'), 1)
(1, 4)
item()* subsequence(item()* l, xsd:double start xsd:double length)
retourne la sous-liste commenant la position start et de longueur length ou ventuellement moins si
la fin de la liste l est atteinte.
subsequence((1, 'Hello', 0, 1, 'World'), 2, 3)
('Hello', 0, 1)
item()* remove(item()* l, xsd:integer pos)
retourne la liste obtenue en supprimant de la liste l la valeur la position pos.
remove(1 to 5, 3)
(1, 2, 4, 5)
item()* insert-before(item()* l1, xsd:integer pos, item()* l2)
retourne la liste obtenue en insrant la liste l2 dans la liste l1 la position pos.
insert-before(1 to 5, 3, 1 to 3)
(1, 2, 1, 2, 3, 3, 4, 5)
item()* reverse(item()* l)
retourne la liste obtenue en inversant l'ordre
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.
6.5.1. Oprateurs de comparaisons atomiques

136
XPath
Les oprateurs de comparaison pour les valeurs atomiques sont les oprateurs eq, ne, lt, le, gt et ge. Ils
permettent respectivement de tester l'galit, la non-galit, l'ordre strict et l'ordre large (avec galit) entre deux
valeurs de mme type. L'ordre pour les entiers et les flottants est l'ordre naturel alors que l'ordre pour les chanes
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.
6.5.2. Oprateurs gnraux de comparaisons

Les oprateurs gnraux de comparaison sont les oprateurs '=', '!=', '<', '<=', '>' et '>='. Ils permettent
respectivement de tester l'galit, la non-galit, l'ordre strict et l'ordre large de deux valeurs de types quelconques.
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.
6.5.2.1. Comparaisons de valeurs atomiques

La faon de raliser une comparaison entre deux valeurs atomiques dpend du type [Section 6.1.4] de ces deux
valeurs. Suivant les types de celles-ci, certaines conversions sont effectues au pralable puis elles sont compares
avec l'oprateur de comparaison atomique correspondant donn par la table suivante.
Oprateur gnral
Oprateur atomique
eq
!=
ne
<
lt
<=
le
>
gt
>=
ge
137
XPath
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
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.
Pour illustrer ces comparaisons, on considre le petit document suivant.
<list>
<item type="1">1</item>
<item type="1.2">4</item>

<item type="str">5</item>
</list>
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.
6.5.2.2. Comparaisons de listes

Les comparaisons entre listes ont une smantique trs particulire qui est parfois pratique mais souvent contraire
l'intuition. Ce cas s'applique ds qu'un des deux objets compars est une liste puisqu'une valeur est identifie
une liste de longueur 1. La comparaison entre deux listes l1 et l2 pour un des oprateurs =, !=, <, <=, > et >=
est effectue de la faon suivante. Chaque valeur de la liste l1 est compare avec chaque valeur de la liste l2
pour le mme oprateur, comme dcrit la section prcdente. Le rsultat global est gal true ds qu'au moins
une des comparaisons donne la valeur true. Il est gal false sinon. Cette stratgie implique en particulier
que le rsultat est false ds qu'une des deux listes est vide quel que soit l'oprateur de comparaison.
() = ()
donne false car une des deux listes est vide.
138
XPath
() != ()
L'exemple prcdent montre que l'oprateur != n'est pas la ngation de l'oprateur =, ce qui n'est pas trs intuitif.
() != (1)
(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).
6.5.3. Oprateurs de comparaisons de nuds

L'oprateur is compare deux nuds et retourne true s'il s'agit du mme nud. C'est donc plus un test d'identit
que d'galit. Il s'apparente plus l'oprateur '==' de Java qu' la mthode equals du mme langage.
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].
Pour illustrer ces trois oprateurs, on considre le document minimaliste suivant.
<list length="2">
</list>
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.
list << list/item[1]
donne true car le pre est plac avant ses enfants dans l'ordre du document.
139
XPath
list/@length << list/item[1]

donne true car les attributs sont placs avant les lments enfants.
list/item[1] << list/item[2]
donne true.
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.
6.6. Structures de contrle

Des structures de contrle sont apparues avec la version 2.0 de XPath. L'objectif n'est pas d'crire des programmes
complets en XPath. Il s'agit plutt de remplacer par des expressions XPath simples des constructions plus lourdes
des langages htes. Il est, par exemple, plus concis d'crire le fragment XSLT [Chapitre 8] suivant avec un test dans
l'expression XPath. Dans l'exemple suivant, l'lment a contient une expression XPath en attribut [Section 8.6.3]
dont le rsultat devient la valeur de son attribut id. Cette expression retourne la valeur de l'attribut xml:id de
l'lment courant si cet attribut existe ou gnre un nouvel identifiant sinon.
<a id="{if (@xml:id) then @xml:id else generate-id()}"/>
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.
if (test) then expr1 else expr2
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 ().
if (contains($url, ':')) then substring-before($url, ':') else ''
l'valuation de cette expression retourne le protocole d'une URL [Section 2.3] plac avant le caractre ':'
si celle-ci en contient un.
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
140
XPath
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.
for var in expr1 return expr2
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
for $i in 1 to 3 return (2 * $i, 2 * $i + 1)
l'valuation de cette expression donne la liste (2,3,4,5,6,7) qui est la concatnation des trois listes
(2,3), (4,5) et (6,7)
for $i in 1 to 5 return if ($i mod 2) then () else $i * $i
l'valuation de cette expression donne la liste (4,16) des carrs des deux nombres pairs 2 et 4 pour lesquels
$i mod 2 donne 0
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.
for var-1 in expr-1, , var-N in expr-N return expr
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)
6.6.3. Quantification existentielle

L'oprateur some permet de vrifier qu'au moins un des objets d'une liste satisfait une condition. Sa syntaxe est
la suivante.
some var in expr1 satisfies expr2
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.
some $i in 0 to 5 satisfies $i > 4
l'valuation de cette expression donne la valeur true car la condition $i > 4 est satisfaite pour $i = 5
6.6.4. Quantification universelle

141
XPath
L'oprateur every permet de vrifier que tous les objets d'une liste satisfont une condition. Sa syntaxe est la
suivante.
every var in expr1 satisfies expr2
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.
every $i in 0 to 5 satisfies $i > 4
l'valuation de cette expression donne la valeur false car la condition $i > 4 n'est pas satisfaite pour
$i = 0 ou $i = 1
every $i in 0 to 5 satisfies some $j in 0 to 5 satisfies $i + $j eq 5
l'valuation de cette expression donne la valeur true
6.7. Syntaxe abrge

Les constructions les plus frquentes des expressions XPath peuvent tre abrges de faon avoir des expressions
plus concises. Les abrviations possibles sont les suivantes.
' '
l'axe child:: peut tre omis.
..
est l'abrviation de parent::node().
@
est l'abrviation de attribute::.
//
est l'abrviation de /descendant-or-self::node()/.
[n]
est l'abrviation de [position()=n] o n est un entier.
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.
142
XPath
Les seuls oprateurs utiliss dans les motifs sont les oprateurs '|', '/' et '//' et leur imbrication est trs
restreinte. Un motif prend ncessairement la forme suivante
expr-1 | expr-2 | ... | expr-N
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
*
tous les lments
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
@*
tous les attributs
section/@lang
tous les attributs lang des lments section
text()
tous les nuds textuels
6.9. Utilisation interactive de xmllint

Le logiciel xmllint possde un mode interactif avec lequel il est possible de se dplacer dans un document XML
comme s'il s'agissait d'un systme de fichiers. Les nuds du documents XML sont assimils des rpertoires
143
XPath
(dossiers) et fichiers. Ce mode interactif s'apparente un interprteur de commandes (shell) dont le rpertoire de
travail devient le nud courant. Les commandes permettent de se dplacer dans le document en changeant le nud
courant et en valuant des expressions XPath par rapport ce nud courant. L'intrt de ce mode interactif rside
bien sr dans la possibilit d'exprimenter facilement les expressions 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.
Une session d'exprimentation du mode interactif de xmllint avec le fichier de bibliographie
bibliography.xml est prsente ci-dessous.
bash $ xmllint --shell bibliography.xml
/ > grep XML
/bibliography/book[1]/title : t-27 XML langage et applications
/bibliography/book[2]/title : t-14 XML by Example
/bibliography/book[5]/title : t-46 Modlisation et manipulation ...
/bibliography/book[6]/title : t-25 XML Schema et XML Infoset
/bibliography/book[7]/title : ta3 XML
/ > xpath bibliography/book[@lang='en']
Object is a Node Set :
Set contains 2 nodes:
1 ELEMENT book
ATTRIBUTE key
TEXT
content=Marchal00
ATTRIBUTE lang
TEXT
content=en
2 ELEMENT book
ATTRIBUTE key
TEXT
content=Zeldman03
ATTRIBUTE lang
TEXT
content=en
/ > cd bibliography/book[3]
book > xpath @lang
Object is a Node Set :
Set contains 1 nodes:
144
XPath
ATTRIBUTE lang
TEXT
content=fr
book > cd ..
bibliography >
6.10. Rcapitulatif des oprateurs XPath

Oprateur
Action
Syntaxe
Exemples
Concatnation de listes
E1,E2
1,'Two',3.14,true()
for
Itration
for $i in E1 return for $i in 1 to 5

E2
return $i * $i
some
Quantification existentielle some

$i
in
satisfies E2
E1
every
Quantification universelle every $i in

satisfies E2
E1
if
Test
if (E1)
else E3
E2 if ($x > 0) then $x

else 0
Enchanement
E1/E2
[ ]
Prdicat
E1[E2]
and or not
Oprations logiques
E1 or E2
to
Intervalle
E1 to E2
eq ne lt le gt ge
Comparaisons de valeurs E1 eq E2
atomiques
$x lt $y
= != < <= > >=
Comparaisons gnrales
E1 = E2
$x < $y
<< is >>
Comparaisons de nuds
E1 is E2
+ * - div idiv
Oprations arithmtiques
E1 + E2
|
union Oprations sur les listes de E1 | E2
intersection
nuds
except
instance of cast as Changements de type
castable as treat
as
then
chapter[count(section)
> 1]
1 to 5
$price * $qty
/|*
E1 instance of type $x
instance
xsd:string
145
of
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.

On donne ci-dessous un premier exemple de schematron trs simple. Il contient une seule rgle qui s'applique
aux lments list du document. Pour chacun de ces lments, la valeur de l'attribut length doit tre gale
au nombre d'enfants.
<sch:schema xmlns:sch="http://purl.oclc.org/dsdl/schematron">
<sch:title>Premier exemple de schematron</sch:title>
<sch:pattern>
<sch:rule context="list">
<sch:assert test="@length = count(*)">
L'attribut length doit tre gal au nombre d'enfants.
</sch:assert>
</sch:rule>
</sch:pattern>
</sch:schema>
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'lments." 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.
<lists>
<list length="3">
<item>A</item><item>B</item><item>C</item>
</list>
<list length="4">
<item>1</item><item>2</item><item>3</item>
</list>
</lists>
146
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
Figure 7.1. Validation avec un schematron

Il existe plusieurs implmentations de schematron souvent bases sur XSLT [Chapitre 8]. Les deux phases sont
ralises par l'application de feuilles de style XSLT. Une premire feuille de style XSLT transforme le schematron
en une autre feuille de style XSLT qui constitue la version compile du schematron. Cette dernire feuille de style
est applique au document pour produire le rapport.
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
147
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.
<?xml version="1.0" standalone="yes"?>
<svrl:schematron-output xmlns:svrl="http://purl.oclc.org/dsdl/svrl"
xmlns:sch="http://purl.oclc.org/dsdl/schematron"
title="Comparaison attribut/nombre d'enfants"
schemaVersion="ISO19757-3">
<svrl:active-pattern/>
<svrl:fired-rule context="list"/>
<svrl:fired-rule context="list"/>
<svrl:failed-assert test="@length = count(*)" location="/lists/list[2]">
<svrl:text>L'attribut length doit tre
gal au nombre d'enfants.</svrl:text>
</svrl:failed-assert>
</svrl:schematron-output>
7.4. Structure globale d'un schematron

L'ensemble d'un schematron est contenu dans un lment sch:schema. L'espace de noms [Chapitre 4] des
schematrons est identifi par l'URI http://purl.oclc.org/dsdl/schematron. Il existe des versions
antrieures des schematrons qui utilisaient un autre espace de noms. Le prfixe gnralement associ l'espace de
noms est sch comme dans cet ouvrage ou aussi iso pour bien distinguer la version ISO actuelle des schematrons
des anciennes versions.
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].
7.4.1. Espaces de noms cible

Lorsque les lments des documents valider appartiennent un ou des espaces de noms, il est ncessaire de
les dclarer dans le schematron et de leur associer des prfixes. Les prfixes sont ncessaires pour nommer
correctement les lments dans les expressions XPath des rgles. Il faut en effet utiliser des noms qualifis.
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.
<sch:schema queryBinding="xslt" schemaVersion="ISO19757-3"
xmlns:sch="http://purl.oclc.org/dsdl/schematron">
<sch:title>Comparaison attribut/nombre d'enfants</sch:title>

<sch:ns prefix="tns" uri="http://www.liafa.jussieu.fr/~carton/"/>
<sch:pattern>

<sch:rule context="tns:list">
<sch:assert test="@length = count(*)">
L'attribut length doit tre gal au nombre d'lments.
</sch:assert>
</sch:rule>
</sch:pattern>
</sch:schema>
148
Schematron
7.4.2. Rgles et blocs

Les rgles d'un schematron sont regroupes en blocs. Chacun de ces blocs est introduit par un lment
sch:pattern.
<sch:schema xmlns:sch="http://purl.oclc.org/dsdl/schematron">
...
<sch:pattern>
...
</sch:pattern>
<sch:pattern>
...
</sch:pattern>
...
</sch:schema>
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>
...
</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.4.3. Titres et commentaires

Le schematron ainsi que chacun de ses blocs peuvent tre comments. Les lments sch:schema et
sch:pattern peuvent avoir comme enfant un lment sch:title pour donner un titre. Ils peuvent aussi
contenir des lments sch:p prvus pour donner des descriptions plus dtailles. Les contenus des lments
sch:title et sch:p sont souvent repris pour la construction du rapport.
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.
149
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: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.
150
Schematron
7.5.1. Variables locales

Une rgle peut dfinir des variables locales introduites par des lments sch:let. Celles-ci mmorisent le rsultat
d'un calcul intermdiaire pour des utilisations dans la rgle. Chaque lment sch:let a des attributs name et
value pour spcifier le nom et la valeur de la variable. L'attribut value doit contenir une expression XPath qui
donne sa valeur la variable. Cette valeur ne peut plus ensuite tre modifie. Les lments sch:let doivent tre
les premiers enfants de l'lment sch:rule. La variable ainsi dclare est disponible dans toute la rgle.
<sch:title>Tests sur les heures</sch:title>
<sch:pattern>
<sch:rule context="time">
<sch:let name="hour" value="number(substring(.,1,2))"/>
<sch:let name="min" value="number(substring(.,4,2))"/>
<sch:let name="sec" value="number(substring(.,7,2))"/>

<sch:assert test="string-length(.) = 8 and substring(.,3,1) = ':' and
substring(.,6,1) = ':'">
L'heure <sch:value-of select="."/> doit tre au format HH:MM:SS.
</sch:assert>
<sch:assert test="$hour >= 0 and $hour <= 23">
Le nombre d'heures doit tre compris entre 0 et 23.
</sch:assert>
<sch:assert test="$min >= 0 and $min <= 59">
Le nombre de minutes doit tre compris entre 0 et 59.
</sch:assert>
<sch:assert test="$sec >= 0 and $sec <= 59">
Le nombre de secondes doit tre compris entre 0 et 59.
</sch:assert>
</sch:rule>
</sch:pattern>
</sch:schema>
7.6. Rgles abstraites

Le principe gnral des rgles abstraites est d'avoir des rgles gnriques susceptibles de s'appliquer diffrents
contextes. Le contexte d'une rgle, c'est--dire l'ensemble des nuds sur lesquels elle s'applique est normalement
donn par son attribut context. Il est possible de dfinir une rgle sans contexte qui dfinit seulement des
contraintes. Elle ne peut pas tre utilise directement mais d'autres rgles l'utilisent en spcifiant le contexte.
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.
<sch:title>Utilisation de rgles abstraites</sch:title>
<sch:pattern>

151
Schematron
<sch:rule abstract="true" id="has-title">

<sch:assert test="*[1][self::title]">
L'lment <sch:name/> doit avoir un enfant title qui
doit tre le premier enfant.
</sch:assert>
</sch:rule>

<sch:extends rule="has-title"/>
<sch:assert test="chapter">
Le livre soit contenir au moins un chapitre.
</sch:assert>
</sch:rule>

<sch:rule context="chapter">
<sch:extends rule="has-title"/>
<sch:assert test="para">
Le chapire soit contenir au moins un paragraphe.
</sch:assert>
</sch:rule>
</sch:pattern>
</sch:schema>
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.
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<book>
<title>Titre du livre</title>
<chapter>
<title>Premier chapitre</title>
<para>Ceci est le premier chapitre ...</para>
</chapter>
<chapter>
<para>Paragraphe avant le titre ...</para>
<title>Titre mal plac</title>
<para>Second paragraphe du second chapitre aprs le titre ...</para>
</chapter>
<chapter>
<para>Chapitre sans titre</para>
</chapter>
</book>
7.7. Blocs abstraits

Les blocs abstraits gnralisent le principe des rgles abstraites. Ils dclarent des rgles qui peuvent s'appliquer
diffrentes situations. Leur principe de fonctionnement est proche de celui des fonctions de n'importe quel langage
de programmation. Un bloc abstrait contient des rgles qui utilisent des paramtres. Ce bloc est alors utilis par
d'autres blocs qui instancient les paramtres en leur donnant des valeurs explicites.
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:applytemplates et xsl:call-template [Section 8.9.2] de XSLT. En revanche, l'lment sch:param des
152
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.
<sch:title>Utilisation de blocs abstraits</sch:title>

<sch:pattern abstract="true" id="uniq">

<sch:rule context="$elem">
<sch:assert test="$desc">
L'lment <sch:name/> doit avoir un descendant $desc.
</sch:assert>
<sch:report test="count($desc) > 1">
L'lment <sch:name/> doit avoir un seul descendant $desc.
</sch:report>
</sch:rule>
</sch:pattern>

<sch:pattern is-a="uniq" id="uniq-id">
<sch:param name="elem" value="book"/>
<sch:param name="desc" value="@id|@key"/>
</sch:pattern>
<sch:pattern is-a="uniq" id="uniq-title">
<sch:param name="elem" value="book"/>
<sch:param name="desc" value="title"/>
</sch:pattern>
</sch:schema>
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.
<sch:title>Substitution des blocs abstraits</sch:title>
<sch:pattern id="uniq-id">
L'lment <sch:name/> doit avoir un descendant @id|@key
</sch:assert>
<sch:report test="count(@id|@key) > 1">
153
Schematron
L'lment <sch:name/> doit avoir un seul descendant @id|@key

</sch:report>
</sch:rule>
</sch:pattern>
<sch:pattern id="uniq-title">
<sch:assert test="title">
L'lment <sch:name/> doit avoir un descendant title
</sch:assert>
<sch:report test="count(title) > 1">
L'lment <sch:name/> doit avoir un seul descendant title
</sch:report>
</sch:rule>
</sch:pattern>
</sch:schema>
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.
xmlns:sch="http://purl.oclc.org/dsdl/schematron"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<sch:title>Vrification des liens is-a des schematrons</sch:title>
<sch:p>Ce schematron vrifie que, dans un schematron, tout bloc rfrenc
par un autre bloc par l'attribut is-a est bien dclar abstrait par
l'attribut abstract avec la valeur true.</sch:p>


<sch:ns prefix="tns" uri="http://purl.oclc.org/dsdl/schematron"/>

<xsl:key name="patid" match="tns:pattern" use="@id"/>
<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.
</sch:report>
154
Schematron
</sch:rule>
</sch:pattern>
</sch:schema>
7.8. Phases de validations

Il est possible de regrouper les blocs en phases. Chaque phase est identifie par un nom. Lors de la validation
d'un document par un schematron, il est possible de spcifier la phase effectuer. Seuls les blocs appartenant
cette phase sont alors pris en compte. Ce mcanisme permet de scinder un schematron en plusieurs parties et de
procder une validation incrmentale d'un document. Chaque phase dclare les blocs qu'elle contient et un bloc
peut appartenir plusieurs phases. Lorsque la validation par schematron est implmente avec XSLT, la phase
est prcise en donnant un paramtre global [Section 8.9.2] la feuille de style XSLT. Il existe une phase par
dfaut appele #ALL qui comprend tous les blocs. Si aucune phase n'est spcifie, la validation utilise tous les
blocs du schematron.
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.
<sch:title>Utilisation de phases</sch:title>

<sch:phase id="phase1">
<sch:active pattern="idkey"/>
</sch:phase>

<sch:phase id="phase2">
<sch:active pattern="count"/>
</sch:phase>

<sch:pattern id="idkey">
L'lment book doit avoir un attribut id ou key
</sch:assert>
</sch:rule>
</sch:pattern>

<sch:pattern id="count">
<sch:rule context="bibliography">
<sch:report test="book">
Il y a <sch:value-of select="count(book)"/> livre(s).
</sch:report>
</sch:rule>
</sch:pattern>
</sch:schema>
155
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.
156
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
Figure 8.1. Principe de XSLT

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.
157
XSLT
8.2. Premier programme : Hello, World!

On commence par la feuille de style XSLT la plus simple. Cette-ci se contente de produire un document XHTML
affichant le message Hello World! dans un titre. Cette feuille de style a donc la particularit de produire un
document indpendant du document source.
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns="http://www.w3.org/1999/xhtml">
<xsl:template match="/">
<html>
<head>
<title>Hello World!</title>
</head>
<body>
<h1>Hello world!</h1>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
lment racine xsl:stylesheet de la feuille de style.
Dclaration de l'espace de noms XSLT associ au prfixe xsl.
Dclaration de l'espace de noms XHTML comme espace de noms par dfaut.
Dfinition d'une rgle s'appliquant la racine '/' du document source.
Fragment de document XHTML retourn par la rgle.
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.
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
</head>
<body>
</body>
</html>
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.
8.3. Modle de traitement

Le document XML source est transform en un document XML rsultat obtenu en appliquant les rgles de la
feuille de style des nuds du document source. Chaque application de rgle un nud produit un fragment de
document XML. Tous ces fragments sont assembls pour former le document rsultat.
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.
158
XSLT
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'endroit o se trouve l'lment xsl:apply-templates
constitue donc le point d'ancrage pour l'insertion du ou des fragments produits par son excution.
La forme globale d'une rgle est donc la suivante.
<xsl:template match="...">

...

<xsl:apply-templates .... />
...

<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 s'insrent dans le document rsultat la place des 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 de mme taille sur la figure mme si les fragments ne sont pas identiques. 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:applytemplates.
159
XSLT
t em plat e
apply-t em plat es
t em plat e
apply-t em plat es
t em plat e
t em plat e
apply-t em plat es
t em plat e
t em plat e
t em plat e
t em plat e
Figure 8.2. Traitement

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. L'espace de noms des lments de XSLT doit
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 est aussi indispensable de dclarer les espaces de noms du document rsultat si celui-ci en utilise. Ces
dclarations d'espaces de noms sont importantes car le contenu de chaque rgle contient un mlange d'lments
XSLT et d'lments du document rsultat.
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 indispensables. L'attribut excluderesult-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.
exclude-result-prefixes="xsl dbk"
xmlns:dbk="http://docbook.org/ns/docbook"
160
XSLT
...
L'lment xsl:output doit tre un enfant de l'lment xsl:stylesheet. Il permet de contrler 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]. Un exemple typique
d'utilisation pour produire un document XHTML est le suivant.
<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"/>
8.4.1. Traitement des espaces

Avant d'appliquer la feuille de style au document source, est effectu un traitement pralable des caractres
d'espacement [Section 2.2.2] dans le document. Ce traitement consiste supprimer certains nuds textuels
ne contenant que des caractres d'espacement. Seuls les nuds textuels contenant uniquement des caractres
d'espacement sont concerns. Les nuds contenant, au moins, un autre caractre ne sont jamais supprims
par ce traitement. L'attribut xml:space [Section 2.7.4.2] ainsi que les lments xsl:strip-space et
xsl:preserve-space contrlent lesquels des nuds textuels sont effectivement supprims.
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.
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" encoding="iso-8859-1" indent="no"/>
<xsl:strip-space elements="strip"/>
<xsl:template match="node()|@*">
<xsl:copy>
<xsl:apply-templates select="node()|@*"/>
</xsl:copy>
</xsl:template>
</xsl:stylesheet>
Le document suivant contient des lments preserve et des lments strip.
161
XSLT

<list>
<sublist>
<preserve>
<p>a b c</p>
<p> a b c </p>
</preserve>
<strip xml:space="preserve">
<p>a b c</p>
<p> a b c </p>
</strip>
<strip>
<p>a b c</p>
<p> a b c </p>
</strip>
</sublist>
<sublist xml:space="preserve">
<strip>
<p>a b c</p>
<p> a b c </p>
</strip>
<strip xml:space="default">
<p>a b c</p>
<p> a b c </p>
</strip>
</sublist>
</list>
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.
<list>
<sublist>
<preserve>
<p>a b c</p>
<p> a b c </p>
</preserve>

<strip xml:space="preserve">
<p>a b c</p>
<p> a b c </p>
</strip>
<strip><p>a b c</p><p> a b c </p></strip>
</sublist>
<sublist xml:space="preserve">

<strip>
<p>a b c</p>
<p> a b c </p>
</strip>

<strip xml:space="default"><p>a b c</p><p> a b c </p></strip>
</sublist>
</list>
8.5. Dfinition et application de rgles

Les deux lments qui constituent le cur de XSLT sont les lments xsl:template et xsl:applytemplates qui permettent respectivement de dfinir des rgles et de les appliquer des nuds. Chaque
162
XSLT
dfinition de rgle par un lment xsl:template prcise, par un motif XPath, les nuds sur lesquels elle
s'applique. Chaque application de rgles par un lment xsl:apply-templates prcise les nuds actifs
auxquels doit tre applique une rgle mais ne spcifie pas du tout la rgle appliquer. Le choix de la rgle
appliquer chaque nud est fait par le processeur XSLT en fonction de priorits entre les rgles [Section 8.5.3].
Ces priorits sont dtermines partir des motifs XPath de chaque rgle. Ce principe de fonctionnement est le
mode normal de fonctionnement de XSLT. Il est, cependant, utile l'occasion d'appliquer une rgle dtermine
un nud. L'lment xsl:call-template permet l'appel explicite d'une rgle par son nom.
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.
8.5.1. Dfinition de rgles

L'lment xsl:template permet de dfinir une rgle. Cet lment est ncessairement enfant de l'lment
racine xsl:stylesheet. L'attribut match qui contient un motif XPath [Section 6.8] dfinit le contexte de
la rgle, c'est--dire, les nuds sur lesquels elle s'applique. L'attribut name donne le nom de la rgle. Un de
ces deux attributs doit tre prsent mais les deux peuvent tre simultanment prsents. L'attribut match permet
la rgle d'tre invoque implicitement par un lment xsl:apply-templates alors que l'attribut name
permet la rgle d'tre appele explicitement par un lment xsl:call-template. Le contenu de l'lment
xsl:template est le fragment de document insrer dans le document rsultat lors de l'application de la rgle.
L'lment xsl:template peut aussi contenir un attribut priority pour fixer la priorit de la rgle ainsi qu'un
attribut mode pour prciser dans quels modes elle peut tre applique.
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.
<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>
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].
8.5.2. Application implicite

L'lment xsl:apply-templates provoque l'application de rgles sur les nuds slectionns par son attribut
select qui contient une expression XPath. L'valuation de cette expression par rapport au nud courant donne
une liste de nuds du document source. chacun de ces nuds devenus actifs, une rgle choisie par le processeur
163
XSLT
XSLT est applique. Le rsultat de ces application de rgles remplace alors l'lment xsl:apply-templates
dans le contenu de l'lment xsl:template pour former le rsultat de la rgle en cours d'application.
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:applytemplates.
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
<html>
<head><title>Bibliographie</title></head>
<body>
<h1>Bibliographie</h1>
<ul><xsl:apply-templates select="bibliography/book"/></ul>
</body>
</html>
</xsl:template>
<xsl:template match="book">

<li><xsl:apply-templates select="*"/></li>
</xsl:template>
...
</xsl:stylesheet>
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
retourns par la fonction XPath id(). 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:co">
<xsl:text>\includegraphics[scale=0.25]{images/callouts/</xsl:text>
<xsl:number level="single" count="dbk:co" format="1"/>
<xsl:text>.pdf}</xsl:text>
</xsl:template>
w<xsl:template match="dbk:callout">
<xsl:text>\item[</xsl:text>

<xsl:for-each select="id(@arearefs)">
<xsl:apply-templates select="."/>
164
XSLT
</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 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 par une autre feuille de style, elle a une priorit d'import infrieure celle qui l'importe. 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 suprieure 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].
8.5.4. Application de rgles moins prioritaires

C'est normalement la rgle de priorit maximale [Section 8.5.3] qui est applique un nud lorsque le processus est
initi par un lment xsl:apply-templates. Il existe galement les deux lments xsl:next-match et
xsl:apply-imports qui permettent d'appliquer une rgle de priorit infrieure. Ces deux lments appliquent
implicitement une rgle l'lment courant et il n'ont donc pas d'attribut select.
L'lment xsl:next-match applique l'lment courant la rgle qui se trouvait juste avant la rgle courante
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.

<xsl:template match="dbk:para">
<p xsl:use-attribute-sets="para"><xsl:apply-templates/></p>
165
XSLT
</xsl:template>

<xsl:template match="dbk:para[@role='right']">
<div style="text-align: right">
<xsl:next-match/>
</div>
</xsl:template>
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.

</xsl:template>
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.


<xsl:import href="general.xsl"/>

<div style="text-align: left">
<xsl:apply-imports/>
</div>
</xsl:template>
8.5.5. Application explicite

L'lment xsl:call-template provoque l'application de la rgle dont le nom est donn par l'attribut
name. Contrairement l'lment xsl:apply-templates qui modifie le nud courant, le contexte et, donc
en particulier, le nud courant [Section 6.1.5.2] ne sont pas modifis par l'application d'une rgle nomme
par xsl:call-template. Le rsultat de l'application de la rgle remplace alors l'lment xsl:calltemplate dans le contenu de l'lment xsl:template pour former le rsultat de la rgle en cours
d'application.
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'enfant n'est pas le dernier. Il est
important que le focus soit prserv l'appel de cette rgle pour que le test position() != last() fonctionne
correctement.
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
...

166
XSLT
</xsl:template>
<xsl:template match="title">

<i><xsl:apply-templates/></i>
<xsl:call-template name="comma"/>
</xsl:template>
<xsl:template match="url">

<tt><xsl:apply-templates/></tt>
</xsl:template>
<xsl:template match="*">
</xsl:template>
<xsl:template name="comma">

<xsl:if test="position() != last()">
<xsl:text>, </xsl:text>
</xsl:if>
</xsl:template>
</xsl:stylesheet>
Les deux lments xsl:apply-templates et xsl:call-template peuvent contenir des lments
xsl:with-param pour spcifier les valeurs de paramtres [Section 8.9.2] que la rgle applique peut avoir
dclars avec l'lment xsl:param.
8.6. Construction de contenu

Chaque application de rgle de la feuille de style produit un fragment du rsultat. Ce fragment est construit partir
du contenu de l'lment xsl:template et d'autres lments permettant d'insrer d'autres nuds calculs.
8.6.1. Contenu brut

Lorsqu'une rgle est applique, tout le contenu de l'lment xsl:template est recopi dans le rsultat
l'exception des lments de l'espace de noms XSLT. Ces derniers sont, en effet, valus par le processeur puis
remplacs par leur valeur. Tout les autres lments ainsi que leur contenu se retrouvent recopis l'identique dans
le document rsultat.
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.
<html>
<head>
</head>
<body>
</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
167
XSLT
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.
<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 !.

<text>Bonjour !</text>
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 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 obtenu en appliquant une rgle chacun des lments book. La seconde rgle de la feuille de style est la
rgle qui est 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. 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.

<html>
<head>
<title>Bibliographie</title>
</head>
<body>
<ul><xsl:apply-templates select="bibliography/book"/></ul>
</body>
</html>
</xsl:template>


<li><xsl:apply-templates/></li>
</xsl:template>

168
XSLT


</xsl:template>
</xsl:stylesheet>
En appliquant la feuille de style prcdente au document bibliography.xml, on obtient le document XHTML
suivant dont l'indentation a t remanie pour une meilleure prsentation.
<?xml version="1.0" encoding="UTF-8"?>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<title>Bibliographie</title>
</head>
<body>
<ul>
<li>XML langage et appplications Alain Michard 2001 Eyrolles
2-212-09206-7 http://www.editions-eyrolles/livres/michard/ </li>
<li>Designing with web standards Jeffrey Zeldman 2003 New Riders
0-7357-1201-8 </li>

...
</ul>
</body>
</html>
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 et elle est donc applique aux lments title et url.


</xsl:template>

<xsl:template match="url">

<tt><xsl:apply-templates/></tt>
</xsl:template>
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.
<?xml version="1.0" encoding="iso-8859-1" ?>
<html>
169
XSLT
<head>
<title>Bibliographie Franais/Anglais</title>
</head>
<body>
<h1>Bibliographie en franais</h1>

<ul><xsl:apply-templates select="bibliography/book[@lang='fr']"/></ul>
<h1>Bibliographie en anglais</h1>

<ul><xsl:apply-templates select="bibliography/book[@lang='en']"/></ul>
</body>
</html>
</xsl:template>

...
</xsl:stylesheet>
8.6.1.1. Substitution d'espaces de noms

Il est parfois souhait qu'une feuille de style XSLT produise une autre feuille de style XSLT comme document
rsultat. Ce mcanisme est, en particulier, mis en uvre par les schematrons [Chapitre 7]. Le problme est que
l'espace de noms XSLT est justement utilis par le processeur pour distinguer les lments XSLT qui doivent tre
excuts des autres lments qui doivent tre recopis dans le rsultat. Il est alors, a priori, impossible de mettre
des lments XSLT dans le document rsultat. L'lment xsl:namespace-alias permet de contourner cette
difficult. Il provoque la conversion d'un espace de noms de la feuille de style en un autre espace de noms dans le
rsultat. Cet lment doit tre enfant de l'lment racine xsl:stylesheet de la feuille de style. Ses attributs
stylesheet-prefix et result-prefix donnent respectivement les prfixes associs l'espace de noms
convertir et de l'espace de noms cible. Ces deux attributs peuvent prendre la valeur particulire #default pour
spcifier l'espace de noms par dfaut.
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.
xmlns:tns="http://www.liafa.jussieu.fr/~carton">
<xsl:output method="xml" encoding="iso-8859-1" indent="yes"/>

<xsl:namespace-alias stylesheet-prefix="tns" result-prefix="xsl"/>
<tns:stylesheet version="2.0"
<tns:output method="xhtml" encoding="iso-8859-1" indent="yes"/>
<tns:template match="/">
<html>
<head>
<title>Exemple d'expressions XPath</title>
</head>
<body>
<h1>Exemple d'expressions XPath</h1>
<xsl:apply-templates select="operators/operator"/>
</body>
170
XSLT
</html>
</tns:template>
</tns:stylesheet>
</xsl:template>
...
8.6.2. Rgles par dfaut

Il existe des rgles par dfaut pour traiter chacun des nuds possibles d'un document. Celles-ci simplifient l'criture
de feuilles de style trs simples en fournissant un traitement adapt la plupart des nuds. Ces rgles ont la
priorit la plus faible. Elles ne s'appliquent un nud que si la feuille de style ne contient aucune rgle pouvant
s'appliquer ce nud. L'effet de ces diffrentes rgles est le suivant. Elles suppriment les instructions de traitement
et les commentaires. Elles recopient dans le rsultat le contenu des nuds textuels et les valeurs des attributs.
Le traitement d'un lment par ces rgles est d'appliquer rcursivement une rgle ses enfants, ce qui exclut les
attributs.
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.
<?xml version="1.0" encoding="us-ascii"?>

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"/>
En appliquant cette feuille de style minimale au document bibliography.xml, on obtient le rsultat suivant.
<?xml version="1.0" encoding="UTF-8"?>
XML langage et applications
Alain Michard
2001
Eyrolles
2-212-09206-7
http://www.editions-eyrolles/livres/michard/
XML by Example
Benot Marchal
2000
Macmillan Computer Publishing
0-7897-2242-9
XSLT fondamental
Philippe Drix
2002
Eyrolles
2-212-11082-0
Designing with web standards
Jeffrey Zeldman
2003
New Riders
0-7357-1201-8
Ce rsultat s'explique par la prsence de rgles par dfaut qui sont les suivantes.

<xsl:template match="/|*">

171
XSLT


</xsl:template>

<xsl:template match="text()|@*">

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


<xsl:template match="processing-instruction()|comment()"/>
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.
8.6.3. Expression XPath en attribut

Il est possible d'insrer directement dans un attribut la valeur d'une expression XPath. L'expression doit tre
dlimite dans l'attribut par des accolades '{' et '}'. l'excution, l'expression est value et le rsultat remplace
dans l'attribut l'expression et les accolades qui l'entourent. L'expression XPath peut simplement tre une variable
XSLT [Section 8.9] comme dans le premier example <body ... > ci-dessous. Un mme attribut peut contenir
un mlange de texte et de plusieurs expressions XPath comme dans le second exemple <div ... > ci-dessous.
<body background-color="{$color}">
...
<div style="height: {$height+10}; width: {$width+10}">
Cette syntaxe est beaucoup 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 example 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 plus concises
que les constructions quivalentes en XSLT. L'exemple ci-dessous est, par exemple, beaucoup plus court que
l'quivalent avec les structures de contrle XSLT [Section 8.7].
<a id="{if (@xml:id) then @xml:id else generate-id()}"/>
Pour insrer des accolades ouvrantes ou fermantes dans la valeur d'un attribut, il faut simplement doubler les
accolades et crire '{{' et '}}'. Si la rgle XSLT suivante
<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.
<braces id="JB007" esc="{@id}" escid="{JB007}"/>
Les expressions XPath en attribut apparaissent normalement dans les attribut des lments hors de l'espace de
noms XSLT. Ils peuvent galemement apparatre comme valeur de quelques attributs d'lments XSLT. C'est,
172
XSLT
par exemple, le cas de l'attribut name des lments xsl:element et xsl:attribute [Section 8.6.6].
Ceci permet d'insrer dans le document rsultat des lments et/ou des attributs dont les noms sont calculs
dynamiquement.
8.6.4. Texte brut

L'lment xsl:text utilise son contenu pour crer un nud textuel dans le document rsultat. Les caractres
spciaux [Section 2.2.1] '<', '>' et '&' sont automatiquement remplacs par les entits prdfinies
[Section 3.5.1.2] correspondantes si la valeur de l'attribut method de l'lment output n'est pas text. Si la
valeur cet attribut est text, les caractres spciaux sont recopis l'identique.
<xsl:text>Texte et entits '<', '>' et '&'</xsl:text>
La prsentation de la bibliographie en XHTML peut tre amliore par l'ajout de virgules ',' entre les proprits
titre, 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].

</xsl:if>
</xsl:template>
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().

</xsl:template>
8.6.5. Expression XPath

L'lment xsl:value-of cre un 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.
<values><xsl:value-of select="list/*" separator=","/></values>
</xsl:template>
</xsl:stylesheet>
Le document suivant comporte un lment racine avec des enfants item contenant des valeurs 1, 2 et 3.
173
XSLT
<list><item>1</item><item>2</item><item>3</item></list>
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 ','.
<values>1,2,3</values>
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.
<values>1</values>
Quelques exemples d'utilisation de xsl:value-of.
<xsl:value-of select="generate-id()"/>
<xsl:value-of select="key('idchapter', @idref)/title"/>
8.6.6. lment et attribut

Tout lment contenu dans un lment xsl:template et n'appartenant pas l'espace de nom xsl des feuilles
de style est recopi l'identique lors de l'application de la rgle. Ceci permet d'ajouter facilement des lments
et des attributs dont les noms sont fixes. Il est parfois ncessaire d'ajouter des lments et/ou des attributs
dont les noms sont calculs dynamiquement. Les lments xsl:element et xsl:attribute permettent
respectivement de construire un nud pour un lment ou un attribut. Le nom de l'lment ou de l'attribut est
dtermin dynamiquement par l'attribut name de xsl:element et xsl:attribute. Cet attribut contient une
expression XPath en attribut [Section 8.6.3]. L'valuation des expressions XPath dlimites par des accolades '{'
et '}' fournit le nom de l'lment ou de l'attribut. Le contenu de l'lment ou la valeur de l'attribut sont donns par
l'attribut select ou par le contenu des lments xsl:element et xsl:attribute. Ces deux possibilits
s'excluent mutuellement. L'attribut select doit contenir une expression XPath.
Dans l'exemple suivant, le nom de l'lment est obtenu en concatnant la chane new- avec la valeur de la variable
XSLT var [Section 8.9].
<xsl:element name="{concat('new-', $var)}">...</element>
L'utilisation des lments xsl:element et xsl:attribute est pratique lorsque l'insertion de l'lment ou
de l'attribut est conditionnelle. Le fragment de feuille style suivant construit un lment tr. Elle lui ajoute un
attribut bgcolor 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>
8.6.6.1. Groupe d'attributs

Il est frquent qu'une feuille de style ajoute systmatiquement les mmes attributs des lments. Les groupes
d'attributs dfinissent des ensembles d'attributs qu'il est, ensuite, facile d'utiliser pour ajouter des attributs aux
lments construits. Cette technique accrot, en outre, la flexibilit des feuilles de style. Le groupe peut tre redfini
au niveau global, permettant ainsi, d'adapter la feuille de style sans modifier les rgles.
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
174
XSLT
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 certains lments XSLT comme xsl:element mais il peut galement apparatre dans des
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 useattribute-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.
<xsl:output ... />

<xsl:attribute-set name="text">
<xsl:attribute name="align">left</xsl:attribute>
</xsl:attribute-set>

<xsl:attribute-set name="para" use-attribute-sets="text"/>

<xsl:attribute-set name="title" use-attribute-sets="text">
<xsl:attribute name="id" select="generate-id()"/>
<xsl:comment>Generated by dbk2html.xsl</xsl:comment>
<head><title><xsl:value-of select="dbk:book/dbk:title"/></title></head>
<body><xsl:apply-templates/></body>
</html>
</xsl:template>

<xsl:template match="dbk:title|dbk:subtitle"/>

<xsl:template match="dbk:book">
</xsl:template>

<xsl:template match="dbk:chapter">
<h1 xsl:use-attribute-sets="title"><xsl:value-of select="dbk:title"/></h1>
</xsl:template>

<xsl:template match="dbk:sect1">
175
XSLT
<h2 xsl:use-attribute-sets="title"><xsl:value-of select="dbk:title"/></h2>

</xsl:template>
</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.

<xsl:import href="dbk2html.xsl"/>

<xsl:attribute-set name="title">

<xsl:attribute name="align">center</xsl:attribute>

<xsl:attribute-set name="para">

<xsl:attribute name="style">font-family: serif</xsl:attribute>
</xsl:stylesheet>
8.6.7. Commentaire et instruction de traitement

Les lments xsl:comment et xsl:processing-instruction permettent respectivement de construire
un nud pour un commentaire [Section 2.7.5] ou une instruction de traitement [Section 2.7.6]. Le nom
de l'instruction de traitement est dtermin dynamiquement par l'attribut name de xsl:processinginstruction. Cet attribut contient une expression XPath en attribut [Section 8.6.3]. Le texte du commentaire
ou de l'instruction de traitement est donn par le contenu des lments xsl:comment et xsl:processinginstruction.

<xsl:comment>Un commentaire dans le document final</xsl:comment>

<xsl:processing-instruction name="dbhtml">
filename="index.html"
</xsl:processing-instruction>
On obtient, dans le document rsultat, le commentaire et l'instruction de traitement comme ci-dessous.

<?dbhtml filename="index.html"?>
8.6.8. Liste d'objets

L'lment xsl:sequence construit une liste de valeurs dtermine par l'valuation de l'expression XPath
contenue dans l'attribut select ou par le contenu de l'lment xsl:sequence lui-mme. Cet lment est
souvent utilis dans la dclaration d'une variable [Section 8.9] ou dans la dfinition d'une fonction d'extension
[Section 8.10]. L'lment xsl:sequence permet en pariculier une rgle de retourner une liste de nuds du
176
XSLT
document source. Dans la feuille de style suivante, la rgle s'appliquant l'lment list retourne la liste de ses
enfants item o apparat la chane '1'.
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:variable name="var" as="node()*">
<xsl:apply-templates select="list"/>
</xsl:variable>

<texts>
<xsl:for-each select="$var">
<xsl:copy-of select="."/>
<xsl:copy-of select="following-sibling::*[1]"/>
</xsl:for-each>
</texts>
</xsl:template>
<xsl:template match="list">
<xsl:sequence select="item[contains(.,'1')]"/>
</xsl:template>
</xsl:stylesheet>
Si la feuille de style prcdente est applique au document suivant, on obtient le document rsultat donn cidessous.

<list><item>12</item><item>23</item><item>31</item></list>
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.

<texts><item>12</item><item>23</item><item>31</item></texts>
Une liste cre par xsl:sequence peut tre trie par l'lment xsl:perform-sort [Section 8.8.1].
8.6.9. Copie superficielle

L'lment xsl:copy permet de copier le nud courant dans le document rsultat. Cette copie est dite superficielle
car elle copie seulement le nud ainsi que les dclarations d'espaces de noms ncessaires. L'lment xsl:copy
n'a pas d'attribut select car c'est toujours le nud courant qui est copi.
Les attributs (dans le cas o le nud courant est un lment) et le contenu ne sont pas copis. 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, ajouter des lments xsl:copy-of ou xsl:apply-templates.
La feuille de style suivante transforme le document bibliography.xml en remplaant chaque attribut lang
d'un lment book par un enfant lang ayant comme contenu la valeur de l'attribut. La feuille de style est
constitue de deux rgles, une pour les lments book et une autre pour 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.
177
XSLT


<xsl:template match="/|*">
<xsl:copy>

<xsl:copy-of select="@*"/>

</xsl:copy>
</xsl:template>
<xsl:copy>

<xsl:copy-of select="@*[name() != 'lang']"/>

<lang><xsl:value-of select="@lang"/></lang>

</xsl:copy>
</xsl:template>
</xsl:stylesheet>
En appliquant la feuille de style prcdente au document bibliography.xml, on obtient le document suivant.
<bibliography>
<book key="Michard01">
<lang>fr</lang>
<title>XML langage et appplications</title>
<year>2001</year>
<isbn>2-212-09206-7</isbn>
</book>
<book key="Zeldman03">
<lang>en</lang>
<year>2003</year>
<isbn>0-7357-1201-8</isbn>
</book>

...
</bibliography>
8.6.10. Copie profonde

L'lment xsl:copy-of permet de copier des nuds slectionns ainsi que tous les descendants de ces nuds
dans le document rsultat. Cette copie est dite profonde car tout le sous-arbre enracin en un nud slectionn est
copi. L'expression XPath contenue dans l'attribut select de xsl:copy-of dtermine les nuds copier.
La feuille de style suivante transforme le document bibliography.xml en rpartissant la bibliographie en
deux parties dans des lments bibliodiv contenant respectivement les livres en franais et en anglais. L'unique
rgle de la feuille de style cre le squelette avec les deux lments bibliodiv et copie les livres dans ces deux
lments grce deux lments xsl:copy-of.
178
XSLT

<bibliography>
<bibliodiv>
<xsl:copy-of select="bibliography/book[@lang='fr']"/>
</bibliodiv>
<bibliodiv>
<xsl:copy-of select="bibliography/book[@lang='en']"/>
</bibliodiv>
</bibliography>
</xsl:template>
</xsl:stylesheet>
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, 2, 3, , 9, 10, 11,
01
01, 02, 03, , 09, 10, 11,
a, b, c, , z, aa, ab,
A, B, C, , Z, AA, AB,
i, ii, iii, iv, v, vi, vii, viii, ix, x, xi,
I, II, III, IV, V, VI, VII, VIII, IX, X, XI,
Tableau 8.1. Formats de xsl:number

Il existe aussi des formats w, W et Ww permettant d'crire les nombres en toutes lettres. L'attribut lang qui prend
les mmes valeurs que l'attribut xml:lang spcifie la langue dans laquelle sont crits les nombres. Il semblerait
que l'attribut lang ne soit pas pris en compte.
8.6.11.2. Calcul du numro

Le numro calcul par xsl:number peut tre donn de faon explicite par l'attribut value qui contient une
expression XPath. L'valuation de cette expression fournit le nombre rsultat. Cette mthode permet d'avoir un
contrle total sur le numro. 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
les lments pris en compte. Chacun de ces trois attributs contient un motif XPath permettant de slectionner des
nuds.
<xsl:number value="1 + count(preceding::*)" format="i"/>
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
179
XSLT
peut contenir plusieurs indicateurs de formats spars par des caractres non alphanumriques comme 1.1.1
ou [A-1-i].
2
2 .3 .2
Mo d e s in g le
21
Mo d e m u lt ip le
Mo d e a n y
Figure 8.3. Modes de xsl:number

Dans le mode single, le numro est gal au nombre (augment d'une unit pour commencer avec 1) de frres
gauches du nud courant qui satisfont le motif donn par count. Rappelons qu'un frre est un enfant du mme
nud pre et qu'il est gauche s'il prcde le nud courant dans le document.
La feuille de style suivante ajoute un numro aux lments section. Ce numro est calcul dans le mode
single.
<?xml version="1.0" encoding="us-ascii"?>
<xsl:copy>
<xsl:if test="name()='section'">

<xsl:number level="single" count="section" format="1"/>
</xsl:if>
</xsl:copy>
</xsl:template>
</xsl:stylesheet>
On considre le document XML suivant qui reprsente le squelette d'un livre avec des chapitres, des sections et
des sous-sections.
<book>
<chapter>
<section>
<section></section><section></section>
</section>
<section>
</section>
</chapter>
<chapter>
<section>
</section>
<section>
</section>
</chapter>
</book>
180
XSLT
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.
<book>
<chapter>
<section>1
<section>1</section><section>2</section>
</section>
<section>2
</section>
</chapter>
<chapter>
<section>1
</section>
<section>2
</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. Ensuite, on considre chacun des anctres entre le nud de
dpart et le nud courant qui satisfait l'attribut count. 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.
<xsl:number level="multiple" count="chapter|section" format="A.1.i"/>
<book>
<chapter>
<section>A.1
<section>A.1.i</section><section>A.1.ii</section>
</section>
<section>A.2
<section>A.2.i</section><section>A.2.ii</section>
</section>
</chapter>
<chapter>
<section>B.1
<section>B.1.i</section><section>B.1.ii</section>
</section>
<section>B.2
<section>B.2.i</section><section>B.2.ii</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.
181
XSLT
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 le document car la valeur par dfaut de
from est la racine du document.
<xsl:number level="any" count="section" format="1"/>
<book>
<chapter>
<section>1
</section>
<section>4
</section>
</chapter>
<chapter>
<section>7
</section>
<section>10
</section>
</chapter>
</book>
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.
<xsl:number level="any" count="section" from="chapter" format="1"/>
<book>
<chapter>
<section>1
</section>
<section>4
</section>
</chapter>
<chapter>
<section>1
</section>
<section>4
</section>
</chapter>
</book>
8.6.12. Formatage de nombres

L'lment xsl:number a des possibilits limites pour formater un nombre de manire gnrale. Ils possde
deux attributs grouping-separator et grouping-size dont les valeurs par dfaut sont respectivement
',' et 3. Dans l'exemple suivant, l'entier 1234567 est format en 1.234.567.
<xsl:number grouping-separator="." value="12345678"/>
182
XSLT
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 cidessous. 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, )
';'
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.
Nombre\Format
##
####
#,#00.##
####.00
0000.00
01
1.00
0001.00
123
123
123
123
123.00
0123.00
1234
1234
1234
1,234
1234.00
1234.00
12.34
12
12
12.34
12.34
0012.34
1.234
01.23
1.23
0001.23
Tableau 8.2. Rsultats de format-number()

Les caractres '%' et '' permettent de formater une fraction entre 0 et 1 comme un pourcentage ou un millime.
Le formatage du nombre 0.1234 avec les formats #%, #.##% et # donne respectivement 12%, 12.34% et 123.
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)
183
XSLT
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.

<xsl:decimal-format name="en" decimal-separator="."
grouping-separator=","/>

<xsl:decimal-format name="fr" decimal-separator=","
grouping-separator="."/>
...
<price xml:lang="en-GB" currency="pound">
<xsl:value-of select="format-number($price, '###,###,###.##', 'en')"/>
</price>
...
<price xml:lang="fr" currency="euro">
<xsl:value-of select="format-number($price, '###.###.###,##', 'fr')"/>
</price>
...
8.7. Structures de contrle

Le langage XSLT propose, comme tout langage de programmation, des structures de contrle permettant
d'effectuer des tests et des boucles. Il contient les deux lments xsl:if et xsl:choose pour les tests et les
deux lments xsl:for-each et xsl:for-each-group pour les boucles. L'lment xsl:if autorise un
test sans alternative (pas d'lment xsl:else) alors que l'lment xsl:choice permet, au contraire un choix
entre plusieurs alternatives. L'lment xsl:for-each pemet des boucles simples sur des nuds slectionns.
L'lment xsl:for-each-group permet de former des groupes partir de nuds slectionns puis de traiter
successivement les diffrents groupes. Certaines constructions XSLT sont parfois ralises de manire plus concise
par des structures de contrle XPath [Section 6.6] places dans des attributs [Section 8.6.3].
8.7.1. Conditionnelle sans alternative

L'lment xsl:if permet de raliser un test. De faon surprenante, cet lment ne propose pas d'alternative car il
n'existe pas d'lment xsl:else. Lorsqu'une alternative est ncessaire, il faut utiliser l'lment xsl:choose.
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. Sinon, le contenu de l'lment xsl:if est ignor.
<xsl:if test="not(position()=last())">
</xsl:if>
8.7.2. Conditionnelle alternatives multiples

184
XSLT
L'lment xsl:choose permet de raliser plusieurs tests conscutivement. Il contient des lments xsl:when
et ventuellement un lment xsl:otherwise. Chacun des lments xsl:when possde un attribut test
contenant une expression XPath servant de condition.
Les conditions contenues dans les attributs test des lments xsl:when sont values puis converties en valeur
boolenne [Section 6.3.1] dans l'ordre des lments xsl:when Le contenu du permier lment xsl:when
dont la condition donne la valeur true est pris en compte et les contenus des autres xsl:when et d'un
ventuel xsl:otherwise sont ignors. Si aucune condition ne donne la valeur true, le contenu de l'lment
xsl:otherwise est pris en compte et les contenus de tous les lments xsl:when sont ignors.
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 sinon.
<xsl:choose>
<xsl:when test="title">
<xsl:value-of select="title"/>
</xsl:when>
<xsl:otherwise>
<xsl:text>Section </xsl:text>
<xsl:number level="single" count="section"/>
</xsl:otherwise>
</xsl:choose>
8.7.3. Itration simple

L'lment xsl:for-each permet de raliser des boucles en XSLT. L'itration est dj prsente implicitement
avec l'lment xsl:apply-templates puisqu'une rgle est successivement applique chacun des nuds
slectionns. L'lment xsl:for-each ralise une boucle de manire explicite.
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:foreach qui parcourt tous les lments book de bibliography.xml. Le rsultat de la fonction position()
est formate par l'lment xsl:number pour numroter les lignes du tableau.
<html>
<head>
<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>
185
XSLT
<xsl:for-each select="bibliography/book">
<xsl:sort select="author" order="ascending"/>
<tr>
<td><xsl:number value="position()" format="1"/></td>
<td><xsl:value-of select="title"/></td>
<td><xsl:value-of select="author"/></td>
<td><xsl:value-of select="publisher"/></td>
<td><xsl:value-of select="year"/></td>
</tr>
</xsl:for-each>
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
<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>Numéro</th>
<th>Titre</th>
<th>Auteur</th>
<th>Éditeur</th>
<th>Année</th>
</tr>
<tr>
<td>1</td>
<td>XML langage et appplications</td>
<td>Alain Michard</td>
<td>Eyrolles</td>
<td>2001</td>
</tr>

...
</table>
</body>
</html>
8.7.4. Itration sur des groupes

L'lment xsl:for-each-group est un ajout de XSLT 2.0. Il permet de grouper des nuds du document
source suivant diffrents critres puis de parcourir les groupes forms.
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
186
XSLT
xsl:for-each. L'attribut select de cet lment utilise la fonction current-group() [Section 6.1.7] qui
retourne la liste des objets du groupe.
<xsl:output method="xhtml" encoding="iso-8859-1" indent="yes"/>
<html>
<head>
<title>Bibliographie par anne</title>
</head>
<body>
<h1>Bibliographie par anne</h1>

<xsl:for-each-group select="bibliography/book" group-by="year">

<xsl:sort select="current-grouping-key()"/>

<h2>
<xsl:text>Anne </xsl:text>
<xsl:value-of select="current-grouping-key()"/>
</h2>

<ul>

<xsl:for-each select="current-group()">

<xsl:sort select="author"/>
<xsl:sort select="publisher"/>
</xsl:for-each>
</ul>
</xsl:for-each-group>
</body>
</html>
</xsl:template>

<xsl:call-template name="separator"/>
</xsl:template>
<xsl:call-template name="separator"/>
</xsl:template>

<xsl:template name="separator">
</xsl:if>
</xsl:template>
</xsl:stylesheet>
187
XSLT
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<title>Bibliographie par anne</title>
</head>
<body>
<h1>Bibliographie par anne</h1>
<h2>Anne 2000</h2>
<ul>
<li><i>XML by Example</i>, Benot Marchal, 2000,
Macmillan Computer Publishing, 0-7897-2242-9</li>
...
</ul>
<h2>Anne 2001</h2>
...
</body>
</html>
La feuille de style suivante donne un exemple classique 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 langages 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.
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.
xmlns:html="http://www.w3.org/1999/xhtml"
exclude-result-prefixes="xsl html">
<book>
<xsl:apply-templates select="html:html/html:body"/>
</book>
</xsl:template>
<xsl:template match="html:body">

<xsl:for-each-group select="*" group-starting-with="html:h1">
<chapter>

<title><xsl:value-of select="current-group()[1]"/></title>


<xsl:for-each-group select="current-group()"
group-starting-with="html:h2">
<xsl:choose>
<xsl:when test="local-name(current-group()[1]) = 'h2'">
<sect1>
188
XSLT


<title><xsl:value-of select="current-group()[1]"/></title>
<xsl:apply-templates select="current-group()"/>
</sect1>
</xsl:when>
<xsl:otherwise>
<xsl:apply-templates select="current-group()"/>
</xsl:otherwise>
</xsl:choose>
</chapter>
</xsl:template>

<xsl:template match="html:h1|html:h2"/>

<xsl:template match="html:p">
<para><xsl:apply-templates/></para>
</xsl:template>
</xsl:stylesheet>
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.
<?xml version="1.0" encoding="iso-8859-1" ?>
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fr" lang="fr">
<head>
<title>Fichier HTML exemple</title>
</head>
<body>
<h1>Titre I</h1>
<p>Paragraphe I.0.1</p>
<h2>Titre I.1</h2>
<h2>Titre I.2</h2>
<h1>titre II</h1>
<p>Paragraphe II.0.1</p>
<h2>Titre II.1</h2>
<h2>Titre II.2</h2>
</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.
<book xmlns="http://docbook.org/ns/docbook">
<chapter>
<title>Titre I</title>
<para>Para I.0.1</para>
<sect1>
189
XSLT
<title>Titre I.1</title>
</sect1>
<sect1>
<title>Titre I.2</title>
</sect1>
</chapter>
<chapter>
<title>titre II</title>
<para>Para II.0.1</para>
<sect1>
<title>Titre II.1</title>
</sect1>
<sect1>
<title>Titre II.2</title>
</sect1>
</chapter>
</book>
8.8. Tris
L'lment xsl:sort permet de trier des lments avant de les traiter. L'lment xsl:sort doit tre le premier
fils des lments xsl:apply-templates, xsl:call-template, xsl:for-each ou xsl:foreach-group. Le tri s'applique tous les lments slectionns par l'attribut select de ces diffrents lments.
Le fragment de feuille de style suivant permet par exemple de trier les lments book par auteur par ordre
croissant.
<xsl:apply-templates select="bibliography/book">
</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="year"
order="descending"/>
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() 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.
190
XSLT


<xsl:variable name="orderlist" as="xsd:string*"
select="/bibliography/book[1]/*/name()"/>
...
<xsl:copy>

<xsl:apply-templates>


<xsl:sort select="(index-of(('title', 'author', 'publisher',
'year', 'isbn'), name()),10)[1]"/>


</xsl:copy>
</xsl:template>
</xsl:stylesheet>
8.8.1. Tri de listes

L'lment xsl:perform-sort permet d'appliquer un tri une suite quelconque d'objets, en particulier avant de
l'affecter une variable. Ses enfants doivent tre un ou des lments xsl:sort puis des lments qui construisent
la suite comme xsl:sequence [Section 8.6.8] dans l'exemple suivant.
<xsl:output method="text" encoding="iso-8859-1"/>
<xsl:variable name="list" as="xsd:integer*">
<xsl:perform-sort>
<xsl:sort data-type="number" order="ascending"/>
<xsl:sequence select="(3, 1, 5, 0)"/>
</xsl:perform-sort>
</xsl:variable>

<xsl:value-of select="$list" separator=","/>
</xsl:template>
</xsl:stylesheet>
8.9. Variables et paramtres

Le langage XSLT permet l'utilisation de variables pouvant stocker des valeurs. Les valeurs possibles comprennent
une valeur atomique, un nud ou une suite de ces valeurs, c'est--dire toutes les valeurs des expressions XPath.
Les variables peuvent tre utilises dans les expressions XPath.
Le langage XSLT distingue les variables des paramtres. Les variables servent stoker des valeurs intermdiaires
alors que les paramtres servent transmettre des valeurs aux rgles. Les variables sont introduites par
191
XSLT
l'lment xsl:variable et les paramtres par l'lment xsl:param. L'lment xsl:with-param permet
d'instancier 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.
<xsl:variable name="squares" as="xsd:integer*">
<xsl:for-each select="1 to 5">
<xsl:sequence select=". * ."/>
</xsl:for-each>
</xsl:variable>
<xsl:variable name="cubes" as="xsd:integer*"
select="for $i in 1 to 5 return $i * $i * $i"/>
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 contexte dynamique
[Section 6.1.5.2]. Le fragment de feuille de style mmorise le nud courant dans la variable current. Elle l'utilise
ensuite pour slectionner les lments publisher dont l'attribut id est gal l'attribut by du nud courant.
<xsl:variable name="current" select="."/>
<xsl:xsl:copy-of select="//publisher[@id = $current/@by]"/>
XSLT 2.0 a introduit une fonction XPath current() [Section 6.1.7] qui retourne le nud courant. Il n'est plus
ncessaire de le stocker dans une variable. L'exemple prcdent pourrait tre rcrit de la faon suivante.
<xsl:xsl:copy-of select="//publisher[@id = current()/@by]"/>
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 par leur attribut id. Cette approche est dveloppe 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.

<xsl:key name="idpublisher" match="publisher" use="@id"/>
...

<xsl:variable name="result" select="key('idpublisher', @by)"/>
192
XSLT
<publisher>

<xsl:copy-of select="$result/@*[name() != 'id']"/>
<xsl:copy-of select="$result/* | $result/text()"/>
</publisher>
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.
<xsl:param name="bg-color" select="'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/>
8.9.2.1. Paramtres globaux

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 fixer la valeur d'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 donner une rgle CSS [Chapitre 10] dans l'entte du document.
<xsl:output ... />

<xsl:param name="bg-color" select="'white'"/>
<xsl:comment>Generated by dbk2html.xsl</xsl:comment>
<head>
<title><xsl:value-of select="dbk:book/dbk:title"/></title>
<style>
<xsl:comment>
193
XSLT
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.
xsltproc --stringparam bg-color blue dbk2html.xsl dbk2html.xml
8.9.2.2. Paramtres locaux

La dclaration d'un paramtre d'une rgle est ralise par un lment xsl:param enfant de xsl:template.
Les dclarations de paramtres doivent tre les premiers enfants. Le passage d'une valeur en paramtre est ralis
par un lment xsl:with-param fils de xsl:apply-templates ou xsl:call-template. Comme
pour xsl:variable, 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 [Section 6.1.4] de la valeur.
Dans l'exemple suivant, la premire rgle (pour la racine '/') applique la rgle pour le fils text avec le paramtre
color gal blue. La valeur par dfaut de ce paramtre est black.
<xsl:apply-templates select="text">

<xsl:with-param name="color" select="'blue'"/>
</xsl:template>
<xsl:template match="text">

<xsl:param name="color" select="'black'"/>
<p style="color:{$color};"><xsl:value-of select="."/></p>
</xsl:template>
</xsl:stylesheet>
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.
<xsl:apply-templates select="*"/>
</xsl:template>
<xsl:copy>

<xsl:call-template name="get-id"/>
194
XSLT
</xsl:copy>
</xsl:template>

<xsl:template name="get-id">

<xsl:param name="node" as="node()" select="."/>
<xsl:attribute name="id"
select="($node/@id, $node/@xml:id, generate-id($node))[1]"/>
</xsl:template>
</xsl:stylesheet>
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.
xmlns:fun="http://www.liafa.jussieur.fr/~carton">

<xsl:function name="fun:get-id" as="xsd:string">
<xsl:param name="node" as="node()"/>
<xsl:sequence select="($node/@id, $node/@xml:id, generate-id($node))[1]"/>
</xsl:function>
</xsl:template>
<xsl:copy>
<xsl:attribute name="id" select="fun:get-id(.)"/>
</xsl:copy>
</xsl:template>
</xsl:stylesheet>
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.

<xsl:template match="text()">
<xsl:call-template name="quote.string">
<xsl:with-param name="string" select="."/>
</xsl:call-template>
</xsl:template>

<xsl:template name="quote.string">

<xsl:param name="string"/>
<xsl:choose>
<xsl:when test="contains($string, '"')">
195
XSLT
<xsl:call-template name="quote.string.char">
<xsl:with-param name="string" select="$string"/>
<xsl:with-param name="char"
select="'"'"/>
</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:when>
<xsl:otherwise>
<xsl:value-of select="$string"/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>

<xsl:template name="quote.string.char">

<xsl:param name="string"/>

<xsl:param name="char"/>
<xsl:variable name="prefix">
<xsl:with-param name="string" select="substring-before($string, $char)"/>
</xsl:variable>
<xsl:variable name="suffix">
<xsl:with-param name="string" select="substring-after($string, $char)"/>
</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().

<xsl:value-of select="replace(., '(["\\])', '\\$1')">
</xsl:template>
8.9.4. Paramtres tunnel

Il est parfois fastidieux de transmettre systmatiquement des paramtres aux rgles appliques. Les paramtres
tunnel sont transmis automatiquement. En revanche, ils ne peuvent tre utilises que dans les rgles qui les
dclarent.
Dans l'exemple suivant, la rgle pour la racine applique une rgle au nud text avec les paramtres tunnel
et lunnet. La rgle applique reoit ces deux paramtres et applique nouveau des rgles ses fils textuels. Le
paramtre tunnel est transmis implicitement ces nouvelles rgles car il a t dclar avec l'attribut tunnel
valant yes. La rgle applique au nuds textuels dclare les paramtres tunnel et lunnet. La valeur de
tunnel est effectivement la valeur donne au dpart ce paramtre. Au contraire, la valeur du paramtre lunnet
est celle par dfaut car il n'a pas t transmis.
196
XSLT
<xsl:apply-templates select="text">
<xsl:with-param name="tunnel" select="'tunnel'" tunnel="yes"/>
<xsl:with-param name="lunnet" select="'lunnet'"/>
</xsl:template>
<xsl:template match="text">
<xsl:apply-templates select="text()"/>
</xsl:template>

<xsl:param name="tunnel" select="'default'" tunnel="yes"/>
<xsl:param name="lunnet" select="'default'"/>

<xsl:value-of select="$tunnel"/>

<xsl:value-of select="$lunnet"/>
</xsl:template>
</xsl:stylesheet>
8.10. Fonctions d'extension XPath

Avec XSLT 2.0, il est possible de dfinir des nouvelles fonctions qui peuvent tre utilises dans les
expressions XPath. Ces nouvelles fonctions viennent complter la librairie des fonctions XPath. Elles remplacent
avantageusement des constructions lourdes de XSLT 1.0 avec des rgles rcursives. Le traitement des chanes de
caractres est un champ d'utilisation classique de ces fonctions.
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. 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.
<xsl:function name="name" as="return-type">

<xsl:param name="param1" as="type1"/>
<xsl:param name="param2" as="type2"/>
...

...
</xsl:function>
L'lment xsl:function doit ncessairement tre enfant de l'lment racine xsl:stylesheet de la feuille
de style. Ceci signifie que la porte de la dfinition d'une fonction est la feuille de style dans son intgralit.
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.
<xsl:function name="url:protocol" as="xsd:string">
<xsl:param name="url" as="xsd:string"/>
<xsl:sequence select="
if (contains($url, ':')) then substring-before($url, ':') else ''"/>
</xsl:function>
197
XSLT
Une fois dfinie, la fonction url:protocol peut tre utilise comme n'importe quelle autre fonction XPath.
L'exemple suivant cre un nud texte contenant http.
<xsl:value-of select="url:protocol('http://www.liafa.jussieu.fr/')"/>
La fonction url:protocol peut tre utilise pour dfinir une nouvelle fonction url:address qui extrait la
partie adresse internet d'une URL. Cette fonction utilise une variable locale protocol pour stocker le rsultat
de la fonction url:protocol.
<xsl:function name="url:address" as="xsd:string">
<xsl:param name="url" as="xsd:string"/>
<xsl:variable name="protocol" as="xsd:string" select="url:protocol($url)"/>
if (($protocol eq 'file') or ($protocol eq ''))
then ''
else substring-before(substring-after($url, '://'), '/')"/>
</xsl:function>
L'expression XPath url:address('http://www.liafa.jussieu.fr/~carton/') s'value, par
exemple, en la chane de caractres www.liafa.jussieu.fr.
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 '/'.
<xsl:function name="url:file" as="xsd:string">
<xsl:param name="path" as="xsd:string"/>
if (contains($path, '/'))
then url:file(substring-after($path, '/'))
else $path"/>
</xsl:function>
L'expression XPath url:file('Enseignement/XML/index.html') s'value, par exemple, en la chane
de caractres index.html.
Une fonction XPath est identifie par son nom qualifi et son arit (nombre de paramtres). Il est ainsi possible
d'avoir deux fonctions de mme nom pouvu qu'elles soient d'arits diffrentes. Ceci permet de simuler des
paramtres avec des valeurs par dfaut en donnant plusieurs dfinitions d'une fonction avec des nombres de
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.

<xsl:function name="fun:join-path" as="xsd:string">
<xsl:param name="path1" as="xsd:string"/>
<xsl:param name="sep"
as="xsd:string"/>
<xsl:sequence select="concat($path1, $sep, $path2)"/>
</xsl:function>

<xsl:function name="fun:join-path" as="xsd:string">
<xsl:sequence select="concat($path1, '/' , $path2)"/>
</xsl:function>
...

<xsl:value-of select="fun:join-path('Directory', 'index.html', '/')"/>

198
XSLT
<xsl:value-of select="fun:join-path('Directory', 'index.html')"/>
8.11. Modes
Il est frquent qu'une feuille de style traite plusieurs fois les mmes nuds du document d'entre pour en extraire
divers fragments. 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 identificateur. 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.

<xsl:template match="...">
...

<xsl:template match="..." mode="test">
...

<xsl:template match="..." mode="#default foo bar">
...

<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
#current permet appliquer des rgles avec le mme mode que celui de la rgle en cours. La valeur par dfaut
est encore #default.

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

<xsl:apply-templates select="..." mode="test"/>
...

<xsl:apply-templates select="..." mode="#current"/>
...
Dans l'exemple suivant, le nud text est trait d'abord dans le mode par dfaut #default puis dans le mode
test. Dans chacun de ces traitements, ses fils textuels sont traits d'abord dans le mode par dfaut puis dans son
propre mode de traitement. Les fils textuels sont donc, au final, traits trois fois dans le mode par dfaut et une
fois dans le mode test.
<xsl:apply-templates select="text"/>
<xsl:apply-templates select="text" mode="test"/>
</xsl:template>
<xsl:template match="text" mode="#default test">
<xsl:apply-templates select="text()"/>
199
XSLT
<xsl:apply-templates select="text()" mode="#current"/>

</xsl:template>
<xsl:text>Mode #default: </xsl:text>
<xsl:text>
</xsl:text>
</xsl:template>
<xsl:template match="text()" mode="test">
<xsl:text>Mode test: </xsl:text>
<xsl:text>
</xsl:text>
</xsl:template>
</xsl:stylesheet>
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.

<html>
<head>
<title><xsl:value-of select="book/title"/></title>
</head>
<body>

<xsl:apply-templates mode="toc"/>

</body>
</html>
</xsl:template>
...

<xsl:template match="book" mode="toc">
<h1>Table des matires</h1>
<ul><xsl:apply-templates mode="toc"/></ul>
</xsl:template>
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. 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
stock dans une variable [Section 8.9] pour l'utiliser plusieurs reprises.

200
XSLT
<bibliography>
<xsl:apply-templates select="bibliography/books/book"/>
</bibliography>
</xsl:template>

<book>


<xsl:copy-of select="*[name() != 'published']"/>

<xsl:apply-templates select="published"/>
</book>
</xsl:template>

<xsl:template match="published">

<xsl:variable name="pubnode" select="id(@by)"/>
<publisher>


<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.
<xsl:key name="idchapter" match="chapter" use="@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.
201
XSLT
<xsl:value-of select="key('idchapter', $node/@idref)/title"/>

L'utilisation des index peut tre contourne par des expressions XPath approprie. L'expression ci-dessus avec la
fonction key est quivalente l'expression XPath ci-dessous qui utilise l'oprateur '//' [Section 6.7].
<xsl:value-of select="//chapter[@id = $node/@idref]/title"/>
L'inconvnient de cette dernire expression est d'imposer un parcours complet du document pour chacune de ses
valuations. 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:copyof [Section 8.6.10] pour ses attributs et ses enfants.

<xsl:key name="pubname" match="publisher" use="name"/>
<bibliography>
<books>

<xsl:apply-templates select="bibliography/book"/>
</books>
<publishers>

<xsl:apply-templates select="bibliography/book/publisher"/>
</publishers>
</bibliography>
</xsl:template>

<book>

<xsl:copy-of select="@* | *[name() != 'publisher']"/>

<xsl:if test="publisher">
<published id="{generate-id(key('pubname', publisher/name)[1])}"/>
</xsl:if>
</book>
</xsl:template>

202
XSLT
<xsl:template match="publisher">

<xsl:if test=". is key('pubname', name)[1]">
<xsl:copy>
<xsl:attribute name="id">
<xsl:value-of select="generate-id()"/>
</xsl:attribute>

<xsl:copy-of select="@* | *"/>
</xsl:copy>
</xsl:if>
</xsl:template>
</xsl:stylesheet>
8.13. Documents multiples

La fonction document() permet de lire et de manipuler un document XML contenu dans un autre fichier. Le
nom du fichier contenant le document est fourni en paramtre la fonction. Le rsultat peut tre stock dans
une variable ou tre utilis directement. Le document suivant rfrence deux autres documents europa.xml et
states.xml.
<files>
<file href="europa.xml"/>
<file href="states.xml"/>
</files>
Le document europa.xml est le suivant. Le document states.xml est similaire avec des villes amricaines.
<cities>
<city>Berlin</city>
<city>Paris</city>
</cities>
La feuille de style XSL suivante permet de collecter les diffrentes villes des documents rfrencs par le premier
document pour en faire une liste unique.
<html>
<head>
<title>Liste de villes</title>
</head>
<body>
<h1>Liste de villes</h1>
<ul>
<xsl:for-each select="files/file">
<xsl:apply-templates select="document(@href)/cities/city"/>
</xsl:for-each>
</ul>
</body>
</html>
</xsl:template>
<xsl:template match="city">
<li><xsl:value-of select="."/></li>
203
XSLT
</xsl:template>
</xsl:stylesheet>
L'ajout d'un lment xsl:sort comme fils de l'lment <xsl:apply-templates
select="document(@href)/cities/city"/> permet de trier les lments l'intrieur d'un des
documents rfrencs. Pour trier les lments globalement, il faut supprimer les deux itrations imbriques et les
remplacer par une seule itration comme dans l'exemple suivant.
<xsl:apply-templates select="document(files/file/@href)/cities/city">
<xsl:sort select="."/>
Dans l'expression XPath document(files/file/@href)/cities/city, on utilise le fait que la fonction
document() prend en paramtre une liste de noms de fichiers et qu'elle retourne l'ensemble des contenus des
fichiers.
8.14. Analyse de chanes

Il arrive que le document source ne soit pas suffisament structur et que la feuille de style ait besoin d'extraire
des morceaux de texte. L'lment xsl:analyze-string permet d'analyser une chane de caractres et de
la dcouper en fragments. Ces fragments peuvent ensuite tre repris et utiliss. L'analyse est ralise avec une
expression rationnelle [Section 5.15].
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:nonmatching-substring de xsl:analyze-string donnent le rsultat suivant que la chane est compatible
ou non avec l'expression.
La fonction XPath regex-group() permet de rcuprer un fragment de la chane correspondant un bloc
dlimit par des parenthses dans l'expression. L'entier fourni en paramtre donne le numro du bloc. Les blocs
sont numrots partir de 1.
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>
La feuille de style prcdente peut tre applique au document suivant.
<names>
<name>Lagaffe, Gaston</name>
<name>Talon, Achille</name>
<name>Astrix</name>
204
XSLT
</names>
On obtient le document suivant o les noms sont mieux structurs.
<names>
<name><firstname>Gaston</firstname><lastname>Lagaffe</lastname></name>
<name><firstname>Achille</firstname><lastname>Talon</lastname></name>
<name>Astrix</name>
</names>
8.15. Import de feuilles de style

Les lments xsl:include et xsl:import permettent d'inclure les rgles d'une feuille de style au sein d'une
autre feuille de style. La seule diffrence entre les deux lments est la gestion des priorits entre les rgles des
deux feuilles de style. Ces priorits [Section 8.5.3] influencent les choix de rgles appliquer sur les nuds. Ces
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.
xmlns:dbk="http://docbook.org/ns/docbook">

<xsl:import
href="/usr/share/sgml/docbook/xsl-stylesheets/html/profile-docbook.xsl"/>

<xsl:include href="common.xsl"/>

<xsl:param name="html.stylesheet" select="'style.css'"/>

<xsl:template match="dbk:para[@role = 'right']">
<p align="right"><xsl:apply-templates/></p>
</xsl:template>
</xsl:stylesheet>
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 feuiile
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,
205
XSLT
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
D
C
E
Figure 8.4. Priorits d'import
206
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].


<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">

<fo:layout-master-set>
<fo:simple-page-master master-name="A4"
page-width="210mm" page-height="297mm"
margin="1cm">

<fo:region-body
margin="2cm"/>

<fo:region-before extent="1cm"/>

<fo:region-after extent="1cm"/>
</fo:simple-page-master>
</fo:layout-master-set>

<fo:page-sequence master-reference="A4">

<fo:static-content flow-name="xsl-region-before">
<fo:block text-align="center">XSL-FO Hello, World! example</fo:block>
</fo:static-content>

<fo:static-content flow-name="xsl-region-after">
<fo:block text-align="center">- <fo:page-number/> -</fo:block>
</fo:static-content>

<fo:flow flow-name="xsl-region-body">
<fo:block text-align="center"
font="32pt Times"
border="black solid thick">Hello, world!</fo:block>
</fo:flow>
</fo:page-sequence>
</fo:root>
Le document prcdent peut tre trait par un programme comme fop pour produire un document
helloworld.pdf ou helloworld.png.
9.2. Structure globale

Un document XSL-FO est constitu de deux parties principales. La premire partie contenue dans l'lment
fo:layout-master-set contient des modles de pages. Ces modles dcrivent la mise en page du contenu.
La seconde partie contenue dans l'lment fo:page-sequence donne le contenu structur en blocs.
207
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;
}
/* Equations et figures centres */
p.equation, p.figure {
text-align: center;
}
/* Zone de code : fond jaune clair, bordure noire et marges */
pre {
background-color: #ffffcc;
border: 1px solid black;
margin: 10px;
padding: 5px;
}
208
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.
selector1, selector1, ..., selectorN
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.
<p class="numbered equation"> ... </p>
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.
h1#title { color: red }
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 }
209
CSS
p { color: gray }
Certaines parties d'un document qui ne correspondent pas un lment peuvent tre slectionnes par des pseudolments. 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;
}
Les pseudo-classes :link, :visited, :hover et :active s'appliquent l'lment a et permettent de
slectionner les liens, les liens dj traverss, les liens sous le curseur et les liens activs.
a:link
a:visited
a:hover
a:active
{
{
{
{
color:
color:
color:
color:
blue; }
magenta; }
red; }
red; }
La pseudo-classe :focus permet de slectionner l'entre d'un formulaire qui a le focus.

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 enGB ou en-US mais pas fr. La proprit quote dfinit quels caractres doivent entourer les citations.
210
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
211
CSS
Symbole
Unit
in
pouce
mm
millimtre
cm
centimtre
Tableau 10.1. Units des dimensions en CSS
10.3. Hritage et cascade

Certaines proprits sont automatiquement hrites comme color. Cela signifie qu'un lment hrite de la valeur
de cette proprit de son pre sauf si une rgle donne une autre valeur cette proprit. D'autres proprits comme
background-color ne sont pas hrites. On peut donner la valeur inherit n'importe quelle proprit pour
forcer l'hritage de la valeur du pre.
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;
}
10.3.1. Provenance de la valeur

La valeur d'une proprit pour un lment peut avoir les trois provenances suivantes par ordre de priorit
dcroissante.
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.
212
CSS
10.4. Modle de botes

Chaque lment (au sens usuel ou au sens XML) est mis dans une bote au moment de la mise en page. Cette bote
englobe le contenu de l'lment. Elle a aussi un espacement intrieur (padding en anglais), une bordure (border)
et une marge (margin) (cf. figure ci-dessous).
To p
LM
LB
TM
Ma rg in
TB
Bo rd e r
TP
Pa d d in g
LP
RP
Le ft
Co n t e n t
RB
RM
Rig h t
BP
BB
BM
Bo t t o m
Figure 10.1. Modle de bote

Chaque bote est positionne l'intrieur de la bote englobante de son pre. Le positionnement des lments dans
une bote englobante est d'abord dtermin par le type de la bote englobante. Les types principaux possibles pour
une bote sont bloc (block) ou en ligne (inline), table, entre de liste (list-item). Les lments d'une bote de type
bloc sont assembls verticalement alors que ceux d'une bote de type en ligne sont assembls horizontalement.
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.
10.5. Style et XML

On reprend le document bibliography.xml avec la feuille de style CSS suivante attache.
/* Feuille de style pour la bibliographie */
213
CSS
bibliography {
display: block;
border: 1px solid black;
margin: 30px;
padding: 20px;
}
/* Mode liste sans marque */
book {
display: list-item;
list-style: none;
}
/* Calcul de la marque */
book:before {
content: "[" counter(c) "]";
counter-increment: c;
}
/* Titre en italique */
title {
font-style: italic;
}
/* Virgule aprs chaque champ */
title:after, author:after, year:after, publisher:after {
content: ", ";
}
/* Fonte sans-serif pour l'url */
url {
font-family: sans-serif;
}
/* Virgule avant l'URL si elle est prsente */
url:before {
content: ", ";
}
10.6. Attachement de rgles de style

Les rgles de style concernant un document peuvent tre places diffrents endroits. Elles peuvent d'abord tre
mises dans un fichier externe dont l'extension est gnralement .css. Le document fait alors rfrence cette
feuille de style. Les rgles de style peuvent aussi tre incluses directement dans le document. Pour un document
XHTML, elles peuvent se placer dans un lment style de l'entte. Elles peuvent aussi tre ajoutes dans un
attribut style de n'importe quel lment.
10.6.1. Rfrence un document externe

La faon de rfrencer une feuille de style externe dpend du format du document. Pour un document XML, il faut
utiliser une instruction de traitement xml-stylesheet. Pour un document XHTML, il faut utiliser un lment
link dans l'entte.
<?xml-stylesheet type="text/css" href="bibliography.css" ?>
<head>
214
CSS
<title>Titre de la page</title>
<link href="style.css" rel="stylesheet" type="text/css" />
</head>
10.6.2. Inclusion dans l'entte du fichier XHTML

Les rgles de style peuvent tre directement incluses dans un lment style de l'entte, c'est--dire contenues
dans l'lment head. Il est prfrable de protger ces rgles par des balises '' de commentaires.
<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>
10.6.3. Inclusion dans un attribut d'un lment

Chaque lment peut aussi avoir un attribut style qui contient uniquement des couples proprit/valeur spars
par des virgules. Les slecteurs sont inutiles puisque ces rgles s'appliquent implicitement cet lment.
<span style="text-decoration: overline">A</span>
10.7. Principales proprits

10.7.1. Polices de caractres et texte
Proprit
Valeur
color
couleur
font
combinaison des proprits font-*
font-family
nom de police, serif, sans-serif, cursive,

fantasy ou monospace
font-style
normal, italic, oblique
font-variant
normal, small-caps
font-weight
normal, bold, bolder ou lighter
font-size
dimension
text-decoration
none, underline, overline, line-through

ou blink
text-transform
none, capitalize, uppercase ou lowercase
word-spacing
normal ou dimension
letter-spacing
normal ou dimension
vertical-align
baseline, sub, super, top, text-top,

middle, bottom, text-bottom ou pourcentage
text-align
left, right, center ou justify
text-indent
dimension ou pourcentage
line-height
normal, facteur, dimension ou pourcentage
white-space
normal, pre, nowrap, pre-wrap ou pre-line
content
chane de caractres
215
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.3. Botes et positionnement

Proprit
Valeur
width height
auto, dimension ou pourcentage
padding
padding-top
padding-right dimension ou pourcentage
padding-bottom padding-left
border-style
none, dotted, dashed, solid,

groove, ridge, inset ou outset
border-width
medium, thin, thick ou une dimension
border-color
couleur
double,
margin margin-top margin-right margin- auto, dimension ou pourcentage

bottom margin-left
position
static, relative, absolute ou fixed
top right bottom left
auto, dimension ou pourcentage
float
none, left ou right
clear
none, left, right ou both
overflow
visible, hidden, scroll ou auto
visibility
visible ou hidden
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, upperRoman, lower-Roman, upper-alpha ou loweralpha
216
Chapitre 11. SVG

SVG est un dialecte de XML pour le dessin vectoriel. Ce format permet de dfinir les lments graphiques de
manire standard.
l l o , SV G!
e
H
Figure 11.1. Rendu du document ci-dessous
<?xml version="1.0" encoding="iso-8859-1" standalone="no" ?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN"
"http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">
<svg version="1.0" width="200" height="100"
xmlns="http://www.w3.org/2000/svg"
xmlns:xlink="http://www.w3.org/1999/xlink">
<defs>
<path id="textpath"
d="M 15,80 C 35,65 40,65 50,65 C 60,65 80,75 95,75
C 110,75 135,60 150,60 C 165,60 170,60 185,65"
style="fill:none;stroke:black;" />
</defs>
<text style="font-family:Verdana; font-size:28;
font-weight:bold; fill:red">
<textPath xlink:href="#textpath">
Hello, SVG!
</textPath>
</text>
<use xlink:href="#textpath" y="10"/>
</svg>
11.2. lments de dessins

11.2.1. Formes lmentaires
lment
Rendu
Ligne
x2 ,y2
<line x1=... y1=... x2=... y2=... />

x1 ,y1
217
SVG
lment
Rendu
Rectangle
x,y
<rect
x=...
height=... />
y=...
wid t h
width=...
h e ig h t
Ellipse
<ellipse cx=... cy=... rx=... ry=... /
>
c x,c y
rx
ry
Ligne polygonale
<polyline
y3 ..."/>
points="x1
x3 ,y3
y1
x2
y2
x3
x1 ,y1
x4 ,y4
x2 ,y2
Ligne polygonale ferme

<polygon points="x1
y3 ..."/>
x3 ,y3
y1
x2
y2
x3
x1 ,y1
x4 ,y4
x2 ,y2
11.2.2. Chemins
lment
Rendu
Point de dpart
<path d="M x1 y1"/>
x1 ,y1
Ligne horizontale
<path d="M x1 y1 H x2"/>
x1 ,y1
Ligne verticale
x2 ,y1
x1 ,y1
<path d="M x1 y1 V y2"/>
x1 ,y2
218
SVG
lment
Rendu
Ligne
x2 ,y2
<path d="M x1 y1 L x2 y2"/>

x1 ,y1
Courbe de Bzier quadratique
c x,c y
x2 ,y2
<path d="M x1 y1 Q cx cy x2 y2"/>
x1 ,y1
Courbe de Bzier quadratique avec partage de point de

contrle
c x1 ,c y1
x3 ,y3
x2 ,y2
<path d="M x1 y1 Q cx cy x2 y2 T x3
y3"/>
x1 ,y1
Courbe de Bzier cubique
c x1 ,c y1
x2 ,y2
<path d="M x1 y1 C cx1 cy1 cx2 cy2

x2 y2"/>
c x2 ,c y2
x1 ,y1
Courbe de Bzier cubique avec partage de point de

contrle
c x1 ,c y1
c x3 ,c y3
<path d="M x1 y1 C cx1 cy1 cx2 cy2 x2

y2 S cx3 cy3 x3 y3"/>
x2 ,y2
c x2 ,c y2
x1 ,y1
Fermeture du chemin par une ligne
x3 ,y3
c x,c y
x2 ,y2
<path d="M x1 y1 Q cx cy x2 y2 Z"/>
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
<path d="..." fill="evenodd"/>
219
SVG
lment
Rendu (PNG)
Rgle nonzero
<path d="..." fill="nonzero"/>
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
11.4. Indications de style

11.4.1. Attribut style
<svg width="200" height="100">
<rect x="10" y="10" width="180" height="80" style="stroke:black;fill:none"/>
<ellipse cx="100" cy="50" rx="90" ry="40" style="stroke:black;fill:red"/>
<ellipse class="circle" cx="100" cy="50" rx="40" ry="40"/>
</svg>
11.4.2. Attributs spcifiques

<rect x="10" y="10" width="180" height="80" stroke="black" fill="none"/>
<ellipse cx="100" cy="50" rx="90" ry="40" stroke="black"/>
<ellipse class="circle" cx="100" cy="50" rx="40" ry="40" fill="red"/>
</svg>
11.4.3. lment style

<style type="text/css">
rect { stroke: red}
ellipse { fill: red }
ellipse.circle { fill: white }
</style>
<rect x="10" y="10" width="180" height="80"/>
<ellipse cx="100" cy="50" rx="90" ry="40"/>
</svg>
220
SVG
11.4.4. Feuille de style attache

<?xml-stylesheet href="stylesvg.css" type="text/css"?>
</svg>
11.4.5. Au niveau d'un groupe

<g style="stroke: black; fill: none">
</g>
</svg>
11.5. Courbes de Bzier et B-splines

11.5.1. Courbes de Bzier
Les courbes de Bzier sont des courbes de degr 3. Elles sont donc dtermines par quatre points de contrle. La
courbe dtermine par les points P1, P2, P3 et P4 va de P1 P4 et ses drives en P1 et P4 sont respectivement 3(P2
- P1) et 3(P3 - P4). Ceci signifie en particulier que la courbe est tangente en P1 et P4 aux droites P1P2 et P3P4.
P3
P4
P2
P2
P3
P2
P1
P4
P1
P3
P1
P4
Figure 11.2. Courbes de Bzier

Si les coordonnes des points de contrle sont (x1, y1), (x2, y2), (x3, y3) et (x4, y4), la courbe est dcrites par les
formules suivantes qui donnent la courbe sous forme paramtre.
x(t) = (1-t)3x1 + 3t(1-t)2x2 + 3t2(1-t)x3 + t3x4 pour 0 t 1
y(t) = (1-t)3y1 + 3t(1-t)2y2 + 3t2(1-t)y3 + t3y4 pour 0 t 1
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(1t)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.
221
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
Figure 11.3. Construction de Casteljau
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.
xi(t) = 1/6[ (1-t)3xi + (3t3-6t2+4)xi+1 + (-3t3+3t2+3t+1)xi+2 + t3xi+3] pour 0 t 1
yi(t) = 1/6[ (1-t)3yi + (3t3-6t2+4)yi+1 + (-3t3+3t2+3t+1)yi+2 + t3yi+3] pour 0 t 1
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.
si(1) = si+1(0) = 1/6(Pi+1 + 4Pi+2 + Pi+3)
s'i(1) = s'i+1(0) = 1/2(Pi+3 - Pi+1)
s''i(1) = s''i+1(0) = Pi+3 - 2Pi+2 + Pi+1
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.
x'1 = 1/6(x1 + 4x2 + x3)
222
SVG
x'2 = 1/6(4x2 + 2x3)

x'3 = 1/6(2x2 + 4x3)
x'4 = 1/6(x2 + 4x3 + x4)
Les formules suivantes permettent la transformation inverse
x1 = 6x'1 - 7x'2 + 2x'3
x2 = 2x'2 - x'3
x3 = -x'2 + 2x'3
x4 = 2x'2 - 7x'3 + 6x'4
223
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
source.xm l
Eve n t
Ha n d le r
Pa rs e r
Figure 12.1. Principe de SAX

SAX est une API permettant de lire un fichier XML sous forme de flux. Le principe de fonctionnent est le suivant.
L'application cre un parseur et elle enregistre auprs de ce parseur son gestionnaire d'vnements. Au cours de
la lecture du fichier contenant le document XML, le gestionnaire reoit les vnements gnrs par la parseur. Le
document XML n'est pas charg en mmoire.
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.
12.1.2. Lecture d'un fichier XML avec SAX

Handler TrivialSAXHandler.java minimal
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
224
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();
}
}
Lecture TrivialSAXRead.java d'un fichier XML
// IO
import
import
// SAX
import
import
java.io.InputStream;
java.io.FileInputStream;
javax.xml.parsers.SAXParserFactory;
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
225
Programmation XML
SAXParserFactory parserFactory = SAXParserFactory.newInstance();

// Cration du parser
SAXParser parser = parserFactory.newSAXParser();
// Lecture de chaque fichier pass en paramtre
for(int i = 0; i < args.length; i++) {
// Flux d'entre
InputStream is = new FileInputStream(args[i]);
parser.parse(is, new TrivialSAXHandler());
}
}
}
12.2. DOM
12.2.1. Principe
Ap p lic a t io n
source.xm l
Do c u m e n t t re e
Bu ild e r
Figure 12.2. Principe de DOM

DOM est une API permettant de charger un document XML sous forme d'un arbre qu'il est ensuite possible de
manipuler. Le principe de fonctionnent est le suivant. L'application cre un constructeur qui lit le document XML
et construit une reprsentation du document XML sous forme d'un arbre.
12.2.2. Arbre document


<?xml-stylesheet href="tree.xsl" type="text/xsl"?>
<table type="technical">
<item key="id001" lang="fr">
XML & Co
</item>
<item>

226
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
Figure 12.3. Arbre d'un document
227
Programmation XML
12.2.3. Principales classes

Do c u m e n t
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
Figure 12.4. Classes du DOM
12.2.4. Lecture d'un fichier XML avec DOM

Lecture TrivialDOMRead.java d'un fichier XML
// IO
import
import
// DOM
import
import
import
java.io.InputStream;
java.io.FileInputStream;
javax.xml.parsers.DocumentBuilderFactory;
javax.xml.parsers.DocumentBuilder;
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();
228
Programmation XML
// Lecture de chaque fichier pass en paramtre

for(int i = 0; i < args.length; i++) {
// Flux d'entre
InputStream is = new FileInputStream(args[i]);
// Construction du document
Document doc = documentBuilder.parse(is);
// Exploitation du document ...
System.out.println(doc);
}
}
}
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.
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" >
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fr" lang="fr">
<head>
<title>
Chargement dynamique
</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<meta name="Author" content="Olivier Carton" />
<script type="text/javascript">
// Dans la premire version de Google Suggest, la fonction
// s'appelait sendRPCDone. Elle s'appelle maintenant
// window.google.ac.Suggest_apply
window.google = new Object();
window.google.ac = new Object();
window.google.ac.Suggest_apply = sendRPCDone;
var XMLHttpRequestObject = false;
// Cration du gestionnaire de connexion
if (window.XMLHttpRequest) {
XMLHttpRequestObject = new XMLHttpRequest();
} else {
XMLHttpRequestObject = new ActiveXObject("Microsoft.XMLHTTP");
}
// Fonction de chargement des donnes
function getData(url) {
if (XMLHttpRequestObject) {
// Mise en place de la requte
XMLHttpRequestObject.open("GET", url);
229
Programmation XML
// Mise en place du handler

XMLHttpRequestObject.onreadystatechange = function() {
if (XMLHttpRequestObject.readyState == 4 &&
XMLHttpRequestObject.status == 200) {
// valuation du rsultat
eval(XMLHttpRequestObject.responseText);
}
}
// Envoi de la requte
XMLHttpRequestObject.send(null);
}
}
// Fonction appele chaque entre de caractre
function getSuggest(keyEvent) {
var keyEvent = (keyEvent) ? keyEvent : window.event;
var input = (keyEvent.target) ? keyEvent.target : keyEvent.srcElement;
// Utilisation du wrapper google.php
var url = "google.php?qu=";
if (keyEvent.type == 'keyup') {
if (input.value) {
getData(url + input.value);
} else {
var target = document.getElementById("target");
target.innerHTML = "<div></div>";
}
}
}
// Fonction appele par la requte
function sendRPCDone(unused, term, results, unusedArray) {
// Entte de la table de prsentation des rsultats
var data = "<table align='left' border='1' " +
"cellpadding='2' cellspacing='0'>";
if (results.length != 0) {
for (var i = 1; i < results.length-1; i = i + 2) {
data += "<tr><td><a href='http://www.google.com/search?q=" +
results[i] + "'>" + results[i] + "</a></td>" +
"<td>" + results[i+1] + "</td></tr>";
}
}
data += "</table>";
var target = document.getElementById("target");
target.innerHTML = data;
}
</script>
</head>
<body>
<h2>Google Live Search</h2>


<p><input type="text" onkeyup="JavaScript:getSuggest(event)" /></p>

<p><div id="target"></div></p>
</body>
230
Programmation XML
</html>
231
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
232
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]
233
Bibliographie
XML
A. Michard. XML langage et applications. Eyrolles. Paris. 2001. 2-212-09206-7.
B. Marchal. XML by Example. Macmillan Couputer Publishing. 2000.
M. Morrison. XML. CampusPress. 2005.
F. Role. Modlisation et manipulation de documents XML. Lavoisier. 2005.
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.
J.-J. Thomasson. Schmas XML. Eyrolles. 2003. 2-212-11195-9.
XSLT et XSL-FO
P. Drix. XSLT fondamental. Eyrolles. 2002.
D. Tidwell. XSLT. O'Reilly. 2001.
M. Kay. XSLT 2.0 Programmer's Reference. Wiley Publishing Inc.. 2004.
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.
234
Index
Symboles
##any, 67
##local, 67
##other, 67
##targetNamespace, 67
#all, 199
#current, 199
#default, 199
#FIXED, 38, 71
#IMPLIED, 27, 37, 38, 70
#PCDATA, 23, 26, 34, 37, 61
#REQUIRED, 28, 37, 38, 70
' ', 142, 173, 173, 211
'!=', 124, 137, 173
'"', 15, 19, 27, 29, 29, 31, 38, 38, 129
'#', 183, 209
'$', 75, 131, 133, 133
'%', 31, 183
'&', 18, 19, 29, 29, 173
''', 15, 19, 27, 29, 29, 31, 38, 38, 129, 193, 193
'(' et ')', 32, 36, 108, 131
'()', 140
'*', 32, 75, 101, 108, 117, 123, 128, 143, 161, 164, 173,
192, 209
'*/', 208
'+', 26, 32, 108, 117, 128, 211
',', 32, 61, 116, 134, 135, 135, 182, 183
'-', 8, 20, 26, 109, 109, 128, 183, 210
'-->', 21, 215
'.', 8, 75, 109, 118, 133, 135, 138, 142, 163, 164, 174,
183, 192, 203, 209
'..', 142
'/', 13, 101, 115, 124, 143, 143, 163
'/*', 208
'//', 13, 26, 101, 124, 142, 143, 192, 202
'/>', 17
'0', 183
':', 8, 12, 13, 26, 42, 208
'::', 119
';', 29, 31, 183, 208
'<!', 25, 28
'<!--', 21, 215
'<', 11, 16, 17, 18, 19, 124, 124, 137, 173
'</', 16
'<<', 115, 139
'<=', 137, 151
'<?', 22
'<?xml', 15, 22, 27
'=', 19, 124, 137, 210
'>', 16, 17, 18, 19, 28, 29, 124, 137, 173, 211
'>=', 137, 151
'>>', 115, 139
'?', 11, 32, 108, 117
'?>', 22
'@', 101, 142

'@*', 143, 164
'i', 133
'm', 133
's', 133
'U+', 7
'[' et ']', 26, 109, 134, 142, 210
'\', 108, 109
'\c', 110
'\C', 110
'\d', 109
'\D', 109
'\i', 109
'\I', 110
'\s', 109, 132
'\S', 109
'\w', 109
'\W', 109
']]>', 18
'^', 75, 109, 133, 133
'_', 8
'{' et '}', 108, 140, 172, 208
'{{' et '}}', 172
'|', 32, 36, 62, 101, 108, 126, 143
'|=', 210
'~=', 210
'', 11
'', 11
'', 183
'', 9
'##', 9
A
absolute, 213
abstract, 85, 85, 86, 88, 151, 152
analyse lexicale, 8, 18, 22, 57, 76
ancestor-or-self::, 121, 174
ancestor::, 121
anctre, 18
and, 127, 135, 151
ANY, 35
arbre du document, 111
as, 192, 193, 194, 197
atomisation, 114, 117
ATTLIST, 35
attribut, 18
dclaration, 35, 68
interdit, 70
obligatoire, 38, 70
optionnel, 38, 70
particulier, 19
attribute(), 117
attribute::, 120, 123
attributeFormDefault, 50, 105
axe, 119, 119, 143
235
Index
B
balise, 16
base, 71, 74
block, 50, 85, 89, 91, 213
blockDefault, 50, 89, 91
C
C++, 48, 54, 71, 86, 193
caractres
codage des, 9
d'chappement, 108
d'espacement, 8, 20, 33, 57, 76, 108, 132, 161
des identificateurs, 8, 75
spciaux, 8, 18, 19, 22, 173
CDATA, 18, 36
child::, 120, 123, 123
collapse, 76
collation, 11, 117
comment(), 117, 123, 124
commentaire, 21, 28, 51, 112, 149, 176, 208, 215
contenu
d'un lment, 16
dterministe, 34
mixte, 34, 60
pur, 32, 59
context, 149
contexte, 117, 192
dynamique, 118
statique, 117
corps du document, 15, 16
D
decimal-separator, 184
default, 20, 52, 71
descendant, 18
descendant-or-self::, 120
descendant::, 120, 124
display, 213
div, 128
DocBook, 5, 22, 41, 45, 47, 165, 175, 188, 205
DOCTYPE, 16, 25, 25, 26, 27, 27, 27
doctype-public, 161
doctype-system, 161
document-node(), 117
DTD, 25, 45, 48, 161
Dublin Core, 41, 47
E
ELEMENT, 32, 61
lment, 16, 16
abstrait, 85, 88
bloqu, 91
dclaration, 32, 52
final, 94
global, 53
local, 53
racine, 16, 18, 21, 25
vide, 17, 35, 61

element(), 117
elementFormDefault, 50, 104
else, 140
EMPTY, 35, 37, 37
encoding, 15, 161
enfant, 18, 113
entte, 15, 22, 27, 31
entit, 29
gnrale, 29
paramtre, 27, 31
prdfinie, 29, 173
ENTITIES, 36
ENTITY, 29, 31, 36
eq, 136, 198
espace de noms, 12, 41, 67, 71, 103, 117, 148, 160, 167,
170
cible, 67, 98, 104, 107
par dfaut, 43
Euro, 7, 10, 30, 30, 132
every, 118, 141
except, 124, 126
exclude-result-prefixes, 160, 188
expression
rationnelle, 32, 108, 130, 131, 132, 133, 204
XPath, 111
F
facette, 74
fixe, 86
false, 55, 127
filtre, 124, 134
final, 50, 85, 92, 93, 94
finalDefault, 50, 93
fixed, 52, 71, 86, 213
focus, 118, 124, 134, 163, 164, 166, 185
following-sibling::, 121, 177
following::, 121, 124
for, 118, 140, 192
form, 50
FPI, 26, 27, 29, 29, 31, 161
frre, 18
G
ge, 137
gros-boutiste, 11
group-starting-with, 188
groupe
d'attributs, 95, 107, 174
d'lments, 95
de substitution, 83
grouping-separator, 182, 184
grouping-size, 182
gt, 137
H
html:style, 193
236
Index
ne, 137
nillable, 81
NMTOKEN, 8, 36
NMTOKENS, 36
node(), 114, 117, 123, 124, 125, 164, 164, 172
nom
local, 42
qualifi, 9, 42, 175
XML, 8, 16, 19, 22, 29, 37, 109
none, 213
normalisation
des caractres d'espacement, 132
des fins de lignes, 8
Unicode, 12, 132
NOTATION, 36
nud, 18, 111
courant, 114, 118, 119, 119, 142, 163, 166
I
ID, 8, 21, 36, 98, 115, 118
id, 31
identificateur, 8
idiv, 128
IDREF, 36, 37, 98, 115
IDREFS, 36, 37, 115
if, 127, 140, 172, 197, 198, 198, 198
in, 141, 141, 142
inline, 213
instruction de traitement, 22, 112, 176
intersect, 126
is, 139, 202
is-a, 152
ISBN, 12
ISO 10646, 7
ISO 3166, 20, 56
ISO 639, 20, 26, 56
ISO 9070, 26
ISO-8859-1, 10, 15
ISO-8859-15, 10
item(), 116
itemType, 65
O
objet
courant, 118, 124, 134, 185
OpenDocument, 5
OpenStreetMap, 4
optional, 70
or, 127, 135, 135, 198
ordre du document, 115, 124, 126, 136, 139
J
Java, 48, 54, 71, 86, 139, 140, 183, 193
jeton, 8, 36
paramtre, 193
parent, 18, 113
parent::, 120
parse, 23
Perl, 108
petit-boutiste, 11
point de code, 6, 7, 132
position, 213
position(), 125
preceding-sibling::, 121
preceding::, 121
preserve, 20, 76
priorit, 165, 205
d'import, 165, 205
priority, 165
processContents, 66, 71
processing-instruction(), 117, 123, 124, 124
prohibited, 70, 70
prologue, 15, 15
PUBLIC, 26, 27, 29, 31
Latin-1, 10
Latin-15, 10
le, 137
ligature, 11
link, 214
list-item, 213
lt, 137
M
marque d'ordre des octets, 11
match, 159, 163, 165, 169
MathML, 4, 42
maxOccurs, 62, 64, 64, 65, 66
memberTypes, 64
minOccurs, 62, 64, 65, 66, 106
mixed, 60
ML, 140
mod, 128, 135, 174
mode, 163, 199, 199
motif
XPath, 142, 149, 163, 179, 201
Q
QNAME, 42
qualified, 50
N
name, 53, 59, 68, 68, 95, 97, 151, 166, 174, 174, 192,
193, 194, 197, 201
namespace, 67, 71, 107
namespace::, 122
NCNAME, 42
R
racine, 111, 115, 126
ref, 53, 61, 69, 95, 97, 105
regexp, 204
237
Index
relative, 213
replace, 76
required, 70
return, 141
RSS, 4
de document, 16
de nud, 111
final, 93
nomm, 52
prdfini, 54
simple, 59, 72, 74
S
SAML, 5
satisfies, 141, 142
sch:active, 155
sch:assert, 146, 149, 149, 150, 151
sch:extends, 151
sch:let, 151
sch:name, 150, 151, 153, 153
sch:ns, 148, 154
sch:p, 149
sch:param, 152
sch:pattern, 149, 151
sch:phase, 155
sch:report, 149, 149, 150, 150
sch:rule, 146, 149, 149, 150, 150, 150, 151
sch:schema, 146, 148, 151
sch:title, 146, 149
sch:value-of, 150, 155
schma, 48
schemaLocation, 107
section littrale, 18, 34
select, 150, 163, 173, 174, 176, 178, 185, 186, 190, 190,
192, 193, 194, 204
self::, 120, 142, 151
separator, 173
SMIL, 4
some, 118, 141
standalone, 15, 33
starts-with, 130
static, 213
style, 214, 215
substitution
d'lment, 83, 86, 88
d'espaces de noms, 170
de type, 81, 81, 89, 91
substitutionGroup, 83, 89, 89, 92, 92, 95
SVG, 4
SVRL, 147
SYSTEM, 27, 27, 27, 29, 31, 31
T
targetNamespace, 50, 103
text(), 117, 123, 123, 126, 143, 173, 192, 195, 199
then, 140
to, 134, 192
true, 55, 127
type, 52, 68, 68, 105
abstrait, 86
anonyme, 52
bloqu, 89
complexe, 59, 72, 73, 76, 78
U
U+, 6
UBL, 5
UCS-2, 9
UCS-4, 9
Unicode, 7
union, 126
unqualified, 50, 104
URI, 12, 26
de base, 13, 20, 117
rsolution, 13
URL, 12, 27, 27, 29, 29, 31, 161
URN, 12, 26
US-ASCII, 9, 15
use, 61, 70, 70
use-attribute-sets, 174
UTF-16, 9, 15
UTF-32, 9
UTF-8, 10, 15
V
version, 15, 16, 160
W
WSDL, 4
X
xi:include, 23
XInclude, 23, 46
XLink, 3, 36, 46
xml-stylesheet, 9, 22, 112, 214
xml:base, 9, 20, 23, 56, 107
xml:id, 9, 21, 32, 38, 107, 115, 118
xml:lang, 20, 31, 56, 107, 184
xml:space, 8, 20, 107, 161
xml:specialAttrs, 98, 107
xmllint, 23, 30, 40, 50, 143
xmlns, 42
XPath, 4
xpath:abs(), 128
xpath:avg(), 129
xpath:base-uri(), 21, 115
xpath:ceiling(), 128
xpath:codepoints-to-string(), 132
xpath:compare(), 130
xpath:concat(), 130, 174, 195, 198
xpath:contains(), 30, 130, 140, 177, 195, 197, 198
xpath:count(), 124, 135, 148, 153
xpath:current(), 119, 163, 192
xpath:current-group(), 119, 186, 188
238
Index
xpath:current-grouping-key(), 119, 186

xpath:data(), 114
xpath:distinct-values(), 135
xpath:document(), 203
xpath:document-uri(), 115
xpath:empty(), 135
xpath:ends-with(), 130
xpath:exists(), 135
xpath:false(), 127
xpath:floor(), 128
xpath:format-number(), 118, 183
xpath:generate-id(), 118, 140, 172, 194, 202
xpath:id(), 37, 115, 164, 200
xpath:in-scope-prefixes(), 115
xpath:index-of(), 136, 190
xpath:insert-before(), 136
xpath:key(), 19, 150, 154, 174, 192, 201, 202
xpath:last(), 118, 124, 173
xpath:local-name(), 114, 188
xpath:lower-case(), 132
xpath:matches(), 108, 130, 133
xpath:max(), 129
xpath:min(), 129
xpath:name(), 114, 117, 124, 177, 180, 190, 192, 202
xpath:namespace-uri(), 115
xpath:namespace-uri-for-prefix(), 115
xpath:node-name(), 114
xpath:normalize-space(), 132
xpath:normalize-unicode(), 12, 132
xpath:not(), 127
xpath:number(), 118
xpath:position(), 118, 124, 125, 135, 173, 174, 185
xpath:regexp-group(), 119, 204
xpath:remove(), 136
xpath:replace(), 108, 131, 133, 196, 204
xpath:resolve-uri(), 115
xpath:reverse(), 136
xpath:root(), 115
xpath:round(), 128
xpath:round-half-to-even(), 128
xpath:string(), 114
xpath:string-join(), 130
xpath:string-length(), 130
xpath:string-to-codepoints(), 132
xpath:subsequence(), 136
xpath:substring(), 131, 151
xpath:substring-after(), 131, 195, 198, 198
xpath:substring-before(), 131, 140, 195, 197, 198
xpath:sum(), 129
xpath:tokenize(), 108, 132, 133
xpath:translate(), 131
xpath:true(), 127
xpath:upper-case(), 132
XPointer, 3
XQuery, 4
xsd:all, 59, 63, 85, 95
xsd:annotation, 51
xsd:any, 66
xsd:anyAtomicType, 116
xsd:anyAttribute, 71
xsd:anySimpleType, 116
xsd:anyType, 54, 85, 87, 116
xsd:anyURI, 20, 56, 116
xsd:appInfo, 51
xsd:attribute, 51, 61, 68, 97
xsd:attributeGroup, 95, 97, 107
xsd:base64Binary, 56
xsd:boolean, 55, 116
xsd:boolean(), 118, 127, 127
xsd:byte, 55
xsd:choice, 59, 61, 62, 85, 95
xsd:complexContent, 60, 64, 71, 74, 91
xsd:complexType, 51, 52, 54, 59, 60, 64, 71, 74, 86, 89,
93
xsd:date, 57, 70, 74, 116
xsd:dateTime, 57, 116
xsd:dayTimeDuration, 57, 116
xsd:decimal, 56, 72, 76, 116, 128
xsd:documentation, 51
xsd:double, 56, 76, 116, 128
xsd:double(), 138
xsd:duration, 57, 116
xsd:element, 51, 52, 52, 52, 60, 61, 81, 83, 88, 91, 94,
102
xsd:ENTITIES, 59
xsd:ENTITY, 59
xsd:enumeration, 64, 68, 74, 75
xsd:extension, 69, 70, 71, 72, 72, 76, 82, 87, 89, 91, 93,
94, 95
xsd:field, 98, 102
xsd:float, 56, 76, 116
xsd:fractionDigits, 76
xsd:gDay, 58
xsd:gMonth, 57
xsd:gMonthDay, 58
xsd:group, 95
xsd:gYear, 57
xsd:gYearMonth, 57
xsd:hexBinary, 57
xsd:ID, 21, 21, 59, 115, 118
xsd:IDREF, 59, 61
xsd:IDREFS, 59, 114
xsd:import, 107
xsd:include, 107
xsd:int, 55
xsd:integer, 53, 55, 74, 116, 117, 128
xsd:integer(), 137
xsd:key, 98, 102
xsd:keyref, 102
xsd:language, 20, 56, 69, 74
xsd:length, 65, 75, 89
xsd:list, 65, 75, 76, 114
xsd:long, 55
xsd:maxExclusive, 74, 76
xsd:maxInclusive, 59, 74, 76, 82
xsd:maxLength, 75, 86
239
Index
xsd:maxLenth, 76
xsd:minExclusive, 74, 74, 76
xsd:minInclusive, 74, 76, 86
xsd:minLength, 75, 86
xsd:Name, 56
xsd:NCName, 56
xsd:negativeInteger, 55
xsd:NMTOKEN, 57, 59, 71
xsd:NMTOKENS, 59
xsd:nonNegativeInteger, 56, 59, 64, 82, 89
xsd:nonPositiveInteger, 55
xsd:normalizedString, 56, 76, 132
xsd:NOTATION, 59
xsd:pattern, 75, 75
xsd:positiveInteger, 55, 92, 95
xsd:QName, 56
xsd:restriction, 59, 64, 65, 68, 74, 76, 76, 82, 86, 87, 89,
89, 91, 93, 94
xsd:schema, 50, 51, 69, 89, 91, 93, 95, 97, 103
xsd:selector, 98, 102
xsd:sequence, 53, 59, 60, 61, 95
xsd:short, 55
xsd:simpleContent, 60, 69, 71, 72, 72, 74
xsd:simpleType, 51, 52, 54, 59, 74, 76, 93
xsd:string, 53, 56, 68, 76, 76, 116
xsd:time, 57, 116
xsd:token, 56, 76
xsd:totalDigits, 76
xsd:union, 64, 75
xsd:unique, 98
xsd:unsignedByte, 55
xsd:unsignedInt, 55
xsd:unsignedLong, 55
xsd:unsignedShort, 55
xsd:untyped, 116
xsd:untypedAtomic, 114, 116, 117, 137
xsd:whiteSpace, 76
xsd:yearMonthDuration, 57, 116
xsi:nil, 81
xsi:noNamespaceSchemaLocation, 45, 51
xsi:schemaLocation, 51
xsi:type, 81, 83, 86, 88, 91
xsl:analyze-string, 108, 204
xsl:apply-imports, 165, 205
xsl:apply-templates, 152, 159, 159, 162, 163, 164, 168,
177, 185, 190, 194, 199
xsl:attribute, 140, 172, 174, 174, 175, 194, 202
xsl:attribute-set, 174
xsl:call-template, 152, 166, 187, 190, 194
xsl:choose, 140, 184, 184, 188
xsl:comment, 175, 176, 193
xsl:copy, 161, 177, 180, 190, 202
xsl:copy-of, 177, 177, 178, 190, 192, 200, 202
xsl:decimal-format, 118, 183
xsl:element, 174, 177
xsl:for-each, 163, 164, 177, 184, 185, 190, 192, 201
xsl:for-each-group, 119, 119, 184, 186, 190
xsl:function, 195, 197
xsl:if, 19, 173, 174, 180, 184, 202

xsl:import, 165, 166, 176, 205
xsl:include, 205
xsl:key, 154, 192, 201
xsl:matching-substring, 119, 204
xsl:namespace-alias, 170
xsl:next-match, 165
xsl:non-matching-substring, 204
xsl:number, 164, 179, 182, 185, 185
xsl:otherwise, 185
xsl:output, 161, 161, 178, 187
xsl:param, 152, 167, 191, 193, 197, 205
xsl:perform-sort, 191
xsl:preserve-space, 161
xsl:processing-instruction, 176
xsl:sequence, 116, 176, 191, 192, 192, 195, 198, 198,
198
xsl:sort, 165, 185, 187, 190, 204
xsl:strip-space, 161
xsl:stylesheet, 160, 170, 192, 193, 193, 197, 201, 205
xsl:template, 119, 159, 159, 162, 163, 164, 165, 168,
193, 199, 205
xsl:text, 164, 173, 185
xsl:transform, 160
xsl:value-of, 19, 168, 173, 175, 184, 185, 187, 191, 193,
198, 198, 199, 202
xsl:variable, 177, 190, 191, 191, 192, 195, 198, 200
xsl:when, 30, 185
xsl:with-param, 152, 167, 191, 194
xsltproc, 193
XUL, 4
240

XML 6

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

XML 6

Transféré par

Droits d'auteur :

Formats disponibles

L'essentiel de XML

L'essentiel de XML: Cours XML

Table des matires

6.3. Valeurs atomiques .......................................................................................................

Chapitre 1. Prsentation de XML

1.3. Langages apparents

XPath [ ] (langage de slection)

SAML [ ] (Security Assertion Markup Language)

<!DOCTYPE root-element ... >

Chapitre 2. Syntaxe de XML

2.1. Premier exemple

2.2.1. Caractres spciaux

2.2.2. Caractres d'espacement

2.2.3. Jetons et noms XML

2 octets codant 16 bits

4 octets codant 20 bits

yyyy xxxxxxxx xxxxxxxx o zzzz = yyyy-1

Tableau 2.1. Codage UTF-16

1 octet codant 7 bits

2 octets codant 8 11 bits

1110xxxx 10xxxxxx 10xxxxxx

3 octets codant 12 16 bits

11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

4 octets codant 17 21 bits

Tableau 2.2. Codage UTF-8

Squence d'octets en hexadcimal pour Htrogne

Squence d'octets en hexadcimal pour Htrogne

Tableau 2.3. Comparaison des codages

2.2.4.1. Marque d'ordre des octets

Squence d'octets en hexadcimal

UTF-8 sans BOM

UTF-8 avec BOM

Tableau 2.4. Marques d'ordre des octets

2.3. URI, URL et URN

Figure 2.1. Relations entre URI, URL et URN

2.3.1. Rsolution d'URI

Adresse Int ernet

Figure 2.2. Structure d'une URL

2.4. Syntaxe et structure

2.5. Composition globale d'un document

<?xml ... ?>

2.6.1. Entte XML

2.6.2. Dclaration de type de document

2.7. Corps du document

Figure 2.3. Composition d'un lment

Figure 2.4. lment avec un contenu vide

< t ag1> < t ag2>

< /t ag2> < /t ag1>

< t ag1> < t ag2>

< /t ag1> < /t ag2>

Figure 2.5. Imbrication des lments

Figure 2.6. Liens de parent

Commentaires et instructions de traitement

Balise ouvrante de l'lment racine

Balise fermante de l'lment racine

Commentaires et instructions de traitement

2.7.2. Sections littrales

2.7.4. Attributs particuliers

2.7.4.1. Attribut xml:lang

2.7.4.2. Attribut xml:space

2.7.4.3. Attribut xml:base

2.7.4.4. Attribut xml:id

2.7.6. Instructions de traitement