L'Essentiel de XML Olivier Carton

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

Olivier Carton
Version du 16/07/2010
Copyright 2007-2010 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. Introduction XML ................................................................................................................... 1
1.1. Historique ...................................................................................................................... 1
1.2. Intrts .......................................................................................................................... 1
1.3. Dialectes et extensions ..................................................................................................... 1
1.4. Applications ................................................................................................................... 2
1.5. DocBook ....................................................................................................................... 2
2. Syntaxe de XML ....................................................................................................................... 4
2.1. Premier exemple ............................................................................................................. 4
2.2. Syntaxe et structure ......................................................................................................... 4
2.3. Composition globale d'un document ................................................................................... 5
2.4. Prologue ........................................................................................................................ 5
2.5. Corps du document ......................................................................................................... 7
2.6. Exemples minimaux ...................................................................................................... 14
2.7. Utilisation de XInclude .................................................................................................. 15
3. DTD ...................................................................................................................................... 17
3.1. Un premier exemple ...................................................................................................... 17
3.2. Dclaration de la DTD ................................................................................................... 17
3.3. Contenu de la DTD ....................................................................................................... 19
3.4. Outils de validations ...................................................................................................... 27
4. Espaces de noms ..................................................................................................................... 28
4.1. Identification d'un espace de noms ................................................................................... 28
4.2. Dclaration d'un espace de noms ...................................................................................... 28
4.3. Porte d'une dclaration .................................................................................................. 29
4.4. Espace de noms par dfaut ............................................................................................. 29
4.5. Attributs ...................................................................................................................... 31
4.6. Espace de noms XML .................................................................................................... 31
4.7. Quelques espaces de noms classiques ............................................................................... 31
5. Schmas XML ........................................................................................................................ 33
5.1. Introduction .................................................................................................................. 33
5.2. Un premier exemple ...................................................................................................... 33
5.3. Structure globale d'un schma ......................................................................................... 34
5.4. Dclarations d'lments .................................................................................................. 36
5.5. Dfinitions de types ....................................................................................................... 38
5.6. Constructions de types ................................................................................................... 41
5.7. Dclarations d'attributs ................................................................................................... 45
5.8. Extension de types ........................................................................................................ 47
5.9. Restriction de types ....................................................................................................... 49
5.10. Substitutions ............................................................................................................... 56
5.11. Groupes d'lments et d'attributs .................................................................................... 69
5.12. Contraintes de cohrence .............................................................................................. 71
5.13. Espaces de noms ......................................................................................................... 72
5.14. Imports d'autres schmas .............................................................................................. 76
6. XPath .................................................................................................................................... 77
6.1. Donnes et environnement .............................................................................................. 77
6.2. Expressions de chemins .................................................................................................. 84
6.3. Valeurs atomiques ......................................................................................................... 91
6.4. Listes .......................................................................................................................... 96
6.5. Comparaisons ............................................................................................................... 98
6.6. Structures de contrle ................................................................................................... 102
6.7. Syntaxe abrge .......................................................................................................... 104
6.8. Utilisation interactive de xmllint .................................................................................... 104
6.9. Rcapitulatif des oprateurs XPath .................................................................................. 105
7. Schematron ........................................................................................................................... 107
7.1. Introduction ................................................................................................................ 107
7.2. Premier exemple ......................................................................................................... 107
iii
Cours XML
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. Programmation 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. Rgles par dfaut ........................................................................................................
8.7. Construction du rsultat ................................................................................................
8.8. Structures de contrle ...................................................................................................
8.9. Tris ...........................................................................................................................
8.10. Variables et paramtres ...............................................................................................
8.11. Fonctions d'extension XPath ........................................................................................
8.12. Modes ......................................................................................................................
8.13. Indexation ................................................................................................................
8.14. Documents multiples ..................................................................................................
8.15. Analyse de chanes ....................................................................................................
9. XSL-FO ...............................................................................................................................
9.1. Premier exemple .........................................................................................................
9.2. Structure globale .........................................................................................................
10. Feuilles de style 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. Rfrences ...........................................................................................................................
A.1. Cours XML ...............................................................................................................
A.2. Tutoriaux ..................................................................................................................
A.3. Spcifications .............................................................................................................
A.4. Sites gnralistes ........................................................................................................
A.5. Sites spcialiss ..........................................................................................................
B. Logiciels XML .....................................................................................................................
B.1. Memento logiciels .......................................................................................................
C. Acronymes XML ..................................................................................................................
Bibliographie ............................................................................................................................
Index .......................................................................................................................................
iv
108
109
110
111
113
115
117
117
119
119
121
122
123
123
129
130
131
134
136
138
138
139
140
140
140
141
141
141
145
145
146
147
148
150
150
150
153
153
154
157
157
159
162
162
165
165
165
165
165
165
166
166
168
170
171
Chapitre 1. Introduction XML

Le langage XML (eXtended Markup Language) est un langage de format de document. Il drive de SGML
(Standard Generalized Markup Language) et HTML (HyperText Markup Language). Comme ces derniers, il s'agit
d'un langage form de balises qui permet de structurer les documents.
Le langage XML s'est impos comme le format standard pour les communications entre applications. Il est utilis
dans la plupart des projets de publication sur le WEB ainsi que dans les bases de donnes.
1.1. Historique
L'historique suivant retrace les grandes tapes qui ont conduit la naissance de XML.
1986
Introduction de SGML [ ] par Charles Goldfarb.
1991
Introduction de HTML [ ] par Tim Berners-Lee pour le WEB.
1998
Publication par le W3C [ ] de la version 1.0 d'XML [ ].
1999
Redfinition de HTML 4.0 en XHTML [ ] travers XML.
2004
Publication par le W3C [ ] de la version 1.1 de XML pour une mise jour des caractres spciaux en lien
avec Unicode.
1.2. Intrts
Sparation stricte entre contenu et prsentation
Structuration forte du document
Extensibilit
Modles de documents (DTDs et XML-Schmas)
Modularit des modles
Validation du document par rapport au modle
Format texte avec gestion des caractres spciaux
Format libre
Nombreuses technologies dveloppes autour de XML
1.3. Dialectes et extensions

XLink [ ] et XPointer [ ]
Liens entre documents
XPath [ ]
Sous-ensemble d'un document
Introduction XML
XQuery [ ]
Requtes de base de donnes
XSL [ ]
Transformation de documents
Schmas XML [ ]
Modles de documents
1.4. Applications
RSS [ ] (Really Simple Syndication)
Flux de donnes
XUL [ ] (XML-based User interface Language)
Langage de description d'interfaces graphiques
SVG [ ] (Scalable Vector Graphics)
Dessin vectoriel
SMIL [ ] (Synchronized Multimedia Integration Language)
Multimdia
MathML [ ]
Formules mathmatiques
WSDL [ ] (Web Services Description Language)
Langage de description de services WEB
XML Signature [ ]
Format pour les signatures lctroniques
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. Il a d'abord t introduit par OpenOffice et il an
ensuite t adopt par d'autres applications comme KOffice.
DocBook [ ]
Format de documentation technique utilis pour cet ouvrage
De nombreux projets informatiques utilisent XML pour le stockage de donnes et en particulier de fichiers de
configurations.
ANT [ ]
Android [ ]
1.5. DocBook
DocBook est un exemple typique d'utilisation de XML. Il s'agit d'un format pour des documents techniques. Cet
ouvrage a t crit en utilisant DocBook.
DocBook tait au dpart bas sur SGML mais il s'appuie maintenant sur XML. Il met l'accent sur la smantique du
document. Il contient de nombreuses balises permettant de dcrire le contenu. Il existe ensuite des outils permettant
de traduire un document DocBook en pages HTML ou en document PDF.
Introduction XML
DocBook dcrit trs prcisment la structure du document en utilisant de nombreuses balises. Par contre, il ne
dcrit pas du tout le rendu du document. Il n'est pas possible de spcifer par exemple la couleur ou la fonte du
texte. L'ide principale de DocBook est de permettre la production de plusieurs documents finaux partir d'un
mme document original : document PDF, pages WEB.
Chapitre 2. Syntaxe de XML

2.1. Premier exemple
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.
<?xml version="1.0" encoding="iso-8859-1" ?>

<!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 fermante de l'lment racine bibliography
2.2. 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 ci-dessous.
Il s'agit en quelque sorte de l'orthographe d'XML. La seconde contrainte est de nature structurelle. Un document
valide doit suivre un modle appel type dcrit par une DTD [Chapitre 3] (Document Type Description) ou un
schma. Une DTD est en fait une grammaire pour XML. La diffrence 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.
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. Les fichiers contenant des documents dans un dialecte
XML peuvent avoir une autre extension qui prcise le format. Les extensions pour les schmas XML, les feuilles
de style XSL, les dessins en SVG sont par exemple .xsd, .xsl et .svg.
Syntaxe de XML
Un fichier XML contient du texte dans un format de codage d'Unicode [ ], par exemple UTF-8 [ ] ou Latin1
[ ]. Le codage utilis par le fichier est prcis dans l'entte du fichier.
Un document XML est, la plupart du temps, stock dans un fichier mais il peut aussi tre dmatrialiser et exister
indpendament 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.3. Composition globale d'un document

Un document XML est compos des trois constituants suivants.
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.4. Prologue
Le prologue contient deux dclarations facultatives mais fortement conseilles ainsi que des commentaires et des
instructions de traitement. 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 ou d'autres types
de modles qui remplacent les DTD. La structure globale du prologue est la suivante.
<?xml ... ?>
<!DOCTYPE root-element [
...
]>
Entte XML
DTD
Les diffrentes parties du prologue sont dtailles dans les sections suivantes.
Prologue
Syntaxe de XML
2.4.1. Entte XML

L'entte utilise une syntaxe <?xml ... ?> semblable celle des instructions de traitement [Section 2.5.8] bien
qu'elle ne soit pas vritablement une instruction de traitement. L'entte XML a la forme gnrale suivante.
<?xml version="..." encoding="..." standalone="..." ?>
Cette entte peut contenir trois attributs version, encoding et standalone. Il ne s'agit pas vritablement
d'attributs 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 '''. 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 utilis dans le fichier. Les principales valeurs possibles sont USASCII, ISO-8859-1, UTF-8, et UTF-16. Ces noms de codage peuvent aussi tre crits en minuscule. L'attribut
standalone prcise si le fichier est autonome, c'est--dire s'il requiert ou non des ressources extrieures. La
valeur de cet attribut peut tre yes ou no.
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. Voici quelques exemples d'entte XML.
<?xml version="1.0"?>
<?xml version='1.0' encoding='UTF-8' ?>
<?xml version="1.0" encoding="iso-8859-1" standalone="no" ?>
2.4.2. Codage des caractres

XML utilise la norme Unicode ISO-10646 [ ] aussi appele UCS pour Universal Character Set pour coder les
caractres. Unicode associe des codes 32 bits (4 octets) tous les caractres des langues connues et bien d'autres
symboles mathmatiques ou autres. On appelle BMP pour Basic Multilingual Plane l'ensemble des caractres
ayant un code sur deux octets c'est--dire entre 0 et 0xFFFF. L'ensemble de ces caractres suffit largement pour
la trs grande majorit des langues usuelles.
Pour viter d'utiliser quatre octets pour chaque caractre, il existe diffrents codages des caractres.
UCS-4 ou UTF-32 [ ]
Chaque caractre est cod directement par son code Unicode sur quatre octets. Ce codage permet donc de
coder tous les caractres Unicode.
UCS-2 [ ]
Chaque caractre est cod par son 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 d'une plage de 2048 positions (0xD800
0xDFFF) qui permettent de coder des caractres en dehors du BMP.
UTF-8 [ ]
Ce codage est le codage par dfaut de XML. Chaque caractre est cod sur un nombre variable d'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. Le caractre euro '', de code hexadcimal
x20AC, est, par exemple, cod par les trois octets 11100010 10000010 10101100. Ce codage a l'avantage
d'tre relativement efficace pour les langues europennes.
ISO-8859-1 (Latin-1) [ ]
Chaque caractre est cod sur un seul octet. Ce codage concide avec l'ASCII pour les codes de 0 0x7F.
Les codes de 0x80 0xFF sont utiliss pour les caractres spciaux (caractres accentus, cdilles, ) des
langues d'Europe de l'ouest.
ISO-8859-15 (Latin-15) [ ]
Ce codage est une mise jour du codage ISO-8859-1 dont il diffre uniquement en 8 positions. Les caractres
'', '', '' et '' remplacent, en particulier, d'autres caractres moins utiles.
Syntaxe de XML
Il est possible d'insrer n'importe quel caractre Unicode dans un document XML en utilisant une des deux syntaxes
&#code dcimal; ou &#xcode hexadcimal;. Le caractre euro '' peut par exemple tre insr par
€ ou €.
Certaines ligatures comme '' 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 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 '' est quivalent aux deux caractres 'oe'. Une collation tablit aussi 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 codes Unicode des caractres. Le caractre '' se trouve, pour cette
collation, aprs le caractre 'z' et le mot 'zbre' est donc avant le mot 'talon' dans l'ordre lexicographique.
Le mme caractre peut tre reprsent de plusieurs faons en Unicode. Ce phnomne 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
'' peut, par exemple, tre reprsent par le code xB5 qui provient de Latin-1 et du code x3BC qui provient
du bloc des caractres grecs. D'autres caractres encore peuvent avoir un codage en un seul caractre et un autre
codage fait d'une suite de plusieurs codes. Le caractre '' peut, par exemple, tre cod par le code xEF ou par
la suite x69 x308 forme du code de 'i' suivi par un code spcial du trma ''. 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 codes x69 x308 en le
code xEF du caractre ''. La normalisation d'une chane de caractres peut tre obtenue avec la fonction XPath
normalize-unicode().
Quelques exemples de fichiers
Fichier au format UTF-8 : example-utf8.xml [Examples/example-utf8.xml]
Fichier au format Latin-1 : example-latin1.xml [Examples/example-latin1.xml]
Fichier au format Latin-15 : example-latin15.xml [Examples/example-latin15.xml]
2.4.3. 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
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.5. 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 rpertoire. L'unit de cette organisation
est l'lment. Chaque lment peut contenir du texte simple, d'autres lments ou encore un mlange des deux.
Comme dans une arborescence de fichiers, il y a un lment appel lment racine qui contient l'ensemble du
document.
2.5.1. 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. XML distinguent deux types d'identificateurs appels jetons (name token en anglais abrg en NMToken) et
noms XML dans cet ouvrage.
Syntaxe de XML
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 soulign '_', le tiret '-', le point
'.' et les deux points ':'.
Un jeton est une suite quelconque de ces caractres qui ne commence pas par les trois lettres xml en minuscule ou
majuscule, c'est--dire par une chane de [xX][mM][lL]. Les identificateurs commenant par ces trois lettres
sont rservs aux usages internes de XML. Un nom XML est un jeton qui, en outre, commence par une lettre
[a-zA-Z], le caractre '_' ou le caractre ':'. Les deux caractres '-' et '.' ne peuvent pas apparatre au
dbut des noms. 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. Il
n'y a en revanche aucune restriction pour les autres utilisations des noms.
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.5.2. lments
Contenu de l'lm ent n a me
Figure 2.1. 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> o name est le nom de l'lment et la balise fermante prend la forme </name>.
Les noms des lments XML peuvent tre des noms quelconques. Ils ne sont pas limits un ensemble fix de
noms prdfinis comme en HTML. Des attributs [Section 2.5.4] peuvent ventuellement tre ajouts dans la balise
ouvrante. Le contenu d'un lment est form de tout ce qui se trouve entre la balise ouvrante et la balise fermante
(cf. Figure 2.1). Il peut tre constitu de texte, d'autres lments, de commentaires [Section 2.5.7] et d'instructions
de traitement [Section 2.5.8].
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
Contenu vide
Figure 2.2. 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/>. Cette contraction est
privilgier lorsque l'lment est dclar vide par une DTD [Section 3.3.2.4].
<t a g 1 >
</ t a g 1 >
<t a g 2 >
</ t a g 2 >
<t a g 1 > <t a g 2 >
</ t a g 2 > </ t a g 1 >
<t a g 1 > <t a g 2 >
</ t a g 1 > </ t a g 2 >
Figure 2.3. 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
Syntaxe de XML
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 2.3).
<parent>
<sibling1>
<sibling2>
<self>
<child1>
<child2>
<child3>
</self>
<sibling3>
</parent>
... </sibling1>
... </sibling2>
... <desc1></desc1> ... <desc2></desc2> ... </child1>
... </child2>
... <desc3><desc4> ... </desc4></desc3> ... </child3>
... </sibling3>
pa r e nt
s i bl i ng1
s i bl i ng2
s el f
c hi l d1
c hi l d2
de s c 1
de s c 2
s i bl i ng3
c hi l d3
de s c 3
de s c 4
Figure 2.4. Liens de parent

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 2.4).
2.5.3. 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.3.1.1].
Il est souvent fastidieux d'inclure beaucoup de caractres spciaux l'aide des entits. Les sections littrales,
appeles aussi sections CDATA en raison de la syntaxe permettent d'inclure du texte qui est qui recopi verbatim.
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.
Syntaxe de XML
2.5.4. 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 ou plusieurs associations
de valeurs des attributs comme dans les exemples ci-dessous.
<tag attribute="value"> ... </tag>
<tag attribute1="value1" attribute2="value2"> ... </tag>
Voici ci-dessous d'autres exemples de balises ouvrantes avec des attributs.
<body background='yellow'>
<xsd:element name="bibliography" type="Bibliography">
<a href="#{$node/@idref}">
Lorsque le contenu de l'lment est vide et que la balise ouvrante et la balise fermante sont contractes en une
seule balise, 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"/>
<xsl:value-of select="key('idchapter', @idref)/title"/>
Le nom de chaque attribut doit tre un nom XML [Section 2.5.1]. La valeur d'un attribut peut tre une chane
quelconque de caractres dlimite par une paire d'apostrophes ''' ou une paire de guillemets '"'. Elle ne
peut pas contenir les caractres spciaux '<', '>' et '&'. Ces caractres peuvent toutefois tre introduits par
les entits prdfinies [Section 3.3.1.1]. Si la valeur de l'attribut est dlimite par des apostrophes ''', elle peut
contenir des guillemets '"' et inversement.
Comme des espaces peuvent tre prsents dans la balise aprs le nom de l'lment et entre les attributs, l'indentation
est libre pour crire les attributs d'une balise ouvrante. Aucun espace ne peut cependant sparer le caractre '='
du nom de l'attribut et de sa valeur. Il est ainsi possible d'crire l'exemple gnrique suivant.
<tag attribute1="value1"
attribute2="value2"
...
attributeN="valueN">
...
</tag>
L'ordre des attributs n'a pas d'importance. Les attributs d'un lment doivent avoir des noms distincts. Il est donc
impossible d'avoir deux occurrences du mme attribut dans une mme balise ouvrante.
Le bon usage des attributs est pour les meta-donnes plutt que les donnes elles-mmes. Ces dernires doivent
tre places de prfrence dans le contenu des lments. Dans l'exemple suivant, la date proprement dite est place
dans le contenu alors que l'attribut format prcise son format. La norme ISO 8601 [ ] spcifie la reprsentation
numrique de la date et de l'heure.
<date format="ISO-8601">2009-01-08</date>
C'est une question de style de mettre les donnes dans les attributs ou dans les contenus des lments. Le nom
complet d'un individu peut, par exemple, tre rparti entre des lments firstname et surname regroups dans
un lment personname comme dans l'exemple ci-dessous.
<personname id="I666">
<firstname>Gaston</firstname>
<surname>Lagaffe</surname>
</personname>
Les lments firstname et surname peuvent tre remplacs par des attributs de l'lment personname
comme dans l'exemple ci-dessous. Les deux solutions sont possibles mais la premire est prfrable.
10
Syntaxe de XML
<personname id="I666" firstname="Gaston" surname="Lagaffe"/>
2.5.5. 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. 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.
2.5.5.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 '-'. Cet attribut est hrit par les lments contenus. Ceci signifie qu'une application traitant le document
doit prendre en compte, pour chaque lment, l'attribut xml:lang prsent dans l'anctre le plus proche.
<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.5.5.2. Attribut xml:space

L'attribut xml:space permet d'indiquer une application le traitement des espaces. Les deux valeurs possibles
de cet attribut sont default et preserve.
Le traitement XML des caractres d'espacement est la fois simple dans une premire approche et subtile et source
de surprises dans un second temps. Les caractres d'espacement sont l'espace ' ' de code #x20, la tabulation
de code #x9 ('\t' en notation du langage C), le saut de ligne de code #xA ('\n' en C) et le retour chariot
de code #xD ('\r' en C).
Les retours la ligne sont normaliss par l'analyseur lexical (parser en anglais). Ceci signifie que les diffrentes
combinaisons de fin de ligne sont remplaces par un seul caractre #xA. Cette transformation garantit une
indpendance vis vis des diffrents systmes d'exploitation.
Les caractres d'espacement sont ensuite transmis tels quels l'application. La plupart d'entre elles considrent
de faon quivalente les diffrents caractres d'espacement. Ceci signifie qu'un retour la ligne est vu 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 respecter les caractres d'espacement. Les retours la ligne sont prservs et les espaces
conscutifs ne sont pas confondus.
2.5.5.3. Attribut xml:base

chaque lment d'un document XML est associe une URL appele URL de base. Celle-ci est utilise pour
rsoudre les URL des entits externes, qui peuvent tre, par exemple des fichiers XML ou des fichiers multimdia
(images, sons, vido). 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 xml:base permet de prciser l'URL de base de l'lment. Cette URL peut tre une URL complte ou
une adresse relative. Dans ce dernier cas, l'adresse relative est combine avec l'URL de base du parent pour former
une URL complte. Si l'attribut xml:base est absent, l'URL de base de l'lment est celle de son parent.
L'URL de base de l'lment racine est calcule partir de l'URL de base du document. Celle-ci est gnralement
fournie par l'application qui traite le document. Lorsque le document a t tlcharge par un navigateur,
11
Syntaxe de XML
son URL de base est son adresse Internet, par exemple http://www.liafa.jussieu.fr/~carton/
index.html. Lorsque le document est trait localement, son URL de base est son chemin d'accs dans
l'arborescence des fichiers, par exemple file:/home/carton/Enseignement/XML/index.html.
Pour comprendre comment une URL relative se combine avec une URL complte, il faut d'abord comprendre la
structure d'une URL. La description donne ci-dessous se limite aux aspects indispensables pour apprhender la
composition des adresses. 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 '/'.
Rpertoire
Protocole
Adresse Internet
Chem in d'accs
Rpertoire
Protocole
Fichier
Fichier
Chem in d'accs
Figure 2.5. Structure d'une URL

La composition d'une URL avec une adresse pour former une nouvelle URL est ralise de la faon suivante.
1. Si l'adresse est elle-mme une URL complte qui commence par un protocole, le rsultat de la composition
est l'adresse.
2. Si l'adresse est un chemin absolu commenant par le caractre '/', le rsultat est obtenu en remplaant la
partie chemin de l'URL par l'adresse. L'adresse est donc ajoute aprs la partie adresse Internet de l'URL.
3. Si l'adresse est un chemin relatif ne commenant pas par le caractre '/', le rsultat est obtenu en remplaant
le nom du fichier par l'adresse. Le chemin relatif est donc concatn avec le nom du rpertoire.
Le document suivant illustre les diffrents cas pour la combinaison d'une URL avec une adresse. Pour chacun des
lments, l'URL de base est donne.
<?xml version="1.0" encoding="iso-8859-1" standalone="yes" ?>
<book xml:base="http://www.somewhere.org/Enseignement/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>
12
Syntaxe de XML
</book>
http://www.somewhere.org/Enseignement/index.html
http://www.somewhere.org/Enseignement/XML/chapter.html
http://www.somewhere.org/Enseignement/XML/XPath/section.html
http://www.somewhere.org/Course/section.html
http://www.elsewhere.org/section.html
2.5.5.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 de type ID.
2.5.6. lment racine

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 si celle-ci est prsente. L'lment
bibliography est l'lment racine de l'exemple donn au dbut du chapitre.
]
Balise ouvrante
Corps
...
lments, commentaires et
du
...
instructions de traitement
Balise fermante
...
<root-element>
</root-element>
...
document
2.5.7. 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. Ils peuvent aussi se situer dans le contenu de
n'importe quel lment et aprs l'lment racine. 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.
13
Syntaxe de XML

2.5.8. 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.5.1] 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. 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 XSL [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.4.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.6. Exemples minimaux

Voici quelques exemples minimalistes de documents XML.
2.6.1. Exemple minimal

L'exemple suivant contient uniquement un prologue avec la dclaration XML et un lment de contenu vide. Les
balises ouvrante <tag> et fermante </tag> ont t contractes en une seule balise <tag/>. Ce document n'a
pas de dclaration de DTD.
<?xml version="1.0" ?>
<tag/>
L'exemple aurait pu tre encore rduit en supprimant la dclaration XML mais celle-ci est fortement conseille.
2.6.2. Exemple simple avec une DTD

Cet exemple contient une dclaration de DTD qui permet de valider le document. Cette DTD dfinit l'lment
simple et dclare que son contenu doit tre textuel.
<?xml version="1.0" encoding="ISO-8859-1" standalone="yes" ?>
<!DOCTYPE simple [
]>
<simple>Un exemple simplissime</simple>
14
Syntaxe de XML
2.7. Utilisation de 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 mthodes se diffrencient pas leurs
faons de raliser l'inclusion.
La mthode la plus ancienne t hrite de SGML et elle est base sur les entits externes [Section 3.3.1.3].
La mthode plus rcente base sur XInclude [ ] est utiliser de prfrences aux entits externes. XInclude dfinit
un lment 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 dfinies dans la DTD.
L'opration consistant remplacer un lment xi:include par le contenu du fichier doit mettre jour l'attribut
xml:base de l'lment racine du document dans le fichier. Cet attribut contient une URL qui 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"
xmlns="http://docbook.org/ns/docbook"
xmlns:xi="http://www.w3.org/2001/XInclude">
...

<chapter xml:id="chap.introduction" xml:base="introduction.xml">
...
</chapter>
<chapter xml:id="chap.syntax" xml:base="Syntax/chapter.xml">
15
Syntaxe de XML
...
</chapter>
...
</book>
16
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 permettent de dcrire de faon plus prcise encore la structure d'un document. Ils sont plus sophistiqus
mais plus difficiles manipuler.
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 a t hrites 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.
<!DOCTYPE root-element ... >
17
DTD
Le nom de l'lment racine est suivi du contenu de la DTD dans le cas d'une DTD interne ou de l'URL du fichier
contenant la DTD dans le cas d'une DTD externe.
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 puisse 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 URL

La rfrence une URL est introduite par le mot cl SYSTEM suivi de l'URL dlimit 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.2.2. Adresse par FPI

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" >
18
DTD
3.2.3. DTD mixte

Il est possible d'avoir une DTD externe adresse par URL ou FPI et des dclarations internes. Les dclarations
internes peuvent alors redfinir des lments ou des attributs dj dfinis dans la DTD externe. 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 est possible de redfinir dans la partie interne un lment ou une entit dj dfinie la partie externe. La dfinition
interne a alors priorit sur la dfinition externe. Ce mcanisme permet d'utiliser une DTD externe tout en adaptant
certaines dfinitions au document.
3.3. Contenu de la DTD

Une DTD est essentiellement constitue de dclarations d'lments et d'attributs. Elle peut aussi contenir des
dclarations d'entits qui sont des macros semblables aux #define du langage C.
3.3.1. Dclaration d'entit

Une entit est un nom donn un fragment de document. Ce fragment peut tre insr dans le document en utilisant
simplement le nom de l'entit. Il s'agit en fait d'un mcanisme d'abrviation. Si l'entit a pour nom entity, le
fragment est insr par &entity; o le nom de l'entit est encadr des caractres '&' et ';'. L'entit peut tre
utilise dans le contenu des lments et dans les valeurs des attributs comme dans l'exemple ci-dessous.
<tag meta="attribute: &entity;">Content: &entity;</tag>
Quelques entits sont prdfinies afin d'insrer les caractres spciaux. D'autres entits peuvent tre dfinies
l'intrieur de la DTD du document.
3.3.1.1. Entits prdfinies

Il existe des entits prdfinies permettant d'inclure les caractres spciaux '<', '>', '&', '"' et ''' dans les
contenus d'lments et dans les valeurs d'attributs. Ces entits sont indispensables car ces caractres spciaux ne
peuvent pas apparatre directement dans le contenu du document. Ces entits sont les suivantes.
Entit
Caractre
<
<
>
>
&
&
"
"
'
'
Tableau 3.1. Entits prdfinies

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 &#code dcimal; ou &#xcode
hexadcimal;. Il est cependant possible de dfinir ces propres entits (cf. ci-dessous).
3.3.1.2. Entit interne

Une entit est dite interne lorsque le fragment est inclus directement dans le document. La dclaration d'une telle
entit prend la forme suivante o l'identifiant entity est le nom l'entit et fragment est la valeur de l'entit.
Cette valeur doit tre un fragment XML bien form. Elle peut contenir des caractres et des lments.
19
DTD
<!ENTITY entity "fragment" >

Si la DTD contient par exemple la dclaration d'entit suivante.
<!ENTITY aka "also known as" >
<!ENTITY euro "&#20AC;" >
il est possible d'inclure le texte also known as en crivant seulement &aka;.
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 jmh "James Marshall Hendrix &aka; 'Jimi Hendrix'" >
<!ENTITY aka "also known as" >
]>
<book>&jmh;</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 sans entits.
3.3.1.3. Entit externe

Une entit peut dsigner une fraction 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 un 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. 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.7]
qui est plus pratique.
3.3.1.4. Entit paramtre

Les entits paramtres sont des entits qui peuvent uniquement tre utilises l'intrieur de la DTD. Elles
permettent d'crire des DTD modulaires en dclarant des groupes d'lments ou d'attributs utiliss plusieurs fois.
La dclaration d'une entit paramtre prend la forme suivante.
<!ENTITY % entity "fragment" >
20
DTD
L'entit entity ainsi dclare peut tre utilise en crivant %entity; o le nom de l'entit est encadr des
caractres '%' et ';'. Une entit paramtre peut uniquement tre utilise dans la partie externe de la DTD.
L'exemple suivant dfinit deux entits paramtre 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; >
<!ATTLIST section %langatt; >
Les entits paramtre 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.
3.3.2. Dclaration d'lment

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.5.1] 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.3.2.1. Contenu pur d'lments

Lorsque le contenu d'un lment est pur, celui-ci ne peut pas contenir de texte mais seulement d'autres lments.
Ces lments fils peuvent, leur tour, contenir d'autres lments et/ou du texte. Leur contenu est spcifi par leur
propre dclaration dans la DTD. La dclaration de l'lment dtermine quels lments il peut contenir directement
et dans quel ordre. Une dclaration d'lment a la forme suivante.
<!ELEMENT element regexp >
Le nom de l'lment est donn par l'identifiant element et l'expression rationnelle regexp dcrit les suites
autorises d'lments 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. La signification des cinq oprateurs est donne par la table suivante. Les oprateurs ',' et
'|' sont binaires alors que les oprateurs '?', '*' et '+' sont unaires et postfixs. Ils se placent juste aprs
leur oprande.
Oprateur
Signification
Mise en squence
Choix
0 ou 1 occurrence
Itration (nombre quelconque d'occurrences)
Itration stricte (nombre non nul d'occurrences)
Tableau 3.2. Oprateurs des DTD

Cette dfinition est illustre 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.
21
DTD
<!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.3.2.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 CDATA.
<!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.3.2.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)* >
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 [
22
DTD
<!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.3.2.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.3.3.2].
Dans un soucis 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.3.2.5. Contenu libre

La dclaration suivante n'impose aucune contrainte sur le contenu de l'lment element. Par contre, 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.
<!ELEMENT element ANY >
3.3.3. Dclaration d'attribut

Pour qu'un document soit valide, tout attribut 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.5.1].
<!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.
3.3.3.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.
23
DTD
Liste (value1 | value2 | ... | valueN) de jetons

La valeur de l'attribut doit tre une des valeurs value1, value2, ou valueN. 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.5.1].
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.5.1]. 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.5.1]
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 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.3.3.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 liens de type IDREF et IDREFS permettent au contraire de rfrencer un ou plusieurs autres
lments. Ils crent ainsi des liens entre l'lment ayant les attributs IDREF ou IDREFS et les lments rfrencs.
La valeur d'un attribut de type ID doit tre un nom XML [Section 2.5.1]. 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 id de type ID des lments HTML sont utiliss par les slecteurs de CSS [Section 10.2.2] avec
l'oprateur '#' pour dsigner un lment unique d'un document.
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 lment pour que le document soit valide. La valeur d'un attribut de type IDREFS doit tre une
suite de noms. 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
24
DTD
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.
<?xml version="1.0" encoding="iso-8859-1" standalone="yes" ?>
<!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
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.
<?xml version="1.0" encoding="iso-8859-1"?>
<bibliography>
<books>
<book key="Michard01" lang="fr">
<title>XML langage et appplications</title>
<author>Alain Michard</author>
<year>2001</year>
<isbn>2-212-09206-7</isbn>
<url>http://www.editions-eyrolles/livres/michard/</url>
<published by="id2680397"/>
</book>
<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">
25
DTD
<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.5.5.4]
qui est toujours de type ID.
3.3.3.3. Valeur par dfaut

Chaque dclaration d'attribut prcise une valeur par dfaut. Celle-ci peut prendre une des quatre formes suivantes.
"value" o value est une chane quelconque de caractres dlimite par ''' ou '"'
Si l'attribut est absent pour un lment du document, sa valeur est implicitement la valeur 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" o value est une chane quelconque de caractres dlimite par ''' ou '"'
La valeur de l'attribut est fixe la chane de caractres value. 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.3.3.4. Exemples
Voici quelques exemples de dclarations d'attributs avec, pour chacune d'elles, des valeurs valides et non valides
pour l'attribut.
<!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.
<tag meta="Hello World!">
attribut gal la chane Hello World!
<tag>
attribut gal la valeur par dfaut default
<tag meta="">
attribut gal la chane vide
<tag meta="=='"==">
attribut gal la chane =='"==
<tag meta='=='"=='>
attribut gal la chane =='"==
<tag meta="==<&>==">
attribut gal la chane ==<&>==
<tag meta="==<&&#62==">
attribut gal la chane ==<&>==
<!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.
<book>
attribut gal la valeur par dfaut fr
<book lang="fr">
attribut gal la valeur par dfaut fr
26
DTD
<book lang="en">
attribut gal au 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.
<book>
attribut absent et sans valeur
<book name="en">
attribut gal au jeton en
<book name="-id234"/>
attribut gal au 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.
<entry>
non valide car l'attribut obligatoire est absent
<entry id="id-234">
attribut gal au 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. Il n'a pas de valeur par dfaut.
<xref ref="id-234"/>
valide s'il existe un lment avec un attribut de type

ID gal 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. Il n'a pas de valeur par dfaut.
<xrefs refs="id-234"/>
valide s'il existe un lment avec un attribut de type

ID gal id-234
<xrefs refs="id-234 id-437"/>
valide s'il existe des lments avec des attributs de

type ID gaux respectivement 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.
<rule>
attribut gal la valeur fixe free
<rule style="free">
attribut gal la valeur fixe free
<rule style="libre">
non valide car la valeur est diffrente de la valeur fixe
3.4. Outils de validations

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/]
27
Chapitre 4. Espaces de noms

Les espaces de noms permettent d'utiliser simultanment des lments de mme nom mais dfinis dans des modles
diffrents.
4.1. Identification d'un espace de noms

Un espace de noms est identifi par une URL appele URL de l'espace de noms. Il est sans importance que l'URL
pointe rellement sur un document. Cette URL garantit seulement que l'espace de noms est 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.7] des URL associes aux principaux espaces de noms est donne la fin du chapitre.
4.2. Dclaration d'un espace de noms

Un espace de noms dclar par un pseudo attribut de forme xmlns:prefix dont la valeur est une URL qui
identifie l'espace de noms. Le prfixe prefix est un nom XML [Section 2.5.1] ne contenant pas le caractre ':'.
Il est ensuite utilis pour qualifier les noms d'lments. Bien que la dclaration d'un espace de noms se prsente
comme un attribut, celle-ci n'est pas considre comme un attribut. Le langage XPath [Chapitre 6] distingue en
effet les attributs des dclarations d'espaces de noms. Ces dernires sont manipules de faon particulire.
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 html l'espace de noms de XHTML identifi par l'URL http://
www.w3.org/1999/xhtml. Ensuite, tous les lments de cet espace de noms sont prfixs par html:.
<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. Il faut par contre 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 pour certains espaces de
noms. Ainsi, on prend souvent html pour XHTML, xsd ou xs pour les schmas XML et xsl pour les feuilles
de style XSL.
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">
<html:head>
</html:head>
<html:body>
...
<mml:math>
<mml:apply>
<mml:eq/>
28
Espaces de noms
...
</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 seul donn pour
illustrer le propos mais il n'est pas suivre. C'est une mauvaise pratique d'associer deux prfixes la 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.3. Porte d'une dclaration

La porte d'une dclaration d'un espace de noms est l'lment dans laquelle 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.4. 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 au 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 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'URL 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>
29
Espaces de noms
</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>
...
<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.
30
Espaces de noms
4.5. Attributs
Les attributs peuvent galement avoir des noms qualifis. Ils font alors partie de l'espace de noms donn par le
prfixe comme dans l'exemple suivant. L'attribut noNamespaceSchemaLocation fait partie de l'espace de
noms des instances de schmas identifi par l'URL http://www.w3.org/2001/XMLSchema-instance.
Le nom de l'attribut noNamespaceSchemaLocation doit donc avoir un prfixe associ cette URL. 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 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="bibliography.xsd">
...
En revanche, les attributs dont le nom n'est pas qualifi 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.6. Espace de noms XML

Le prfixe xml est implicitement li l'espace de noms XML dont l'URL est http://www.w3.org/
XML/1998/namespace. Cet espace de noms n'a pas besoin d'tre dclar. Les quatre attributs particuliers
[Section 2.5.5] xml:lang, xml:space, xml:base et xml:id font partie de cet espace de noms.
Ces quatre attributs sont dclars dans le schma XML http://www.w3.org/2001/xml.xsd qui peut tre
import [Section 5.14] par d'autres schmas.
4.7. Quelques espaces de noms classiques

XML [Section 4.6]
http://www.w3.org/XML/1998/namespace
XInclude [Section 2.7]
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
http://www.w3.org/2001/XMLSchema-instance
31
Espaces de noms
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
Schematron [Chapitre 7]
http://purl.oclc.org/dsdl/schematron
32
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 respecte un schma. Les schmas ont t introduits pour combler les
lacunes des DTD.
5.1.1. Inconvnients des DTD

Syntaxe non XML
Manque de concision dans les descriptions des contenus en particulier dans les elements de contenu mixte.
Modularit trs limite
Pas de gestion des espaces de noms
5.1.2. Apports des schmas XML

Syntaxe XML
Nombreux types de donnes prdfinis (nombres, dates, )
Possibilit de dfinir de nouveaux types
Approche objet pour une hirarchie de types
Modularit accrue
Prise en compte des espaces de noms [Chapitre 4]

Voici un exemple de schma XML dfinissant le type de document de la blibiographie [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 peut tre donn pour la bibliographie. Le cours est essentiellement
bas sur des exemples.
<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"/>
33
Schmas XML
<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
<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.
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'lments 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 des schmas XML est identifi par l'URL 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 globaaux ou locaux. Ils sont globaux lorsque leur dclaration
ou leur dfinition est enfant direct de l'lment xsd:schema. Sinon, ils sont locaux. Ces objets et eux seuls
peuvent tre rfrencs dans tout le schma pour tre utiliser. 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 sont nomms. Dans le
schma ci-dessus, le type de l'lment book est 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.
34
Schmas XML
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 schema peut avoir les attributs suivants.
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
Ces deux attributs donnent la valeur par dfaut des attributs block et final [Section 5.10.3]. 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 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'URL
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 utlis lorsque le
document n'utilise pas d'espace de noms
La valeur de l'attribut schemaLocation est une suite d'URI spares par des espaces. Ces URI vont par paires
et le nombre d'URI doit donc tre pair. La premire URI de chaque paire identifie un espace de noms et la seconde
donne l'adresse du schma utiliser pour les lments et attributs dans cet espace de noms. L'espace de noms
identifi par la premire URI doit donc tre l'espace de noms cible du schma donn par la seconde. 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.
35
Schmas XML
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'URL http://www.liafa.jussieu.fr/
~carton/.
<bibliography xsi:schemaLocation="http://www.liafa.jussieu.fr/~carton/
bibliography.xsd"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
...
5.3.3. Documentation
L'lment xsd:annotation permet d'ajouter des commentaires dans un schma. Il peut tre enfant de l'lment
schma pour des commantaires globaux. Il peut aussi se placer dans les dclarations d'lments et les dfinitions
de types pour des commentaires cibls. Contrairement aux commentaires XML, ces commentaires font partie
part entire du schma XML et consituent sa documentation.
<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

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.
36
Schmas XML
<xsd:element name="element">
<xsd:simpleType>
...
</xsd:simpleType>
</xsd:element>
<xsd:element name="element">
<xsd:complexType>
...
</xsd:complexType>
</xsd:element>
5.4.4. Rfrence un lment global

Dans la dfinition d'un lment ou d'un type, il est possible d'utiliser un lment dfini globalement, c'est--dire
comme fils de l'lment schema. Une telle rfrence s'crit de la faon suivante.

<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"
37
Schmas XML
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
Un document valide pour le schma suivant est le suivant.
<?xml version="1.0" encoding="iso-8859-1" standalone="yes"?>
<lists>
<strings>
<local>Une chane</local>
<local>A string</local>
</strings>
<integers>
<local>-1</local>
<local>1</local>
</integers>
</lists>
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 purement textuels. 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
forms uniquement d'lments ou des contenus mixtes. 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 restriction ou extension de types
dj dfinis. L'extension de type est similaire l'hritage des langages de programmation orient 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"/>
5.5.1. Types prdfinis

La liste des types prdfinis est la suivante.
string
Chane de caractres
boolean
true, false, 1 ou 0
float
Flottant 32 bits conforme la norme IEEE 754 [ ]
double
Flottant 64 bits conforme la norme IEEE 754 [ ]
byte
Entier sign sur 8 bits
38
Schmas XML
unsignedByte
Entier non sign sur 8 bits
integer
Entier arbitraire. Ce type n'est pas primitif. Il drive du type decimal.
positiveInteger
Entier strictement positif
negativeInteger
Entier strictement ngatif
nonPositiveInteger
Entier ngatif ou nul
nonNegativeInteger
Entier positif ou nul
int
unsignedInt
long
Entier sign sur 64 bits. Ce type drive du type integer.
unsignedLong
short
unsignedShort
decimal
Nombre dcimal
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.
date
Date au format YYYY-MM-DD, par exemple 2008-01-16. Tous les champs sont obligatoires.
dateTime
Date et heure au format YYYY-MM-DDThh:mm:ss, par exemple 2008-01-16T14:07:23. Tous les
champs sont obligatoires.
duration
Dure au format PnYnMnDTnHnMnS
Les schmas XML reprennent les types des DTD afin de faciliter la traduction des DTD en schemas.
xsd:ID
nom XML identifiant un lment
39
Schmas XML
xsd:IDREF
rfrence un lment par son identifiant
xsd:IDREFS
liste de rfrences des lments par leurs identifiants
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 utilis 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 ou restriction.
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 rstriction d'un autre type, l'lment xsd:complexType doit un contenir
un lment xsd:simpleContent ou 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>
40
Schmas XML


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

L'attribut mixed de l'lment xsd:complexType permet de construire un type avec du contenu mixe.
<xsd:element name="book">
<xsd:complexType mixed="true">
<xsd:choice 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.3.2.1].
5.6.1. lment vide

Si un type complexe dclare uniquement des attributs, le contenu de l'lment est 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>
Un fragement de document valide peut tre le suivant.
<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. 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>
type="xsd:string"/>
type="xsd:string"/>
type="xsd:string"/>
type="xsd:string"/>
41
Schmas XML
</xsd:complexType>
</xsd:element>
Cette dclaration est quivalente la dclaration suivante dans une DTD.
<!ELEMENT book (title, author, year, publisher)>
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. 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)>
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:element name="publisher"
</xsd:all>
</xsd:complexType>
</xsd:element>
type="xsd:string"/>
type="xsd:string"/>
type="xsd:string"/>
type="xsd:string"/>
Les attributs minOccurs et maxOccurs (voir ci-dessous) 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.
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.
Voici titre d'exemple, le type de l'attribut maxOccurs tel qu'il pourrait tre dfini dans un schma pour les
schmas.
<xsd:attribute name="maxOccurs" type="IntegerOrUnbounded"/>
42
Schmas XML
<xsd:simpleType name="IntegerOrUnbounded">
<xsd:union memberTypes="Unbounded xsd:nonNegativeInteger"/>
</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>
<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 donn
par l'attribut itemType. Les valeurs sont spares par des espaces. 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 minOccurs 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>
43
Schmas XML
</xsd:complexType>
</xsd:element>
<!ELEMENT elem (elem1, (elem2 | elem3), elem4) >
<xsd:complexType>
<xsd:sequence>
<xsd:choice>
<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 lment externe au schma. Pour que document
reste valide, il faut que l'lment ajout soit dclar dans un autre schma.
44
Schmas XML
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 dans 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>
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>
45
Schmas XML
Un attribut peut aussi tre global lorsque sa dclaration est enfant direct de l'lment xsd:schema. Cet attribut
peut alors tre ajout diffrents types complexes. La dfinition du type utilise l'lment xsd:attribute avec
un attribut ref qui remplace les deux attributs name et type. Cet attribut ref contient le nom de l'attribut global
ajouter. La dclaration globale d'un attribut est justifie lorsque celui-ci a des occurrences multiple. Elle accrot
la modularit 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>
</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.3.3]. 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"/>
46
Schmas XML
<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>
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.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 objets 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.

L'extension d'un 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
47
Schmas XML
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"/>
Un fragment de document valide peut tre le suivant.
<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>
Un fragment de document valide peut tre le suivant.
<price currency="euro" country="France">3.14</price>
48
Schmas XML
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 semblabe 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:element name="firstname" type="xsd:string"/>
<xsd:element name="lastname" type="xsd:string"/>
</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 les le contenu du type Name qui est constitu des deux lments firstname
et lastname. Le document suivant est valide pour le schma prcdent.
<?xml version="1.0" encoding="iso-8859-1" standalone="no"?>
<names>
<fullname id="id40">
<firstname>Alexander III Alexandrovich</firstname>
<lastname>Romanov</lastname>
<title>Tsar of Russia</title>
</fullname>
<fullname id="id52">
<firstname>Elizabeth II Alexandra Mary</firstname>
<lastname>Windsor</lastname>
<title>Queen of England</title>
</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
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
49
Schmas XML
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 bases [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 simple
est effectues par l'intermdiaires de facettes qui imposent des contraintes aux contenus. Toutes les facettes ne
s'appliquent pas tous les types simples.
5.9.1.1. Restriction par intervalle

Il est possible de dfinit un nouveau type en donnant une valeur minimal et/ou une valeur minimale. Cette
contrainte ne s'applique qu'aux types numriques pour lesquels elle a 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>
5.9.1.2. Restriction par numration

Il est possible de dfinir un nouveau type en donnant explicitement une liste des valeurs possibles d'un type
prdfini ou dj dfini. 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:enumeration value="de"/>
<xsd:enumeration value="en"/>
<xsd:enumeration value="fr"/>
</xsd:restriction>
</xsd:simpleType>
5.9.1.3. Restriction par motif

Il est possible de dfinir un nouveau type en donnant un motif, c'est--dire une expression rationnelle qui dcrit
les valeurs possibles d'un type prdfini ou dj dfini. Dans l'exemple suivant, le type ISBN dcrit explicitement
tous les formes possibles des numros ISBN.
<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 identificateurs qui commencent par une lettre minuscule ou
majuscule ou le caractre '_' puis se prolongent par une suite de caractres alphanumriques ou le caractre '_'.
50
Schmas XML
<xsd:simpleType name="Identifier">
<xsd:pattern value="[A-Za-z_][0-9A-Za-z_]*"/>
</xsd:restriction>
</xsd:simpleType>
La syntaxe des expressions rationnelles qui peuvent tre employes avec la restriction pattern sont les suivantes.
.
Tous les caractres sauf les retours la ligne ([\n\r])
\s
Espaces (espace, tabulation ou retour de ligne [#x20\t\n\r])
\S
Caractres autres que les espaces
\d
Chiffre
\D
Caractres autres que les chiffres
\w
Caractres alphanumriques et le tiret '-'
\W
Caractres autres que les caractres alphanumriques et le tiret
\i
Caractres commenant un identificateur (lettres, '_' ou ':')
\I
Caractres ne commenant pas un identificateur
{n}
Rptition n fois
{m,n}
Rptition entre m et n fois
[x-y]
Les caractres entre x et y
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.
5.9.1.4. Liste des facettes

enumeration
length
maxLength
minLength
maxExclusive
51
Schmas XML
maxInclusive
minExclusive
minInclusive
pattern
fractionDigits
totalDigits
whiteSpace
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 restriction contient un lment 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.
<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 rcrit dans le nouveaux. 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
52
Schmas XML
attribut 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>
</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 de l'attribut decimal est chang
en le type xsd:integer.
53
Schmas XML
<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 les contenus du type restreint doivent tre valide 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.
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"
</xsd:sequence>
</xsd:complexType>

54
Schmas XML
<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>
Le document suivant est valide pour le schma prcdent.
<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.
<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 possible dans un lment
xsd:choice. Dans l'exemple suivant, le choix integer a t supprim dans le type Float.
55
Schmas XML

<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.1] 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>
</number>
</numbers>
5.10. Substitutions
Les schmas XML prvoient plusieurs mcanisme de substitution au niveau des types et des lments. Dans la
substitution de type, un document peut changer explicitement la type associ un lment afin d'y placer un
contenu diffrent de celui prvu par le schma. La substitution d'lment va encore plus. 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 diffrents faons d'obtenir des type drivs par restriction ou extension.
Une seconde condition pour rendre possible les substitutions est que celles-ci doivent tre autorises par le schma.
Les schma possdent diffrent outils pour contrler les substitutions [Section 5.10.3].
5.10.1. Substitution de type

Un type peut remplacer dans une instance de document un 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
56
Schmas XML
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 nom des instances de schmas.
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">
<firstname>Elizabeth II Alexandra Mary</firstname>
<title>Queen of England</title>
</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.
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">
57
Schmas XML
</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.2. 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. 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"/>
</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 qui sont substitus des lments integer.
58
Schmas XML

<integers>
<positive>1</positive>
<negative>-1</negative>
</integers>
Un lment donn est ncessairement le chef d'un unique groupe puisque chaque groupe est identifi par son chef.
De mme, un mme lment ne peut appartenir qu' au plus un groupe puisque l'attribut substitutionGroup
de xsd:element ne peut contenir qu'un seul nom d'lment. La version 1.1 des schmas autorise l'attribut
substitutionGroup contenir plusieurs noms d'lments. Un lment peut ainsi appartenir plusieurs
groupes de substitution.
Les substitutions peuvent tre utilises en cascade. Un lment membre d'un groupe de substitution peut lui-mme
tre chef d'un autre groupe de substitution. Les membres de ce dernier groupe peuvent bien sr remplacer leur
chef de groupe mais aussi son chef de groupe. Dans le schma suivant, l'lment head est le chef d'un groupe
comprenant l'lment subs. Cet lment subs est, son tour, chef d'un groupe de substitution comprenant
l'lment subsubs. Cet lment subsubs peut dont remplacer l'lment subs mais aussi l'lment head.

<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>
</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"/>
<xsd:element name="subs" type="xsd:string" substitutionGroup="head"/>
5.10.3. 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.
59
Schmas XML
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
5.10.3.1. Facette fixe

Les types symples sont obtenus par restrictions successives des types prdfinis 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 ultrieure.
L'attribut fixed peut tre utilis dans toutes les facettes xsd:minLength, maxLength, 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
lomgueur 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>
60
Schmas XML
</strings>
5.10.3.2. Types abstraits

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 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 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 ou une substitution d'lment par
l'intermdiaire d'un groupe de substitution.
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">

61
Schmas XML
<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 gal lment un string suivi
d'un lment integer.
<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">
62
Schmas XML
<string>Un entier</string>
<integer>-1</integer>
</tns:value>
</tns:values>
5.10.3.3. lments abstraits

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 subsitution est uniquement possible lorsque lorsque l'lment abstrait est le chef d'un
groupe de substitution. 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 en rendant un type abstrait.
Il n'est en effet plus possible de remplacer le type. Il faut ncessairement remplacer l'lment.
Dans le schma suivant, l'lment value est dclar abstrait. Il est le chef d'un groupe qui comprend uniquement
l'lment other qui peut donc le remplacer.

<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.3.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.
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
63
Schmas XML
l'attribut xsi:type. Il n'est pas possible non plus de substituer l'lment par un autre lment 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"/>
...

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

64
Schmas XML
<value xsi:type="Extension" att="Un attribut">

</value>

<value xsi:type="Restriction">
</value>
</values>
L'attribut block bloque la substitution par un type dont une des tapes de drivation et pas seulement la
premire tape est mentionne dans ses valeur. Si, par exemple, l'attribut block d'une dfinition de type contient
extension, seuls les types obtenus par restrictions successives de ce type peuvent le remplacer.
Dans le schma suivant, le type List bloque sa substitution par un type obtenu par extension. Le type
ShortList est obtenu par restriction du type List et le type AttrShortList est obtenu par extension du
type ShortList. Le type ShortList peut se substituer au type List. Au contraire, le type AttrShortList
ne peut pas se substituer au type List car il y a une drivation par extension entre le type List et le type
AttrShortList.

<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>
65
Schmas XML
<item>Troisime item</item>
</list>
5.10.3.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.
Dans le schma suivant, l'lment integer bloque toutes les substitutions de types dans les documents avec
block="restriction extension". Ce blocage empche de changer le type en un type driv avec
l'attribut xsi:type. Il empche galement l'lment positive de se substituer l'lment integer car son
type est obtenu par restriction du type xsd:integer. En rechanche, l'lment sametype dont le type est aussi
xsd:integer peut rempalcer l'lment integer.
<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
se substituer dans les documents instance. Cela anihile l'intret d'avoir des lments dans le groupe de substitution
puisque ceux-ci ne peuvent pas rellement se substituer leur chef de groupe.
Dans le schma suivant, les lments sametype et positive appartiennent au groupe de substitution l'lment
integer. En rechanche, ils ne peuvent pas se substituer cet lment en raison de la valeur substitution
de l'attribut block.
<xsd:element name="integer" type="xsd:integer" block="substitution"/>

66
Schmas XML
<xsd:element name="sametype" type="xsd:integer"


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

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

<sametype>1</sametype>

</integers>
5.10.3.6. Type final

Il est possible, dans un schma, de restreidre 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.
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 correcte.
...

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

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


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

<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 type drivs alors que
block concerne l'utilisation des types drivs dans les documents instance.
68
Schmas XML
5.10.3.7. lment final

Il est possible, dans un schma, de limiter les lments susceptibles de substituer un lment donn. Il est en effet
possible d'empcher slectivement les lments d'appartenir un groupe de substitution en 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
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 se substituter
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
de 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.2] qui
permettent de remplacer un lment par un autre.
69
Schmas XML
5.11.1. Groupe d'lments

L'oprateur xsd:group permet de nommer un groupe d'lments. Dans l'exemple suivant, le groupe fullname
est constitu d'un lment first et d'un lment last dans cet ordre.
<xsd:group name="Fullname">
<xsd:sequence>
<xsd:element name="first" type="xsd:string"/>
<xsd:element name="last" type="xsd:string"/>
</xsd:sequence>
</xsd:group>
Une telle dclaration peut tre employe de la faon suivante dans la dclaration d'lments ou de type.
<xsd:complexType name="Person">
<xsd:sequence>
<xsd:group
ref="Fullname"/>
<xsd:element name="country" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
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 la dfinition de diffrents types.
5.11.2. Groupe d'attributs

De faon similaire, l'oprateur attributeGroup permet de regrouper les dclarations de plusieurs attributs
dans le but d'une rutilisation. Dans l'exemple suivant, le groupe d'attributs LangType regroupe deux attributs
lang et type.
<xsd:attributeGroup name="LangType">
<xsd:attribute name="lang" type="xsd:string"/>
<xsd:attribute name="type" type="xsd:string"/>
</xsd:attributeGroup>
Une telle dclaration peut tre employe de la faon suivante dans la dfinition d'un type complexe nomm ou
anonyme. On utilise l'attribut ref de xsd:attribute pour rfrencer le groupe utilis. 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 objet.
<xsd:attributeGroup name="LangTypeClass">
70
Schmas XML
<xsd:attributeGroup ref="LangType"/>
<xsd:attribute name="class" type="xsd:string"/>
</xsd:attributeGroup>
Le schma xml.xsd de l'espace de noms xml dfinit les quatre attributs 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. 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. Ces contraintes doivent tre vrifies
par un document pour que celui-ci soit valide. Ces contraintes sont de deux types. Elles peuvent porter sur l'unicit
ou sur l'existence de certains lments.
5.12.1. Unicit
L'unicit signifie que le contenu ou des valeurs des attributs de certains lments doivent tre unique dans une
partie dtermine du document. Cette notion gnralise les attributs de typeg ID des DTD [Section 3.3.3.2]. Ces
contraintes sont introduites par les lments xsd:key et xsd: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>
Une contrainte dcrite avec xsd:key implique que les champs impliqus soient ncessairement prsents et non
annulables. Une contrainte dcrite avec xsd:unique est au contraire seulement vrifie pour les lments dont
les champs impliqus sont prsents.
5.12.2. Rfrence
L'existence signifie qu'il doit exister dans une partie dtermine du document un lment ayant une certaine valeur
pour son contenu ou des attributs. Cette notion gnralise les attributs de type IDREF des DTDs. Ces contraintes
sont introduites par l'lment xsd:keyref.
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>
71
Schmas XML
<order date="2008-01-09" time="17:32:29">

</order>
</orders>
<catalog>
<product serial="101-XX">Product n 1</product>
<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 DTDs est la prise en charge des espaces de noms. L'attribut
targetNamespace de l'lment schema permet de prciser l'espace de noms des lments et des types dfinis
par le schma.
72
Schmas XML
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
document ne soit pas qualifis (sans le caractre ':') et que l'espace de noms par dfaut [Section 4.4] ne soit
pas spcifi.
Si l'attribut targetNamespace de l'lment 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 schema doit contenir l'URI associ cet espace de noms. Les lments qui sont effectivement dfinis
dans l'espace de noms dpend de la valeur de l'attribut elementFormDefault de l'lment xsd:schema.
Si la valeur de l'attribut elementFormDefault est unqualified qui est sa valeur par dfaut, seuls les
lments dfinis globalement, c'est--dire quand l'lment element est directement fils de l'lment schema
sont dans l'espace de noms cible. Les autres sont sans espace de noms. Dans le schma suivant, l'lment name est
dans l'espace de noms http://www.liafa.jussieu.fr/~carton/ alors que les lments 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>
Un document valide pour ce schma est le suivant.
<tns:name xmlns:tns="http://www.liafa.jussieu.fr/~carton/">
<firstname>Gaston</firstname>
<lastname>Lagaffe</lastname>
</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>
73
Schmas XML
<xsd:element name="lastname"
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
type="xsd:string"/>

<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 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>
<lastname>Lagaffe</lastname>
</tns:name>
5.13.3. Noms qualifis

Lorsqu'un lment, un attribut, un groupe d'lments, un groupe d'attributs 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.
74
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.
<xsd:complexType name="Tree">
<xsd:sequence maxOccurs="unbounded">

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


<xsd:element name="tree" type="tns:Tree"/>
</xsd:sequence>
</xsd:complexType>
L'utilisation de minOccurs avec la valeur 0 est indispensable pour terminer la rcursivit. Sinon, aucun
document valide ne peut avoir d'lment de type Tree.
Il est souvent assez lourd de qualifier chacun des noms des objets dfinis dans le schma. Une alternative assez
commode consiste rendre l'espace de noms par dfaut gal l'espace de noms cible comme dans l'exemple
suivant. Ceci impose bien sr de ne pas utiliser l'espace de noms par dfaut pour les lments des schmas comme
il pourrait tre tentant de le faire. Dans la pratique, on associe l'espace de noms par dfaut l'espace de noms cible
et on dclare galement un prfixe pour cet espace de noms afin de pouvoir y faire rfrence de faon explicite.
Dans l'exemple suivant, l'espace de noms cible 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>
75
Schmas XML
</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.
Le schma l'adresse http://www.w3.org/2001/xml.xsd contient une dfinition des quatre attributs
particuliers [Section 2.5.5] xml:lang, xml:space, xml:base et xml:id de l'espace de noms xml associ
l'URL http://www.w3.org/XML/1998/namespace. 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 est toujours associ au prfixe xml
et 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
</tns:name>
76
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 schmatrons [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 schmatrons 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 langage
XPath utilise aussi des variables propres particulires qui servent parcourir des listes. Ces variables s'apparentent
aux variables du langage hte car elles ne sont jamais affectes explicitement. Leur porte est en outre toujours
limite un oprateur d'itration comme for.
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 diffrentes sortes qui correspondent aux diffrents constituants du
document. Ces sortes de nuds sont les suivantes.
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.
77
XPath
element node
Chaque lment du document est reprsent un nud de cette sorte. 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 cette sorte 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 cette sorte qui contient le texte du
commentaire.
processing instruction node
Chaque instruction de traitement est reprsente par un nud de cette sorte 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 cette sorte 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 cette sorte reprsentaient en XPath 1.0 les espaces de noms dclars dans un lment. Il sont
obsoltes et et ne doivent plus tre utiliss.
Afin d'illustrer ces sortes 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 la sorte du nud, la deuxime est le nom ventuel du nud et la troisime est la valeur
textuelle du nud.
78
XPath
Do c u me n t
XML . . . f i n .
Co mme n t
PI
x ml - s t y l e
El e me n t
l i st
Ti me . . . 0 0 "
hr e f . . . / xs l
XML . . . f i n .
At t r i b u t e
t y pe
El e me n t
i t em
El e me n t
i t em
Te x t
t e c hni c a l
XML & Co
Du t e x t e
e t . . . f i n.
At t r i b u t e
key
At t r i b u t e
l ang
Te x t
Co mme n t
Te x t
i d0001
fr
XML & Co
Un . . . u t i l e
Du t e x t 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 sortes 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.4.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.
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.
79
XPath
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 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.
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 base-uri(node()? node)
retourne l'URI de base [Section 2.5.5.3] 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 qui convertit une valeur en chane de caractre.
xsd:anyAtomicType* data(node()* list)
retourne les valeurs types des nuds de la liste list.
xsd:node root(node()? node)
retourne la racine de l'arbre qui contient le nud node ou le nud courant si node est absent.
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 donne le mme identifiant. En revanche, des appels dans des
80
XPath
traitements diffrents peuvent conduire des rsultats diffrents. Cette fonction est souvent utilise pour
produire une valeur destine un attribut de type ID ou xsd:ID comme xml:id [Section 2.5.5.4].
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() n)
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 /, qui ordonnent
les nuds de leur rsultat suivant cet ordre.
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 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. Inversement, toute liste de longueur 1 est
assimile l'unique valeur qu'elle contient.
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"
81
XPath
xsd:boolean
Boolen : true() et false()
xsd:decimal
Nombre dcimal : 3.14
xsd:float et xsd:double
Nombre flottant en simple ou 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:dateTime, xsd:date et xsd:date
Date et heure : 2009-03-02T11:44:22
xsd:anyURI
URL : 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 type
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.10] lors de sa dclaration et pour les types de retour et des paramtres des fonctions d'extension
[Section 8.11].
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.
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 chacune des sortes de nuds [Section 6.1.1].
Ces types sont document-node(), element(), attribute(), text(), comment(), processinginstruction() et comment() (avec les parenthses). Les types pour les valeurs atomiques sont les types
prdfinis [Section 5.5.1] des schmas comme xsd:integer.
Il y a finalement un type untypedAtomic qui est le type de la valeur de tout nud aprs atomisation.
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 compil. 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.
82
XPath
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'information.
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.1], c'est l'lment contenant l'attribut xmlns. Pour une dclaration de variable XSLT
[Section 8.10], la porte est l'lment parent de l'lment xsl:variable. La porte d'une dfinition d'une
fonction d'extension [Section 8.11] 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 URL 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 dfinies au niveau du langage hte.
Collations
Toutes collations en porte.
URI de base [Section 2.5.5.3]
URI de base de l'lment.
Une collation est un ensemble de rgles pour les comparaisons de caractres. Ces rgles permettent de prendre
en compte les spcificits rgionales et linguistiques. La paire de lettres 'ss' et la lettre '' sont, par exemple,
considres comme quivalentes en allemand. La collation dfinit en particulier l'ordre des lettres qui dtermine
l'ordre lexicographique. La collation par dfaut est dfinie par les codes Unicode des lettres. La lettre 'Z' est, par
exemple, avant la lettre 'a'.
6.1.5.2. Contexte dynamique

La partie importante du contexte dynamique est appele le focus et elle comprend trois objets 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.
C'est un peu l'quivalent du current working directory d'un shell Unix. L'expression @id retourne, par exemple,
l'attribut id du l'objet courant. 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. 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 parcourant une liste
d'objets. Cette liste peut tre dtermine avant l'valuation ou au cours de l'valuation de l'expression XPath. La
position du contexte donne la position de l'objet courant dans cette liste implicite. Cette position est retourne par
la fonction XPath position(). La taille du contexte est la longueur de cette liste implicite et elle est retourne
par la fonction XPath 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.
83
XPath
Valeurs des variables

Les valeurs de toutes les variables en porte.
Dfinition des fonctions
Toutes les dfinitions des fonctions d'extension.
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 un 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 beaucoup d'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 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. 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. Les relations
entre le nud courant et les nuds retourns sont appeles axes dans la terminologie XML.
L'axe par dfaut est l'axe child qui slectionne les enfants du nud courant.
node()
tous les enfants du nud courant
ancestor::*
tous les anctres stricts du nud courant
6.2.1.1. Axes
Chacun des axes donne une relation qui relie les nuds slectionns par rapport au nud courant. Les axes qu'il
est possible d'utiliser dans les expressions XPath sont les suivants.
self
Le nud lui-mme (galit)
child
Fils direct
84
XPath
parent
Parent
attribute
Attribut du nud
descendant
Descendant strict
descendant-or-self
Descendant ou le nud lui-mme
ancestor
Anctre strict
ancestor-or-self
Anctre ou le nud lui-mme
preceding-sibling
Frre gauche (fils du mme parent)
85
XPath
following-sibling
Frre droit (fils du mme parent)
preceding
gauche
following
droite
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 pour accder aux espaces de noms d'un nud.
Les axes self, parent, child, preceding-sibling et following-sibling permettent de
slectionner le nud lui-mme et les nuds proches comme le montre la figure ci-dessous.
86
XPath
pa r e nt
s el f
pr e c e di ng- s i bl i ng
f o l l o wi n g - s i b l i n g
c hi l d
Figure 6.2. Nuds proches

Les cinq axes self, ancestor, preceding, descendant et following partitionnent l'ensemble de tous
les lments du document en cinq parties comme le montre la figure ci-dessous.
Ro o t
An c e s t o r
Se l f
Pr e c e d i n g
Fo l l o wi n g
De s c e n d a n t
Figure 6.3. Partitionnement des lments selon les cinq axes
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
87
XPath
comment()
tous les commentaires
processing-instruction()
toutes les instructions de traitement
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 text enfants du nud courant alors que
l'expression text() retourne les nuds textuels enfants du nud courant. Il faut galement distinguer
l'expression string qui s'value en une liste de nuds des expressions 'string' et "string" qui s'valuent
en une chane de caractres constante.
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 text qui sont enfants du nud courant
child::text() ou text()
tous les nuds textuels qui sont enfants du nud courant
descendant::comment()
tous les commentaires qui sont descendants du nud courant, c'est--dire contenus dans le nud courant
following::processing-instruction()
tous les instructions de traitement qui suivent le nud courant.
6.2.2. Filtres des expressions de cheminement

Les filtres [Section 6.4.2] permettent de slectionner dans une liste les objets qui satisfont une condition.
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.3.1.1].
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 @i.
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.
88
XPath
chapter[count(child::section) > 1]
lment chapter ayant au moins deux lments section comme enfants.
6.2.3. Oprateur '/'

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 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 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.
89
XPath
descendant::p/following-sibling::em[position()=1]
sibling::em[1]
premier frre em d'un lment p descendant du nud courant.
ou
.//p/following-
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
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 la sorte 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 puiqu'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
90
XPath
Bien que les listes manipules par XPath peuvent contenir des nuds et des valeurs atomiques, ces oprateurs
fonctionnent uniquement avec des listes reprsentant des ensembles de nuds. Ils ne fonctionnent pas avec des
listes contenant des valeurs atomiques. Les listes de nuds retournes par ces oprateurs sont tries dans l'ordre
du document et ne comportent pas de doublon.
6.3. Valeurs atomiques

6.3.1. Expressions boolennes
Le type boolen 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. Elles sont aussi converties implicitement ds qu'une valeur boolenne est requise. C'est le cas,
par exemple, des filtres [Section 6.4.2] et de la structure de contrle if [Section 6.6.1]. Les rgles qui s'appliquent
alors sont les suivantes.
Une liste vide est convertie en false.
Une liste vide 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
xsd:boolean('string')
donne true car la chane de caractres n'est pas vide
91
XPath
6.3.2. Nombres
Les seuls nombres existant en XPath 1.0 taient les nombres flottants. XPath 2.0 manipule les nombres des trois
types xsd:integer, xsd:decimal et xsd:double des schmas XML.
Fonctions sur les nombres

Oprateurs '+', '-' et '*'
Ces oprateurs repectivement calculent 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.
round-half-to-even(12.34,-1), round-half-to-even(12.34,1)
10, 12.3
92
XPath
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 qui sont comparables pour l'ordre <. Le paramtre optionnel col
spcifie la collation utiliser pour comparer des chane de caractres.
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 qui sont comparables pour l'ordre lt. Le paramtre optionnel
col spcifie la collation utiliser pour comparer des chane de caractres.
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 guillemes, 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.3.1.1] 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 dlimiteurs ''' bien que ceux-ci ne
fassent pas partie des chanes.
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.
93
XPath
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 optionnelle identifie
par l'URI col. La valeur de retour est -1, 0 ou 1 suivant que s1 est avant s2 pour l'ordre lexicographique,
gale s2 ou aprs s2. Si col est absente, la collation par dfaut est utilise. Celle-ci est base sur les codes
Unicode.
compare('Hello', 'world')
-1
compare('hello', 'World')
1
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 compatible avec l'expression rationnelle regexp et false
sinon. La chane optionnelle flags prcise comment doit tre effectue l'opration.
matches('Hello world', '\w*')
true
matches('Hello world', '^\w*$')
false
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 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'
94
XPath
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 replace(xsd:string s, xsd:string regexp, xsd:string repl)
retourne la chane de obtenue en remplaant dans la chane s l'occurrence de l'expression rationnelle regexp
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'
replace('Hello world', 'world', 'orbi')
'Hello orbi'
replace('(code,1234)', '$([^,]*),([^$]*)\)', '($2,$1)')
'(1234,code)'
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
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 espaces en dbut et en fin de chane et remplace chaque suite d'espaces conscutifs par un seul
espace. Les tabulations et les retours la ligne sont considrs comme des espaces.
normalize-space(' Hello &x0A; world ')
'Hello world'
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 codes Unicode en une chane de caractres.
95
XPath
codepoints-to-string((65, 8364, 48))

'A0'
xsd:integer* string-to-codepoints(xsd:string s)
convertit une chane de caractres en une liste de codes Unicode.
string-to-codepoints('A€0')
(65, 8364, 48)
xsd:string normalize-unicode(xsd:string s, xsd:string? norm)
retourne la normalisation [Section 2.4.2] de la chane s avec la normalisation spcifie par la chane norm.
Cette dernire peut prendre les valeurs NFC, NFD, NFKC et NFKD si le processeur implmente chacune de ces
normalisations. Si norm est absente, la normalisation C (NFC) par dfaut et toujours implmente est utilise.
string-to-codepoints(normalize-unicode(codepoints-to-string((105,
776))))
(239)
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 suivis des valeurs du rsultat
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,2) est bien la liste (1,2,1,2) avec deux occurrences
des entiers 1 et 2.
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. Cette identification entre une valeur
et une liste ne cre pas d'ambigut car les listes XPath ne peuvent pas tre imbriques. Il n'y a pas de diffrence
entre les deux expressions ((1),(2)) et (1,2).
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.
96
XPath
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 de slectionner dans une liste les objets qui satisfont une condition. 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 de la manire suivante. L'objet courant est fix l'objet o, la position du contexte
est fixe la position de l'objet o dans la liste l et la taille du contexte est fixe la taille de l. Le rsultat de cette
valuation est ensuite converti en une valeur boolenne en utilisant les rgles de conversion [Section 6.3.1]. Le
rsultat final de l'valuation de expr1[expr2] est la liste des objets de l pour lesquels expr2 s'est value
en la valeur true. Les objets slectionns restent bien sr dans l'ordre de la liste l. La liste rsultat est en fait
construite en supprimant de la liste l les objets pour lesquels expr2 s'value en false.
Lors de l'valuation de l'expression suivante, l'objet courant qui est retourn par '.' prend les valeurs successives
1, 2, 3, 4 et 5. Seules les valeurs paires satisfont la condition et sont conserves.
(1 to 5)[. mod 2 = 0]
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
97
XPath
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.
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 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)
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 aussi dlicates
utiliser car leur smantique est source de piges conduisant aisment des programmes errons.
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.
Il existe aussi l'oprateur is et les deux oprateurs << et >> permettant de tester l'galit et l'ordre de nuds
dans le document.
98
XPath
6.5.1. Comparaisons de valeurs atomiques

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.
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 contraintes 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 type numriques xsd:integer, xsd:decimal, xsd:float et xsd:double.
6.5.2. Comparaisons gnrales

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, 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 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
Lorsque les deux valeurs sont de type untypedAtomic, celle-ci sont compares comme des chanes de
caractres. Lorsqu'une seule des deux valeurs est de type untypedAtomic, celle-ci est convertie dans le type
99
XPath
de l'autre valeur avant de les comparer. Quand le type de l'autre valeur est un type numrique, la valeur de type
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 un 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 compar avec chaque valeur de la liste l2 pour
le mme oprateur, comme dcrit la section prcdente. Le rsultat global est gal true ds qu'un 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 un moins une des listes est vide.
() != ()
100
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 gale 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, la 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. 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.
list/@length << list/item[1]
donne true car les attributs sont placs avant les lments enfants.
101
XPath
list/item[1] << list/item[2]

donne true.
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.7.2]
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()}"/>
plutt que le fragment quivalent suivant avec un test ralis au niveau de XSLT.
<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. Test
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. 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 plac avant le caractre ':' si celle-ci en
contient un.
L'oprateur if est parfois remplac par un filtre. L'expression if (@xml:id) then @xml:id else
generate-id() est en effet quivalente l'expression plus concise (@xml:id, generate-id())[1].
6.6.2. Itration
L'oprateur for permet de parcourir des listes pour construire une nouvelle liste. Il ne s'agit pas d'une structure
de contrle pour des itrations quelconques comme le for ou le while des langages C ou Java. Il s'apparente
plus l'oprateur map des langages fonctionnels comme ML qui permet d'appliquer une fonction chacun des
objets d'une liste.
La syntaxe de l'oprateur for est la suivante o var est une variable et expr1 et expr2 sont deux expressions.
La variable var peut uniquement apparatre dans l'expression expr2.
for var in expr1 return expr2
102
XPath
L'valuation d'une telle expression est ralise de la faon suivante. L'expression expr1 est d'abord value pour
donner une liste de valeurs. Pour chacune de ces valeurs, celle-ci est affecte la variable var et l'expression
expr2 est value. Le rsultat global est la liste obtenue en concatnant les listes obtenues pour chacune des
valuations de l'expression expr2.
Le rsultat de l'expression expr2 est une liste qui peut donc contribuer plusieurs valeurs de la liste finale. Si,
au contraire, ce rsultat est la liste vide, il n'y a aucune contribution la liste finale.
La variable var introduite par l'oprateur for est une variable muette. Sa porte est rduite l'expression expr2
aprs le mot cl return. Aucune valeur ne peut lui tre affecte directement.
for $i in 1 to 5 return $i * $i
l'valuation de cette expression donne la liste (1,4,9,16,25) des cinq premiers carrs
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 var1 in expr1, , varN in exprN return expr0
Cette expression est en faite quivalente l'expression suivante crite avec la premire syntaxe.
for var1 in expr1 return for
return for varN in exprN return expr0
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. 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

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. Il est gal false sinon.
103
XPath
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.
6.8. 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 sagissait d'un systme de fichiers. Les nuds du documents XML sont assimils des rpertoires
(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
donne 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 relative au nud node.
104
XPath
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:
1 ATTRIBUTE lang
TEXT
content=fr
book > cd ..
bibliography >
6.9. 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]
105
then
chapter[count(section)
> 1]
XPath
Oprateur
Action
Syntaxe
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
Exemples
1 to 5
$price * $qty
/|*
E1 instance of type $x
instance
xsd:string
106
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 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 puisque il est possible de mettre en relation des lments et des attributs qui sont loigns dans le
document. Schematron reste cependant simple et le le vocabulaire trs 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.
<?xml version="1.0" encoding="utf-8"?>
<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'lments.
</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 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>
107
Schematron
Le rsultat de la vrification du document ci-dessus avec le schematron donn prcdemment est donn la section
suivante.
Le cours est essentiellement bas sur des exemples.
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 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 scinde en plusieurs tapes
afin de prendre en compte les inclusions et les blocs abstraits.
Co m p ila t e u r
c o mp i l e r . x s l
Sc h e m a t ro n
Sc h e m a t ro n c o m p il
s c h e ma . s c h
s c h e ma . x s l
XSLT
Pro c e s s o r
Do c u m e n t
Ra p p o rt
d o c u me n t . x ml
r e p o r t . x ml
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
108
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 donns 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(item)"
location="/lists/list[2]">
<svrl:text>L'attribut length doit tre
gal au nombre d'lments.</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'URL 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.13].
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.
<schema xmlns="http://purl.oclc.org/dsdl/schematron"
queryBinding="xslt"
<title>Comparaison attribut/nombre d'enfants</title>

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

<rule context="tns:list">
<assert test="@length = count(*)">
L'attribut length doit tre gal au nombre d'lments.
</assert>
</rule>
109
Schematron
</pattern>
</schema>
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.
<schema xmlns="http://purl.oclc.org/dsdl/schematron">
...
<pattern>
...
</pattern>
<pattern>
...
</pattern>
...
</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 lments la rgle s'applique. Chaque rgle contient ensuite
des tests introduits par les lments sch:assert et sch:report.
<pattern>
<rule context="...">
...
</rule>
...
</rule>
...
</pattern>
La validation d'un document avec un schematron consiste traiter squentiellement chacun des blocs de rgles.
Pour chaque bloc et pour chaque lment 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 lment, une seule des rgles du bloc est rellement applique. Il faut
donc viter cette situation o plusieurs rgles d'un mme bloc s'appliquent potentiellement un mme lment.
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 longues. Le 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. 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.
110
Schematron
<assert test="...">
...
</assert>
<report test="...">
...
</report>
...
</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. 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.
<rule context="book">
<assert test="@id|@key">
L'lment book doit avoir un attribut id ou key
</assert>
</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. 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.
<report test="count(@id|@key) > 1">
L'lment book doit avoir un seul des attributs id ou key
</report>
</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.
<rule context="tns:pattern[@is-a]">
<assert test="key('patid', @is-a)">
L'attribut is-a doit rfrencer un bloc abstrait.
</assert>
<report test="@abstract = 'true'">
Un bloc avec un attribut is-a ne peut pas tre abstrait.
</report>
<report test="rule">
Un bloc avec un attribut is-a ne peut pas contenir de rgle.
</report>
</rule>
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
sont 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.
111
Schematron
Une rgle est dclare abstraite avec un attribut abstract ayant la valeur true. Elle n'a pas d'attribut context.
Elle possde, en revanche, un attribut id qui permet de la dsigner pour l'utiliser.
Un 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.
queryBinding="xslt"
<title>Utilisation de rgles abstraites</title>
<pattern>

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

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

<rule context="chapter">
<extends rule="title"/>
<assert test="para">
Le chapire soit contenir au moins un paragraphe.
</assert>
</rule>
</pattern>
</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>
112
Schematron
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 de 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. 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.10.2] de XSLT. En revanche, l'lment sch:param des
schematrons est l'analogue de l'lment xsl:with-param de XSTL. L'lment xsl:param de XSTL 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 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 second vrifier 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.
queryBinding="xslt"
<title>Utilisation de blocs abtraits</title>

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

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

<pattern is-a="uniq" id="uniq-id">
<param name="elem" value="book"/>
<param name="desc" value="@id|@key"/>
</pattern>
<pattern is-a="uniq" id="uniq-title">
<param name="elem" value="book"/>
<param name="desc" value="title"/>
</pattern>
</schema>
113
Schematron
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.
queryBinding="xslt"
<title>Substitution des blocs abstraits</title>
<pattern id="uniq-id">
L'lment <name/> doit avoir un descendant @id|@key
</assert>
<report test="count(@id|@key) > 1">
L'lment <name/> doit avoir un seul descendant @id|@key
</report>
</rule>
</pattern>
<pattern id="uniq-title">
<assert test="title">
L'lment <name/> doit avoir un descendant title
</assert>
<report test="count(title) > 1">
L'lment <name/> doit avoir un seul descendant title
</report>
</rule>
</pattern>
</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:xsl="http://www.w3.org/1999/XSL/Transform"
queryBinding="xslt"
<title>Vrification des liens is-a des schematrons</title>
<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 true.</p>


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

<xsl:key name="patid" match="tns:pattern" use="@id"/>
<pattern>
<rule context="tns:pattern[@is-a]">
<assert test="key('patid', @is-a)">
L'attribut is-a doit rfrencer un bloc abstrait.
</assert>
114
Schematron
<report test="@abstract = 'true'">

Un bloc avec un attribut is-a ne peut pas tre abstrait.
</report>
<report test="rule">
Un bloc avec un attribut is-a ne peut pas contenir de rgle.
</report>
</rule>
</pattern>
<pattern>
<rule context="tns:pattern[@abstract = 'true']">
<assert test="@id">
Un bloc abstrait doit avoir un attribut id.
</assert>
<report test="@is-a">
Un bloc abstrait ne peut pas avoir un attribut is-a.
</report>
</rule>
</pattern>
</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.10.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 appele phase1 et phase2. Chacune de ces deux phases
contient un seul bloc.
queryBinding="xslt"
<title>Utilisation de phases</title>

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

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

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

<pattern id="count">
<rule context="bibliography">
<report test="book">
Il y a <value-of select="count(book)"/> livre(s).
</report>
</rule>
</pattern>
</schema>
116
Chapitre 8. Programmation 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 document XSL-FO ou XHTML, il peut aussi
produire des documents SVG [Chapitre 11].
Ce chapitre est consacr la partie XSLT de XSL. Le cours est essentiellement bas sur des exemples. Les
diffrentes constructions du langage XSLT sont illustres pas des fragments de programmes extraits des exemples.
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.
117
Programmation XSLT
Fe u ille d e s t yle
s t yl e s he e t . xs l
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
s o u r c e . x ml
r e s u l t . x ml
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. La premire
volution est l'utilisation de XPath [Chapitre 6] 2.0 la place de XPath 1.0. La 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 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 pas ncessaire
pour utiliser XSLT 2.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.
118
Programmation 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="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>
Cette feuille de style 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"/>
<title>Hello World!</title>
</head>
<body>
<h1>Hello world!</h1>
</body>
</html>
L'entte XML du rsultat t automatiquement mise par le processeur XSLT. Comme le codage [Section 2.4.2]
du document rsultat n'est pas spcifi par la feuille de style, c'est le codage par dfaut de XML qui a t choisi.
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.
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
119
Programmation XSLT
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 produit 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
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.
120
Programmation XSLT
t e mp l a t e
a p p l y - t e mp l a t e s
t e mp l a t e
t e mp l a t e
t e mp l a t e
t e mp l a t e
t e mp l a t e
t e mp l a t e
t e mp l a t 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 active 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
La programme ou feuille de style est entirement inclus dans un lment 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
dlarations d'espaces de noms sont importantes car le contenu de chaque rgle contient un mlange d'lments
XSLT et d'lments du document rsultat.
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. Un exemple typique d'utilisation est le suivant.
xmlns="http://www.w3.org/1999/xhtml">
<xsl:output method="xml"
encoding="iso-8859-1"
doctype-public="-//W3C//DTD XHTML 1.1//EN"
doctype-system="http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"
121
Programmation XSLT
indent="yes"/>
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 une rgle et d'appliquer une rgle un nud. Il faut
remarquer qu'une rgle spcifie par l'attribut match de xsl:template sur quels lments elle s'applique mais
que l'application d'une rgle ne prcise pas quelle rgle appliquer. L'lment xsl:apply-templates possde
uniquement un attribut select qui donne les nuds activer. C'est le processeur XSLT qui dtermine la rgle
prcise appliquer sur chaque nud activ. Il utilise pour cela des rgles de priorit entre les motifs contenus dans
les attributs match. Il est parfois indispensable de d'appliquer une rgle dtermine. Dans ce but, il est, d'abord,
possible de nommer une rgle avec un attribut name de xsl:template. Il est, ensuite, possible d'appliquer une
rgle nomme avec l'lment xsl:call-template dont l'attribut name donne le nom de la rgle appliquer.
xsl:template
Dclaration d'une rgle. L'attribut match contient un motif XPath qui dfinit le contexte de la rgle, c'est-dire, les nuds sur lesquels elle s'applique. L'attribut name spcifie le nom de la rgle. Au moins un des
deux attributs match ou name doit tre prsent. Le contenu de l'lment xsl:template est le fragment
de document insrer dans le document rsultat.
xsl:apply-templates
Application des rgles sur les nuds dsigns par le l'attribut select. la valeur par dfaut de cet attribut est
node() qui slectionne tous les nuds enfants mais pas les attributs. Cet lment peut uniquement apparatre
dans le contenu d'un lment xsl:template.
xsl:call-template
Application de la rgle nomme par l'attribut name. Comme l'lment xsl:apply-templates, cet
lment peut uniquement apparatre dans le contenu d'un lment xsl:template.
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.10.2] que la rgle applique peut avoir.
L'lment xsl:apply-templates peut aussi contenir un ou plusieurs lments sort pour effectuer un tri
[Section 8.9] des nuds slectionns par l'expression XPath de l'attribut select.
Le fragment de programme suivant dfinit une rgle grce xsl:template. 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. Cet lment du
document source est remplac dans le document rsultat par le traitement rcursif de ses lments fils suivi d'une
virgule. Le traitement des fils est provoqu par xsl:apply-templates dont la valeur par dfaut de l'attribut
match est child::*. La virgule est insre par l'lment xsl:text.
<xsl:template match="author|year|publisher">
<xsl:apply-templates/><xsl:text>,</xsl:text>
</xsl:template>
122
Programmation XSLT
8.6. Rgles par dfaut

Programme minimal.xml.
<?xml version="1.0" encoding="us-ascii"?>

xmlns:xsl="http://www.w3.org/1999/XSL/Transform"/>
En appliquant ce programme minimal 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="/|*">
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="text()|@*">
<xsl:value-of select"."/>
</xsl:template>
<xsl:template match="processing-instruction()|comment()"/>
La rgle par dfaut des attributs est d'afficher leur valeur. La valeur 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 ne slectionne pas les attributs.
8.7. Construction du rsultat

xsl:text
Insertion de texte brut.
123
Programmation XSLT
xsl:value-of
Insertion sous la forme chane de caractres des nuds dsigns par l'attribut select.
xsl:copy
Copie un niveau (appele aussi copie superficielle)
xsl:copy-of
Copie rcursive (appele aussi copie profonde)
xsl:element
Construction d'un lment dont le nom est donn par l'attribut name.
xsl:attribute
Ajout d'un attribut dont le nom est donn par l'attribut name.
xsl:number
Numrotation d'lments.
8.7.1. Insertion de texte : xsl:text

L'lment xsl:text utilise son contenu pour crer un nud texte dans le document final. Les caractres spciaux
'<', '>' et '&' sont automatiquement remplaces par les entits prdfinies [Section 3.3.1.1] 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 sont crits tels quels.
<xsl:text>Texte et entits '<', '>' et '&'</xsl:text>
8.7.2. 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. Un mme attribut peut contenir un mlange de texte et
de plusieurs expressions XPath comme dans l'exemple <p ... > ci-dessous.
<body background-color="{$color}">
...
<p style="{$property}: {$value}">
Cette syntaxe est beaucoup plus concise que l'utilisation classique de l'lment xsl:attribute pour ajouter
un attribut (cf. ajout d'attribut).
<body>
<xsl:attribute name="background-color" select="$color"/>
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
<xsl:template match="*">
<braces id="{@id}" esc="{{@id}}" escid="{{{@id}}}"/>
</xsl:template>
est applique un lment <braces id="JB007"/>, on obtient l'lment suivant.
<braces id="JB007" esc="{@id}" escid="{JB007}"/>
Les expressions XPath en attribut avec des structures de contrle XPath [Section 6.6] sont souvent plus concises
que constructions quivalentes en XSLT.
8.7.3. Insertion d'une valeur : xsl:value-of

L'lment xsl:value-of cre un un nud texte 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
124
Programmation XSLT
une chane de caractres. Lorsqu'une valeur est un nud, la conversion retourne la valeur textuelle de celui-ci. Le
texte est alors obtenu en concatnant ces diffrentes chanes. Un espace est insr entre chacunes d'entre elles.
Le caractre espace ' ' ui est normalement insr entre les diffrentes valeurs peut tre chang avec l'attribut
separator de l'lment xsl:value-of.
Le fragment XSLT suivant insre dans le document rsultat un attribut id dont la valeur est justement la valeur
de l'attribut id du nud courant.
<xsl:attribute name="id">
<xsl:value-of select="@id"/>
</xsl:attribute>
Quelques exemples d'utilisation de xsl:value-of.
<xsl:value-of
<xsl:value-of
<xsl:value-of
<xsl:value-of
select="."/>
select="generate-id()"/>
select="key('idchapter', @idref)/title"/>
select="ancestor-or-self::p[@xml:lang][1]/@xml:lang"/>
8.7.4. Ajout d'lment : xsl:element

Tout lment contenu dans un lment template et n'appartenant pas l'espace de nom xsl des feuilles de
style est recopi l'identique dans le document rsultat. Ceci permet d'ajouter facilement des lments dont les
noms sont fixes.
L'lment xsl:element permet galement d'ajouter un lment dans le document rsultat. Le nom de l'lment
peut tre calcul dynamiquement. Le nom est en effet dtermin par l'attribut name de xsl:element. Cet
attribut peut contenir une expression XPath dont l'valuation fournit le nom de l'lment.
Dans l'exemple suivant, le nom de l'lment est obtenu en concatnant la chane 'new-' avec la valeur de la
variable var.
<xsl:element name="concat('new-', $var)">...</element>
8.7.5. Ajout d'attribut : xsl:attribute

L'lment xsl:attribute permet d'ajouter un attribut un lment. Le rle de cette lment est similaire aux
expressions XPath dans les attributs mais il offre plus de possibilits. Le nom de l'attribut est dtermin par l'attribut
name qui peut contenir une expression XPath. Le nom de l'attribut peut donc tre calcul dynamiquement. La
valeur est donne soit par l'attribut select de xsl:attribute soit par le contenu de cet lment.
Le fragment de feuille style suivant construit un lment tr avec en plus un attribut bgcolor si la position de
l'lment trait est paire (test position() mod 2 = 0).
<tr>
<xsl:if test="position() mod 2 = 0">
<xsl:attribute name="bgcolor">#ffffcc</xsl:attribute>
</xsl:if>
...
</tr>
8.7.6. Insertion d'un numro : xsl:number

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
format-number de XPath.
125
Programmation XSLT
8.7.6.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.7.6.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
peut contenir plusieurs indicateurs de formats spars par des caractres non alphanumriques comme 1.1.1
ou [A-1-i].
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.
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" encoding="iso-8859-1" indent="yes"/>
<xsl:template match="*">
<xsl:copy>
<xsl:if test="name()='section'">

<xsl:number level="single" count="section" format="1"/>
</xsl:if>
126
Programmation XSLT
</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>
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'entier 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
127
Programmation XSLT
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.
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.
128
Programmation XSLT
<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.8. Structures de contrle

xsl:if
Conditionnelle (sans else) contrle par un attribut test.
xsl:choose
Conditionnelle plusieurs choix introduits par xsl:when
xsl:when
Introduction d'un choix dans xsl:choose contrl par un attribut test.
xsl:otherwise
Choix par dfaut de la conditionnelle xsl:choose.
xsl:for-each
Itration sur les lments slectionns par l'attribut select.
xsl:for-each-group
Itration sur des groupes d'lments slectionns par l'attribut select.
xsl:fallback
Fournit une alternative lorsqu'un lment n'est pas support.
xsl:message
Affichage d'un message avec ventuellement la fin du traitement si l'attribut terminate vaut yes.
8.8.1. Conditionnelle xsl:if

<xsl:if test="not(position()=last())">
<xsl:text>, </xsl:text>
</xsl:if>
8.8.2. Choix xsl:choose, xsl:when et

xsl:otherwise
<xsl:choose>
129
Programmation XSLT
<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.8.3. Itration xsl:for-each

<xsl:for-each select="bibliography/book">
<xsl:sort select="author" order="descending"/>
<tr>
<xsl:if test="position() mod 2 = 0">
<xsl:attribute name="bgcolor">#ffffcc</xsl:attribute>
</xsl:if>
<td><xsl:number value="position()" format="1"/></td>
<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>
8.9. 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 apply-templates, call-template, for-each ou for-each-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:sort select="author" order="ascending"/>
</xsl:apply-templates>
L'attribut select de xsl:sort dtermine la cl du tri. L'attribut data-type qui peut prendre les valeurs
number ou text spcifie comment les cls doivent tre interprtes. Il est possible d'avoir plusieurs cls de tri
en mettant plusieurs lments xsl:sort comme dans l'exemple suivant. Les lments book sont d'abord tris
par auteur puis par anne.
<xsl:apply-templates select="bibliography/book">
<xsl:sort select="author" order="ascending"/>
<xsl:sort select="year"
order="descending"/>
8.9.1. Utilisation de xsl:perform-sort

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.
130
Programmation XSLT
<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.10. 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 l'lment
xsl:variable et les paramtres par l'lment xsl:param. Les lments XSLT permettant d'utiliser les
variables et les paramtres sont les suivants.
xsl:variable
Cration et initialisation d'une variable.
xsl:param
Cration et valeur par dfaut d'un paramtre.
xsl:with-param
Instanciation d'un paramtre dans un appel ralis par xsl:apply-templates ou call-template.
8.10.1. Variables
La valeur de la variable est fixe au moment de sa dclaration par l'lment xsl:variable et 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 fille 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, la variable
squares est dclare de type xsd:integer*. Elle contient donc une liste d'entiers ventuellement vide.
<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"/>
131
Programmation XSLT
Une variable permet aussi de mmoriser un ou plusieurs nuds. Il est parfois ncessaire de mmoriser le nud
courant dans une variable afin de poufois y accder dans une expression XPath qui modifie contexte. 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]"/>
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 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)"/>
<publisher>

<xsl:copy-of select="$result/@*[name() != 'id']"/>
<xsl:copy-of select="$result/* | $result/text()"/>
</publisher>
8.10.2. Paramtres
La valeur par dfaut d'un paramtre est fixe au moment de sa dclaration par l'lment xsl:param. Parmi
les paramtres, le langage XSLT distingue les paramtres globaux et les paramtres (locaux) des rgles. Les
paramtres globaux sont dclars par un lment xsl:param fils de l'lment xsl:stylesheet. Leur valeur
est fixe au moment de l'appel au processeur XSLT. Leur valeur reste constanet 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
pour une option pour ces paramtres. Le processeur xstlproc a, par exemple, des options --param et -stringparam dont les valeurs sont des expressions XPath. La seconde option ajoute implitement les quotes
''' ncessaires autour des chanes de caractres.
La dclaration d'un paramtre d'une rgle est ralise par un lment xsl:param fils de xsl:template.
Les dclarations de paramtres doivent tre les premiers fils. Le passage d'une valeur en paramtre est ralise
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 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:output method="xml" encoding="iso-8859-1" indent="yes"/>
<xsl:apply-templates select="text">

<xsl:with-param name="color" select="'blue'"/>
132
Programmation XSLT
</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>
8.10.3. Rcursivit
La feuille de style suivant ralise le calcul rcursif d'un nombre Fn de la suite de Fibonacci dfinie par rcurrence
par F0 = 1, F1 = 1 et Fn+2 = Fn+1 + Fn pour n 0. L'entier n est fourni par le fichier XML en entre.

<xsl:output method="html" encoding="iso-8859-1" indent="yes"/>
<html>
<head>
<title>Nombres de Fibonacci</title>
</head>
<body>
<h1>
<xsl:variable name="n" select="n/text()"/>
<xsl:text>F</xsl:text>
<sub><xsl:number format="1" value="$n"/></sub>
<xsl:text> = </xsl:text>
<xsl:call-template name="fibo">
<xsl:with-param name="n" select="$n"/>
</xsl:call-template>
</h1>
</body>
</html>
</xsl:template>
<xsl:template name="fibo">
<xsl:param name="n" select="1"/>
<xsl:choose>
<xsl:when test="$n = 0">
<xsl:number format="1" value="1"/>
</xsl:when>
<xsl:when test="$n = 1">
<xsl:number format="1" value="1"/>
</xsl:when>
<xsl:otherwise>
<xsl:variable name="x">

-1"/>
-->
-2"/>
Programmation XSLT
</xsl:variable>
<xsl:number format="1" value="$x+$y"/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
</xsl:stylesheet>
8.10.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 nelunt. 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 nelunt. La valeur de
tunnel est effectivement la valeur donne au dpart ce paramtre. Au contraire, la valeur du paramtre nelunt
est celle par dfaut car il n'a pas t transmis.
<xsl:apply-templates select="text">
<xsl:with-param name="tunnel" select="'tunnel'" tunnel="yes"/>
<xsl:with-param name="nelunt" select="'nelunt'"/>
</xsl:template>
<xsl:template match="text">
<xsl:apply-templates select="text()"/>
</xsl:template>
<xsl:template match="text()">

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

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

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

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.
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 um
nom qualifi avec un espace de noms [Chapitre 4]. Les paramtres de la fonction sont donns par des lments
xsl:param 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 sont les types XPath [Section 6.1.4]. La dfinition d'une
fonction prend donc la forme gnrique suivante.
134
Programmation XSLT
<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.5.5.3] 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>
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: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
135
Programmation XSLT
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', '/')"/>

<xsl:value-of select="fun:join-path('Directory', 'index.html')"/>
8.12. 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 quel mode 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="..."/>
136
Programmation XSLT
...

<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()"/>
<xsl:apply-templates select="text()" mode="#current"/>
</xsl:template>
<xsl:template match="text()">
<xsl:text>Mode #default: </xsl:text>
<xsl:value-of select="."/>
<xsl:text>
</xsl:text>
</xsl:template>
<xsl:template match="text()" mode="test">
<xsl:text>Mode test: </xsl:text>
<xsl:value-of select="."/>
<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>
137
Programmation XSLT
</xsl:template>
8.13. Indexation
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'attribut name fixe le nom de l'index pour son utilisation. L'expression XPath
de l'attribut match dtermine les nuds qui sont indexs alors que l'expression XPath de l'attribut use spcifie
la cl d'indexation. L'lment xsl:key doit tre un fils de l'lment xsl:stylesheet.
<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.
<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.
<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.
8.14. 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>
138
Programmation XSLT
<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>
</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.15. Analyse de chanes

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 dont la
syntaxe est identique celle de la fonction XPath replace.
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="([^,]*),(.*)">
<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>
139
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 XSL [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.
140
Chapitre 10. Feuilles de style 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 par cette page-ci.
/* 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;
}
141
Feuilles de style 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 le 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 }
142
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 fils 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.
p[lang|="en"] {
quotes: '"' '"' "'" "'";
143
}
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 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 fils (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 mettre 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
in
pouce
mm
millimtre
144
Symbole
Unit
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 des 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.
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).
145
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 */
bibliography {
display: block;
border: 1px solid black;
margin: 30px;
padding: 20px;
}
146
/* 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>
<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 contenu dans
l'lment head. Il est prfrable de protger ces rgles par des balises  de commentaires.
147
<head>
<title>Titre de la page</title>
<style type="text/css"><!-/* Contenu de la feuille de style */
/* Ce contenu est 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
10.7.2. Fond
Proprit
Valeur
background
combinaison des proprits background-*
background-attachement
scroll ou fixed
background-color
couleur
148
Proprit
Valeur
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
149
Chapitre 11. SVG

SVG est un dialecte de XML pour le dessin vectoriel. Ce format permet de dfinir les lments graphiques de
manire standard.
llo , S VG !
e
H
Figure 11.1. Rendu du document ci-dessous
<!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
150
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
151
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"/>
152
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>
153
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.
154
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)
155
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
156
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
s o u r c e . x ml
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
157
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
158
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
s o u r c e . x ml
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>

159
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
160
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();
161
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);
162
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>
163
Programmation XML
</html>
164
Annexe A. Rfrences
A.1. Cours XML
Cours du W3C [http://www.w3schools.com/]
Cours [http://www.gchagnon.fr/cours/xml/] de Gilles Chagnon
Cours [http://www.grappa.univ-lille3.fr/~torre/Enseignement/Cours/XML] de Fabien Torre
Cours [http://www710.univ-lyon1.fr/~ecoquery/enseignement/sibd/cours-xml/cours-xquery.html] d'Emmanuel
Coquery
Cours [http://www.issco.unige.ch/staff/andrei/xml/] D'Andrei Popescu-Belis
WikiTuto [http://www.wikituto.org/index.php/Cat%C3%A9gorie:Cours_XML]
A.2. Tutoriaux
Tutorial XSL-FO de RenderX [http://www.renderx.com/tutorial.html]
Tutorial Schematron (Svon) [http://www.zvon.org/xxl/SchematronTutorial/General/toc.html]
Tutorial Schematron (D. Pawson) [http://www.dpawson.co.uk/schematron/index.html]
A.3. Spcifications
Schmas XML [http://www.w3.org/XML/Schema]
Schma pour les schmas [http://www.w3.org/2001/XMLSchema.xsd]
Traductions franaises des documents du W3C [http://www.w3.org/2003/03/Translations/byLanguage?
language=fr]
CSS [http://www.w3.org/Style/CSS/]
A.4. Sites gnralistes

Manuel de rfrences [http://www.devguru.com/] en ligne
Site [http://fr.selfhtml.org/] pour apprendre le WEB
A.5. Sites spcialiss

A.5.1. Schmas XML
Primer du W3C [http://www.w3.org/TR/xmlschema-0/]
XML Schema reference [http://www.xmlschemareference.com/]
A.5.2. CSS
Zen garden [http://www.csszengarden.com/]
MaxDesign [http://css.maxdesign.com.au/]
A list apart [http://www.alistapart.com/]
A.5.3. DocBook
Site DocBook [http://www.docbook.org/]
XSL stylesheets pour DocBook [http://www.sagehill.net/docbookxsl/index.html]
165
Annexe B. Logiciels XML

diteurs
emacs
[http://www.gnu.org/software/emacs] avec le package nXML
[http://
www.thaiopensource.com/nxml-mode/]
kxmleditor [http://kxmleditor.sourceforge.net] (plus maintenu)
xmlcopyeditor [http://xml-copy-editor.sourceforge.net]
XMLMind [http://www.xmlmind.com/xmleditor/] (Version Personal Edition gratuite)
Programmes de validation
nsgmls (projet OpenJade [http://openjade.sourceforge.net])
xmllint (partie de la librairie libxml2 [http://www.xmlsoft.org/])
xerces (projet XML [http://xml.apache.org/] d'Apache [http://www.apache.org])
Application de feuilles de style XSLT
xsltproc (partie de la librairie libxslt [http://www.xmlsoft.org/])
xalan (projet XML [http://xml.apache.org/] d'Apache [http://www.apache.org])
saxon [http://saxon.sourceforge.net/]
xt [http://www.blnz.com/xt/] de James Clark
sablotron [http://www.gingerall.org/sablotron.html]
Transformation de document XSL-FO en PDF
fop [http://xmlgraphics.apache.org/fop/] (d'Apache [http://www.apache.org])
xep [http://www.renderx.com/tools/xep.html] (de RenderX [http://www.renderx.com/])
(Version d'essais gratuite)
B.1. Memento logiciels

B.1.1. Validation DTD
Validation d'un document avec DTD interne ou locale
xmllint --noout --valid xmlfile.xml
xmllint --noout --dtdvalid dtdfile.dtd xmlfile.xml
export
export
export
nsgmls
SP_CHARSET_FIXED="yes"
SP_ENCODING="XML"
SGML_CATALOG_FILES="/usr/share/sgml/opensp-1.5.2/OpenSP/xml.soc"
-s xmlfile.xml
B.1.2. Validation par un schma

xmllint --noout --schema schema.xsd xmlfile.xml
B.1.3. Application de transformation XSLT

xsltproc --stringparam param value stylesheet.xsl source.xml
saxon8 source.xml stylesheet.xsl param=value
xt source.xml stylesheet.xsl param=value
Le caractre $ est un caractre spcial du shell.
166
Logiciels XML
sabcmd source.xml stylesheet.xsl \$param=value

xalan -IN source.xml -XSL stylesheet.xsl -PARAM param value
B.1.4. Cration d'un fichier PDF avec fop

# Directement partir d'un fichier FO
fop source.fo result.pdf
# Application d'une feuille de style pour produire le fichier FO
fop -xsl stylesheet.xsl -xml source.xml -pdf result.pdf
167
Annexe C. Acronymes XML

AJAX [ ]
Asynchronous JavaScript and XML
API [ ]
Application Programming Interface
BMP [ ]
Basic Multilingual Plane
CSS [ ]
Cascading Style Sheet
DOM [ ]
Document Object Model
DTD [ ]
Document Type Definition
FPI
Formal Public Identifier
Infoset
XML Information Set
NCName
No Colon Name (Nom local)
PCDATA
Parsed characters DATA
PNG [ ]
Portable Network Graphics
PSVI
Post-Schema Validation Infoset
QName
Qualified Name
RDF [ ]
Resource Description Framework
RSS [ ]
Really Simple Syndication
SAML [ ]
Security Assertion Markup Language
SAX [ ]
Simple API for XML
SGML [ ]
Standard Generalized Markup Language
SMIL [ ]
Synchronized Multimedia Integration Language
SOAP [ ]
Simple Object Access Protocol
168
Acronymes XML
SVG [ ]
Scalable Vector Graphics
SVRL [http://www.schematron.com/validators.html]
Schematron Validation Report Language
UBL [ ]
Universal Business Language
UCS [ ]
Universal Character Set
URI [ ]
Uniform Resource Identifier
URL [ ]
Uniform Resource Locator
URN
Universal Resource Name
WSDL [ ]
Web Services Description Language
XML [ ]
eXtensible Markup Language
XSD [ ]
XML Schema Definition
XSL [ ]
eXtensible Style Language
XSL-FO [ ]
XSL Formating Object
169
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.
Michael 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.
170
Index
A
anctre, 9
arbre
du document, 77
atomisation, 80
attribut, 10
xml:base, 15
B
balise
fermante, 8
ouvrante, 8
O
objet courant, 83
ordre du document, 81
P
parent, 9, 79
prologue, 5
S
schma, 33
section
littrale, 9
U
URL
de base, 11
codage
des caractres, 6
collation, 7, 83
commentaire, 13
contenu, 8
contexte
d'valuation, 82
dynamique, 82
statique, 82
D
descendant, 9
DTD, 17, 33
E
lment, 7, 8
racine, 7, 13, 17
enfant, 9, 79
entte, 6
espace de noms, 28, 72
cible, 73
par dfaut, 29
F
facette, 50
frre, 9
I
instructions de traitement, 14
J
jeton, 8, 24
N
nom, 8, 24
local, 28
qualifi, 28
nud courant, 83
171

L&#39;Essentiel de XML Olivier Carton

Transféré par

Informations du document

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

L&#39;Essentiel de XML Olivier Carton

Transféré par

Droits d'auteur :

Formats disponibles

Cours XML

Cours XML: L'essentiel de XML

Table des matires

7.3. Fonctionnement ...........................................................................................................

Chapitre 1. Introduction XML

1.3. Dialectes et extensions

Chapitre 2. Syntaxe de XML

2.2. Syntaxe et structure

2.3. Composition globale d'un document

<?xml ... ?>

2.4.1. Entte XML

2.4.2. Codage des caractres

2.4.3. Dclaration de type de document

2.5. Corps du document

2.5.1. Jetons et noms XML

Contenu de l'lm ent n a me

Figure 2.1. Composition d'un lment

Figure 2.2. lment avec un contenu vide

<t a g 1 > <t a g 2 >

</ t a g 2 > </ t a g 1 >

<t a g 1 > <t a g 2 >

</ t a g 1 > </ t a g 2 >

Figure 2.3. Imbrication des lments

Figure 2.4. Liens de parent

2.5.3. Sections littrales

<personname id="I666" firstname="Gaston" surname="Lagaffe"/>

2.5.5. Attributs particuliers

2.5.5.1. Attribut xml:lang

2.5.5.2. Attribut xml:space

2.5.5.3. Attribut xml:base

Figure 2.5. Structure d'une URL

2.5.5.4. Attribut xml:id

2.5.6. lment racine

Commentaires et instructions de traitement

Commentaires et instructions de traitement

2.5.8. Instructions de traitement

2.6. Exemples minimaux

2.6.1. Exemple minimal

2.6.2. Exemple simple avec une DTD

2.7. Utilisation de XInclude

3.1. Un premier exemple

bibliography (book)+ >

3.2. Dclaration de la DTD

3.2.1. DTD interne

3.2.2. DTD externe

3.2.2.1. Adresse par URL

3.2.2.2. Adresse par FPI

3.2.3. DTD mixte

3.3. Contenu de la DTD

3.3.1. Dclaration d'entit

3.3.1.1. Entits prdfinies

Tableau 3.1. Entits prdfinies

3.3.1.2. Entit interne

<!ENTITY entity "fragment" >

3.3.1.3. Entit externe

3.3.1.4. Entit paramtre

3.3.2. Dclaration d'lment

3.3.2.1. Contenu pur d'lments

Itration (nombre quelconque d'occurrences)

Itration stricte (nombre non nul d'occurrences)

Tableau 3.2. Oprateurs des DTD

<!ELEMENT elem (elem1 | elem2 | elem3) >

3.3.2.2. Contenu textuel

L'Essentiel de XML Olivier Carton

L'Essentiel de XML Olivier Carton