Le XML

Département ASI Mercredi 10 mai 2000
UV Multimédia
XML
Stéphane Allorge
Ingénieur développement
sur le projet SEMUSDI
Sommaire
INTRODUCTION ........................................................................................................ 3
Monsieur et Madame W3C ont un fils…................................................................................3
Exemple introductif ................................................................................................................3
LE LANGAGE XML.................................................................................................... 5
Les documents XML ................................................................................................................5
Documents bien formés et documents valides .......................................................................5
Documents, ressources et entités ............................................................................................6
Structure d’un document ........................................................................................................6
Le prologue.........................................................................................................................6
L’arbre d’élément ...............................................................................................................7
Les commentaires ...............................................................................................................7
Eléments et attributs ...............................................................................................................8
Les balises...........................................................................................................................8
Les attributs ........................................................................................................................8
Contenu d’un élément.........................................................................................................9
Entités et notations................................................................................................................10
Entités externes adressées par URL..................................................................................10
Entités externes adressées par identificateur public (FPI)................................................11
Entités non XML ..............................................................................................................12
Définition de documents types : DTD ...................................................................................13
Utilisation des DTD..............................................................................................................13
DTD interne ......................................................................................................................13
DTD externe .....................................................................................................................13
DTD en partie externe ......................................................................................................14
Contenu d'une DTD ..............................................................................................................14
Déclaration d'élément .......................................................................................................14
Déclaration de liste d'attributs ..........................................................................................16
Entités paramètres.............................................................................................................19
Sections conditionnelles .......................................................................................................20
LES FEUILLES DE STYLE ...................................................................................... 22
Principes de base.....................................................................................................................22
REFERENCES ......................................................................................................... 23
Bibliographie...........................................................................................................................23
Sites internet............................................................................................................................23
http://madsemusdipc1.insa-rouen.fr/tutoriaux/xml/ - Page 2 -
Introduction
Monsieur et Madame W3C ont un fils…
Fin 1990 : Tim Berners-Lee, informaticien du CERN, invente le World Wide Web (WWW)
afin d’améliorer la collaboration entre des chercheurs répartis sur de nombreux sites.
Naissance du langage HTML, HyperText Markup Language, issu de la famille SGML,
Standard Generalized Markup Language. Langage de description permettant de structurer et
d’afficher différents objets sur un écran. Le succès est immédiat, c’est un langage simple,
facile à comprendre et à mettre en œuvre.
Le web évolue et HTML montre ses limites.
1997 : XML, eXtensible Markup Language. A travers ce nouveau langage les membres de la
communauté SGML ont cherchés le compromis entre simplicité et puissance.
Exemple introductif
Différents fichiers de paramêtres sous environnement Windows
Fichier kpcms.ini
[KEPS Precision]
DRIVE=C:
[KCP]
CP_DIR=\KPCMS\CMSCP\
[API]
PT_DIR=\KPCMS\DCPDB\
CFG_FILE=KPPrefs.cfg
[ICC Profiles]
DefPath=C:\WINNT\System32\Color
Fichier DBConver.cnt
:Base DBConver.hlp
1 ICQ DBConverter
2 Introduction=Introduction
2 Upgrading Your Database=Upgrading_Your_Database
Fichier country.dat (extrait)

Aucun/Inconnu
1
Afghanistan
2
Albania
3
Algeria
4
American Samoa
5
Andorra
6
Angola
7
Anguilla
Constat
Tous ces fichiers ont un point commun, ils contiennent tous des éléments structurés selon un
code propre à l’application qui les utilise.
En revanche il n'est pas possible à une autre application de les utiliser sans en connaître les
règles d'utilisation et de syntaxe…
Le langage XML
Les documents XML
XML est un langage de description et d’échange de documents structurés. Comme SGML

dont il est issu, XML décrit la structure d’un document à l’aide d’un système de balises
marquant le début et la fin des éléments qui le compose.
Quelques points remarquables d’XML :
XML apparaît comme un format d’échange de données universel.
XML garantit à ses utilisateurs l’indépendance de leurs documents de toute technologie
propriétaire.
XML unifie le monde du traitement de document et celui du Web.
Documents bien formés et documents valides

Un document est bien formé s’il obéit aux règles syntaxiques du langage XML. Un tel
document sera correctement traité par un programme adéquat, comme un parseur XML. Si le
document n’est pas bien formé son traitement provoquera un message d’erreur ou un arrêt de
l’application qui le traite.
Un document valide est forcément un document bien formé mais il obéit en plus à une
structure type définie dans une DTD (Document Type Definition). Nous aborderons les DTD
ultérieurement.
Notons dès maintenant que :

• un document valide peut être distribué dans un système d’information sans sa DTD ou
sans référence à cette DTD, sous réserve de procéder au remplacement des références à
des entités par leur valeur. Le document apparaît dans ce cas comme un document bien
formé.
• les navigateurs XML sont capables de visualiser et d’imprimer, sous le contrôle d’une
feuille de style, des documents bien formés non valides.
• la définition ou l’utilisation d’une DTD n’est absolument pas imposée par les éditeurs
XML.
Documents, ressources et entités
Ressource : unité ou service d’information désignable par un identificateur. Par exemple les
numéros ISBN pour les ouvrages imprimés ou encore les URL pour les fichiers ou services
accessibles à travers un protocole d’Internet.
Entité : objet physique ou numérique qui peut être une réalisation particulière d’une
ressource. Par exemple le fichier html que retourne un serveur suite à une requête HTTP.
Une référence à une entité permet d’insérer celle-ci dans un document XML.
Document : œuvre de l’esprit susceptible d’être réalisée sous plusieurs formes physiques. Un
document XML existe toujours sous forme d’une ou de plusieurs entités.
Structure d’un document

Tout document XML se compose :
• d’un prologue, dont la présence est facultative mais conseillée. Il contiendra un certain
nombre de déclarations.
• d’un arbre d’éléments. Il forme le contenu du document.
• de commentaires et d’instructions de traitement, dont la présence est facultative. Ils
pourront, moyennant certaines restrictions, apparaître aussi bien dans le prologue que
dans l’arbre d’éléments.
Le prologue
Il peut contenir une déclaration XML, des instructions de traitement et une déclaration de type
de document.
Déclaration XML
Syntaxe : <?xml version=’1.0’ encoding=’ISO-8859-1’ standalone=’yes’ ?>
Elle indique au programme qui va traiter le document :

• la version du langage XML utilisée
• le codage de caractères utilisé dans le document ; par défaut ISO 10646 mais le
programme doit pouvoir traiter aussi l’UTF-8 et l’UTF-16.
• l’existence ou non de déclarations extérieures au document qui doivent être prise en
compte pour le traitement de celui-ci.
La déclaration est facultative mais fortement conseillée. Chacune des trois informations est
elle aussi facultative mais si elles apparaissent c’est obligatoirement dans cet ordre.
Instructions de traitement
Elles sont facultatives et ne font pas, à strictement parler, partie du document. Leur contenu
est simplement transmis à une application en vue de déclencher certains traitements.
Déclaration de type de document

La déclaration de type de document indique, le cas échéant, la DTD à laquelle se conforme le
document. Elle permet aussi de spécifier certaines déclarations propres au document.
Syntaxe : <!DOCTYPE nom_type [ déclarations ]>
nom_type est un nom choisi arbitrairement et qui sert à indiquer la portée des déclarations
définies entre crochets. Elles seront valides pour tout document dont l’élément racine sera du
type nom_type.
La DTD peut aussi être définie dans un fichier externe.
Syntaxe : <!DOCTYPE nom_type SYSTEM "fichier.dtd" [ déclarations ]>
Notons que la déclaration de type de document :

• est obligatoire pour les documents valides (se conformant à une DTD).
• est obligatoire lorsque l’auteur veut inclure des déclarations spécifique aux documents,
que ceux ci se conforment ou non à une DTD.
Exemple :
<?xml version="1.0" standalone="yes" ?>
<!DOCTYPE hello [
<!ELEMENT hello (#PCDATA)>
]>
<hello>Hello World.</hello>
L’arbre d’élément
Un élément peut contenir un ou plusieurs autres éléments. On parlera d’élément père et
d’élément fils. En fait la partie essentielle d’un document XML sera toujours formée d’une
hiérarchie d’éléments qui dénote la sémantique de son contenu : c’est l’arbre d’élément.
Exemple :
<personne>
<prenom>Anne</prenom>
<nom>Martin</nom>
<physique>
<yeux>bleu</yeux>
<cheveux>chatain</cheveux>
</physique>
<adresse>
<rue>rue de Mandur</rue>
<code_postal>76000</code_postal>
<ville>Rouen</ville>
</adresse>
</personne>
Dans un document XML il n’existe qu’un et un seul élément père, l’élément racine, qui
contient tous les autres.
Les commentaires
Des commentaires peuvent être insérés dans les documents. Ils sont encadrés pas les marques
de début  de commentaire.
Syntaxe : 
Le corps du commentaire peut contenir n’importe quel caractère à l’exception de la chaîne --.
On ne peut donc pas inclure un commentaire dans un autre. Le commentaire ne peut pas non
plus être inclus à l’intérieur d’une balise.
Eléments et attributs
Les balises
Chaque élément d’un document XML se compose d’une balise d’ouverture, d’un contenu
d’élément et d’une balise de fermeture.
Syntaxe : <nom>contenu_élément</nom>
La balise d’ouverture d’un élément peut inclure des attributs sous la forme de paires
nom=‘valeur’ :
Exemple :
<personne id="394563-M">Martin</personne>
Notons qu’une syntaxe simplifiée existe pour les éléments vides :

<nom/>
<personne id="394563-M" />
Quelques règles importantes :

• le nom des éléments est composé de caractères alphanumériques, de l’underscore _, du
signe moins - ou du point .. Le caractère deux-points : est autorisé mais il a une
signification particulière. De plus le premier caractère doit obligatoirement être
alphabétique ou un underscore.
• ce nom ne doit pas contenir d’espacement ou de fin de ligne.
• aucun nom ne peut commencer par la chaîne xml (casse indifférente).
• la valeur d’un attribut est une chaîne de caractère encadrés par des apostrophes ' ou par
des guillemets ". Elle ne doit pas contenir les caractères ^ % &.
XML fait une distinction entre majuscule et minuscule, ce qui fait que les balises <Nom>,
<nom> et <NOM> ne sont pas équivalentes.
Bien que pouvant être arbitrairement choisis, les noms d’éléments sont en général en rapport
avec le contenu qu’ils encadrent.
Les attributs
Il n’y a pas vraiment de règle quant au choix entre un document utilisant uniquement des
éléments sans attribut et un autre utilisant des éléments avec attributs.
Exemple :
<liste>
<personne>
<prenom>Anne</prenom>
<nom>Martin</nom>
<adresse>
</adresse>
</personne>
<personne>
<prenom>Gaelle</prenom>
<nom>Martin</nom>
<adresse>
</adresse>
</personne>
</liste>
L’avantage du premier réside dans le fait qu’il pourra, avec la feuille de style adéquat, être
visualisé sans problème dans un navigateur.
Le second sera peut être plus concis mais ne pourra plus forcement être correctement affiché
dans un navigateur.
Exemple :
<liste>
<personne prenom=‘Anne’ nom=‘Martin’>
<adresse rue=‘rue de Mandur’ ville=‘Rouen’ />
</personne>
<personne prenom=‘Gaelle’ nom=‘Martin’>
<adresse rue=‘rue de Mandur’ ville=‘Rouen’ />
</personne>
</liste>
Notons aussi que la première forme est peut être un peu moins pratique à utiliser après
traitement par un parseur que la seconde.
Contenu d’un élément

Un élément peut contenir d’autres éléments, des données, des références à des entités, des
sections littérales et des instructions de traitement.
Un élément peut avoir un contenu récursif, c’est à dire qu’il peut contenir une instance du
même type d’élément que lui-même.
Les données des éléments peuvent contenir tous les caractères autorisés sauf le et commercial
& et le inférieur <.
Référence à des caractères ou à des idéogrammes

Un auteur peut vouloir insérer un caractère non disponible sur sa plate-forme ou son clavier. Il
utilise pour cela le numéro du caractère dans les tables ISO 10646 ou Unicode. Ce numéro
sera précédé des caractères &# puis suivi d’un point virgule ;. Le numéro peut être donné en
décimal ou en hexadécimal (dans ce cas on le préfixe par &#x).
Par exemple & ou ≧ correspond au caractère et commercial &.
Référence à des entités prédéfinies

Il existe quelques entités prédéfinies afin de faciliter leur insertion dans un document XML. Il
s’agit notamment des caractères <, >, &, ‘ et "
< <
> >
& &
' ‘
" "
Référence à des entités internes

Il est également possible de définir ses propres entités et d’y faire référence dans le contenu
des éléments. Cette définition se fait dans la partie déclaration du DOCTYPE :
<!DOCTYPE nom_type [
<!ENTITY nom_entité "valeur_remplacement">
]>
Exemple :
<!DOCTYPE test [ <!ENTITY asi "Département ASI"> ]>
&asi;
qui donne : Département ASI
A noter qu’il est possible de composer des entités à partir d’autres entités :
<!DOCTYPE test [
<!ENTITY dp "Département">
<!ENTITY asi "&dp; ASI">
]>
&asi;
Section littérale
Lorsque l’on désire insérer une chaîne contenant beaucoup de caractères spéciaux il est
préférable d’utiliser le marqueur de section littérale <![CDATA [ … ]]>
Exemple :
Entité littérale <![CDATA [<dep>Département
ASI</dep>]]>
qui donne : Entité littérale <dep>Département ASI</dep>
Entités et notations
Le mécanisme des entités ne se limite pas aux éléments prédéfinis ou aux éléments définis en
interne.
On peut distinguer les entités selon qu’elle sont internes ou externes au document qui les
utilise. On peut aussi distinguer les entités qui contiennent un document ou un fragment de
document XML bien formé, de celle qui contiennent des données non XML (images,
graphiques, sons,…).
Notons que des entités contenant des données non XML seront obligatoirement des entités
externes.
Entités externes adressées par URL

Ce type d’entité permet, par exemple, de fragmenter un document XML en plusieurs sous-
documents. Ceux-ci peuvent alors être utilisés dans plusieurs documents distincts.
Syntaxe : <!ENTITY nom SYSTEM url>
On utilise le mot-clef SYSTEM suivi de l'URL où se trouve l'entité. Cette URL peut être donnée
en relatif ou en absolu. Les URL passées en absolu peuvent faire appel à l'un des protocoles
réseaux utilisés couramment sur l'Internet (http://, ftp://, ...).
Comme pour toute entité, les références externes sont remplacées par leurs valeurs (le contenu
des fichiers) lors du traitement du document.
Exemple :
<?xml version="1.0">
<!DOCTYPE carnet_adresse [
<!ENTITY usager "Emile Ezime">
<!ENTITY personne-1 SYSTEM "http://www.myhome.fr/anne_martin.xml">
<!ENTITY personne-2 SYSTEM "./gaelle_martin.xml">
]>
<carnet_adresse>
<titre>Carnet d'adresse de &usager;</titre>
&personne-1;
&personne-2;
</carnet_adresse>
Quelques règles :
• les entités externes doivent elles-mêmes être des fichiers XML bien formés.
• les entités externes n'ont pas à contenir de prologue, celui-ci étant présent dans le
document principal. Il est cependant possible d'inclure une déclaration XML simplifiée si
celle-ci contient des caractères dans un codage différent de celui utilisé dans le document
principal.
• les entités externes ne doivent pas contenir une redéfinition d'un élément du document
principal.
• les déclarations d'entités internes au document principal sont valides dans les sous
documents qu'il utilise.
Entités externes adressées par identificateur public (FPI)

Avertissement : les applications XML ne sont pas toutes capables de traiter les identificateurs
publics. Aussi nous ne ferons qu'un bref passage sur ce point.
Syntaxe : <!ENTITY nom PUBLIC fpi url>
Un identificateur public permet une indirection entre le nom symbolique donné à l'entité et
son URL. Si l'application n'est pas capable de résoudre l'identificateur public pour trouver la
ressource de l'entité, le paramètre url de la déclaration d'élément est utilisé.
Exemple :
<!ENTITY Rec-XML PUBLIC "-//W3//DOCUMENT Recommandation open - The
recommandation for XML 1.0//EN" "http://www.w3.org/TR/1998/REC-xml-
19980210.xml">
Cette indirection est physiquement réalisée par un fichier catalogue (une sorte de DNS). Si
l'URL venait à changer il suffirait de ne changer qu'une ligne dans le fichier catalogue.
Avantage :
• pas d'URL absolu donc pas de difficulté de mise à jour.
• recherche sur serveur le plus proche possible ou le plus facile d'accès.
Entités non XML
La déclaration d'entités non XML nécessite de déclarer préalablement le format de l'entité et
d'associer à ce format une application capable de le traiter. En XML une telle déclaration se
nomme une NOTATION.
Syntaxe : <!NOTATION nom_format SYSTEM url>
On utilise le mot-clef NDATA dans l'entité afin de préciser le format du fichier. Ensuite la
référence à une telle entité se fait pas l'intermédiaire d'un attribut en utilisant le nom
symbolique de l'entité.
Exemple :
<?xml version="1.0">
<!DOCTYPE scene [
<!NOTATION vrml SYSTEM "/urs/local/bin/cosmo">
<!ENTITY cube-3d SYSTEM "./cube.wrl" NDATA vrml>
]>
<scene>
<piece3D loc="cube-3d" />
</scene>
Attention : ne jamais référencer une telle entité en utilisant la construction &nom_entité;
Définition de documents types : DTD
DTD : Document Type Definition.
Les documents valides se conforment à une structure type prédéfinie. La définition de

document type est le mécanisme par lequel de telles structures sont spécifiées.
Les DTD présentent plusieurs intérêts :

• elles sont réutilisables, ce qui vous évite de réécrire une DTD lorsque vous voulez
composer plusieurs documents valides se conformant à une même structure.
• elles sont réutilisables ! De fait vous pouvez trouver des DTD libres de droit sur
Internet et composer des documents se conformant à une structure validée par toute
une communauté d’utilisateur.
• elles sont composables à partir d’autres DTD (moyennent quelques petites règles à
respecter).
Utilisation des DTD

Pour être valide un document doit inclure dans son prologue une déclaration de type, et cette
déclaration de type doit contenir, soit directement soit par référence à des entités externes, des
déclarations pour tous les éléments, attributs, notations et entités qui seront utilisés dans le
document.
DTD interne
Un document valide peut inclure directement sa DTD dans sa déclaration de type. L'attribut
standalone doit prendre la valeur yes, indiquant ainsi que le document est complet et
qu'aucune déclaration externe ne doit être recherchée.
Exemple :
<?xml version="1.0" standalone="yes" ?>
<!DOCTYPE carte [
<!ELEMENT carte (#PCDATA)>
]>
<carte>As de pique</carte>
DTD externe
Le document peut aussi faire référence à une DTD stockée dans une entité externe. L'avantage
est alors la réutilisation possible de la DTD.
Exemple :
Fichier jeu.xml
<?xml version="1.0" standalone="no" ?>
<!DOCTYPE carte SYSTEM "carte.dtd">
<carte>As de pique</carte>
Fichier carte.dtd
<?xml version="1.0" encoding="ISO8859-1" ?>
L'attribut standalone doit prendre la valeur no afin d'indiquer au processeur que des
déclarations ou des parties de déclaration sont contenues dans des entités externes. La
déclaration XML dans le fichier carte.dtd n'est pas indispensable mais elle permet d'indiquer
la version d'XML utilisée.
DTD en partie externe

Il est possible de définir certaines déclarations en interne et de faire en même temps appel à
une DTD externe. Les déclarations locales forment la partie interne et les déclarations
contenues dans la DTD forment la partie externe.
Exemple :
Fichier jeu.xml
<?xml version="1.0" standalone="no" ?>
<!DOCTYPE carte SYSTEM "carte.dtd" [
<!ATTLIST carte force (forte | moyenne | faible)>
]>
<carte force="forte">As de pique</carte>
Fichier carte.dtd
<?xml version="1.0" encoding="ISO8859-1" ?>
En cas d'incompatibilité entre des déclarations de la partie interne et celles de la partie externe
il est alors possible de redéfinir en interne la déclaration d'un élément, d'un attribut ou d'une
entité. Les déclarations de la partie interne auront alors priorité sur celles de la partie externe.
Contenu d'une DTD

Une DTD peut contenir :
• des déclarations d'entités générales
• des déclarations d'entités paramètres
• des déclarations de notations
• des déclarations d'éléments
• des déclarations de listes d'attributs
• des commentaires
Déclaration d'élément
Syntaxe : <!ELEMENT nom modèle>
nom doit respecter les règles d'écriture des éléments.
Une déclaration d'élément définit un type d'élément et associe un nom de type à un modèle de
contenu. Tous les éléments instances de ce type apparaissant dans un document devront avoir
un contenu conforme au modèle défini dans la déclaration.
Le modèle de contenu permet la création d'éléments contenant :
• un ou des éléments fils spécifiés
• des données représentées par un flot de caractères
Le contenu de l'élément peut aussi être un mélange de données et d'éléments fils spécifiés ou
arbitraires, selon la déclaration. Il est aussi possible de spécifier qu'un élément reste vide.
Elément fils
Les éléments fils peuvent être en ordre libre ou en ordre imposé pour former une séquence. En
ordre libre ils seront séparés par des barres verticales | et en ordre imposé, par des virgules ,.
Exemple :
<!ELEMENT livre (titre, preface?, chapitre+, référence*)>
<!ELEMENT chapitre (paragraphe* | illustration*)>
Signification des suffixes d'élément :

• e? indique que l'élément e peut apparaître zéro ou une fois dans le contenu de
l'instance
• e+ indique que l'élément e peut apparaître une ou plusieurs fois dans le contenu de
l'instance
• e* indique que l'élément e peut apparaître zéro, une ou plusieurs fois dans le contenu
de l'instance
• en l'absence de suffixe l'élément doit apparaître une seul fois.
Le suffixe peut s'appliquer à un ensemble d'éléments :

<!ELEMENT chapitre (paragraphe | illustration)*>
Attention ceci n'a pas la même signification que :

<!ELEMENT chapitre (paragraphe* | illustration*)>
Dans le premier cas il peut y avoir dans un chapitre plusieurs paragraphes et/ou illustrations
dans n'importe quel ordre. Dans le second cas il ne peut y avoir que plusieurs paragraphes ou
plusieurs illustrations mais pas les deux mélangés.
Enfin il est possible d'imposer un nombre d'éléments fils du même type :

<!ELEMENT chapitre (paragraphe, paragraphe, paragraphe+)>
Qui indique qu'il devra y avoir au minimum trois paragraphes ou plus.
Données
La présence de données dans le contenu d'un élément s'indique par le mot-clef #PCDATA
abréviation de Parsed Character Data.
Exemple :
<!ELEMENT titre (#PCDATA)>
L'élément ne peut contenir que des données et pas d'élément fils. De plus ces données ne
peuvent être qu'un flot de caractères et pas une image ou autre donnés non textuelle (cf
l'utilisation de NOTATION pour procéder à l'inclusion de telles données).
Modèle mixte
Il est fréquent de définir des modèles mixtes permettant de mêler des données et des éléments.
Exemple :
<!ELEMENT paragraphe (#PCDATA | renvoi)*>
<!ELEMENT renvoi (#PCDATA)>
L'étoile * est obligatoire à la suite de la déclaration du modèle de l'élément. Le type #PCDATA

doit obligatoirement apparaître à gauche de la liste.
Contenu libre
Il est aussi possible de définir des éléments ayant un contenu quelconque, données ou
éléments.
Syntaxe : <!ELEMENT nom_élément ANY>
Pour que le document soit valide les éléments apparaissant dans le contenu de texte_libre
doivent eux-mêmes être déclarés.
Le modèle de données ANY est assez pratique lors de la mise au point d'une DTD en
procédant par remplacement successif des ANY par des structures d'éléments plus contraints.
Elément vide
Un élément peut être spécifié comme obligatoirement vide, en utilisant le mot-clef EMPTY :
Exemple :
<!ELEMENT renvoi EMPTY>
<!ATTLIST renvoi ref IDREF #REQUIRED>
Notons qu'un élément instance d'un type d'élément déclaré comme vide doit être marqué avec
le balisage d'élément vide, <nom_element/>, si l'on souhaite que le document soit compatible
avec les applications SGML.
Un élément instance peut être vide sans que cela ne soit obligatoire, si le modèle le permet.
Déclaration de liste d'attributs

Un attribut est une paire nom="valeur" que l'on associe à un élément. La déclaration
d'attribut dans une DTD permet de spécifier quels sont les attributs qui pourront ou devront
être associés à une instance d'élément, et indiquer éventuellement quelle sera la valeur par
défaut d'un attribut.
Syntaxe :
<!ATTLIST nom_élément nom_attribut type_attribut déclaration_de_défaut>
Il est possible de définir un nombre arbitraire d'attributs pour un élément donné.
Notons que deux éléments différents peuvent avoir des attributs ayant le même nom sans que
cela ne pose problème.
La déclaration de défaut peut prendre quatre formes :

• une valeur : la valeur par défaut de l'attribut
• #FIXED : la valeur de l'attribut est fixée. Elle doit donc être indiquée dans la
déclaration.
• #REQUIRED : l'attribut et sa valeur doivent obligatoirement être présents dans les
instances de l'élément. Aucune valeur par défaut ne peut être fixée.
• #IMPLIED : la présence de l'attribut est facultative dans une instance de l'élément.
Aucune valeur par défaut ne peut être fixée.
Attribut CDATA
Le type d'attribut CDATA indique que la valeur de l'attribut sera une chaîne de caractères prise
littéralement, c'est à dire sans reconnaissance et traitement des caractères spéciaux de la
syntaxe XML.
Exemple :
<!ATTLIST livre isbn CDATA #REQUIRED>
<!ATTLIST livre code CDATA #FIXED '>>089.55<<'>
Comme CDATA est un type littéral les symboles inférieur < et supérieur > seront reconnus et
traités sans problème.
Attribut ENTITY ou ENTITIES

Le type d'attribut ENTITY permet d'indiquer que l'attribut prend pour valeur le nom d'une ou
de plusieurs (ENTITIES) entités externes non XML (par exemple une image). Comme nous
l'avons déjà vu il faudra associer un format de fichier à l'entité non XML au moyen d'une
déclaration NOTATION.
Exemple :
<-- Dans une DTD -->
<!ELEMENT objet-3d EMPTY>
<!ATTLIST objet-3d forme ENTITIES #REQUIRED>
<-- Dans une instance de document -->

<!ENTITY cube SYSTEM "./cube.wrl" NDATA vrml>
<!ENTITY sphere SYSTEM "./sphere.wrl" NDATA vrml>
<-- Dans le corps du document -->

<objet-3d forme="cube sphere" />
Attributs NMTOKEN ou NMTOKENS

Le type d'attribut NMTOKEN permet d'indiquer que le contenu de l'élément peut prendre comme
valeur un nom symbolique composé uniquement de caractères alphanumériques.
Exemple :
<!ELEMENT livre EMPTY>
<!ATTLIST livre code_editeur NMTOKEN #REQUIRED>

<livre code_editeur="G09052" />
Attribut NOTATION
Le type d'attribut NOTATION permet d'indiquer que le contenu de l'élément est au format
indiqué par la valeur de l'attribut (qui fait référence à une NOTATION).
Exemple :
<!ELEMENT objet-3d ANY>
<!ATTLIST objet-3d forme NOTATION (vrml) #REQUIRED>
<object-3d forme="vrml">
#VRML V2.0 utf8
Shape {
appearance Appearance {
material Material {
diffuseColor 0 1 0
}
}
geometry Box {
size 3 3 3
}
}
</vrml>
Lorsque le processus traitant le fichier XML rencontre un élément ayant un attribut du type
NOTATION il sait que le contenu de cet élément est autre chose que du XML. Il peut alors
transmettre ce contenu à une application capable de le traiter.
Attribut énuméré
Ce type d'attribut permet de spécifier la liste des valeurs qu'il peut prendre dans un document.
Il est également possible d'indiquer une valeur par défaut.
Exemple :
<!ELEMENT livre (#PCDATA)>
<!ATTLIST livre genre (roman | technique | bd) #IMPLIED>
<livre genre="technique">Ce livre parle du XML…</livre>
Attribut ID et IDREF
Ces deux types d'attributs permettent de créer des renvois à l'intérieur d'un document : renvoi
vers une référence bibliographique, vers une note, etc. L'attribut ID identifie de façon unique
tous les éléments qui peuvent servir de cible à un renvoi. IDREF, attribut de l'élément à partir
duquel se fait le renvoi, permet de créer une référence à un ID.
Exemple :
<!ELEMENT mot (#PCDATA)>
<!ATTLIST mot renvoi ID #IMPLIED>
<!ELEMENT definition (#PCDATA)>

<!ATTLIST definition reference IDREF #REQUIRED>

<mot renvoi="m346">Normandie</mot>
...
<definition reference="m346">La plus belle région de
France</definition>
Un attribut ID ne peut être que du type IMPLIED ou REQUIRED. On ne peut donc pas lui donner
une valeur fixée, ou une valeur par défaut.
Un élément ne peut avoir qu'un seul attribut de type ID et IDREF.
Le mécanisme de renvoi ne fonctionne qu'à l'intérieur d'un même document.
Entités paramètres
Jusqu'ici nous avons des entités déclarées et référencées dans un document. De telles entités
sont qualifiées de d'entités générales. Il est possible de déclarer des entités qui ne soient
référençables qu'à l'intérieur même de celles-ci. On parle alors d'entités paramètres.
Comme pour les entités générales, les entités paramètres peuvent être déclarées de trois
façons :
Syntaxe :
<!ENTITY % nom_entité "valeur">
<!ENTITY % nom_entité SYSTEM url>
<!ENTITY % nom_entité PUBLIC fpi url>
La déclaration d'une entité paramètre diffère donc de celle d'une entité générale par la
présence du caractère pour cent %. Une entité paramètre ne peut être du type NDATA et ne peut
donc pas contenir autre chose que du XML.
Une référence à une entité paramètre, forcément située dans la DTD, prend la forme
%nom_entité;. Une telle référence ne doit pas apparaître dans une valeur d'attribut, même
dans une DTD.
Exemple :
<!ENTITY % p "(#PCDATA)">
<!ENTITY % c "(paragraphe* | illustration*)">
<!ELEMENT livre (titre, preface?, chapitre*)>
<!ELEMENT titre %p;>
<!ELEMENT preface %c;>
<!ELEMENT paragraphe %c;>
Exemple :
<!ELEMENT auteur (#PCDATA)>
<!ENTITY % am "Anne Martin">
<!ENTITY qui "Ecrit par %am;">
Les entités paramètres sont aussi utilisées pour inclure le contenu d'une DTD externe. Ainsi il
est possible de segmenter les différentes parties d'une DTD dans plusieurs fichiers externes et
de les rendre ainsi réutilisables.
Exemple :
<?xml version="1.0" standalone="no"?>
<!DOCTYPE carnet_adresse [
<!ENTITY % personne SYSTEM "personne.dtd">
%personne;
]>
Si une entité paramètre définie dans une section externe est redéfinie dans la section interne
cette dernière redéfinition est toujours prioritaire.
Exemple :

<!ENTITY % d "(#PCDATA)">
<!ELEMENT phrase %d;>


<!DOCTYPE paragraphe [
<!ENTITY % ph SYSTEM "phrase.dtd">
%ph;
<!ENTITY % d "(mot | symbole)*">
<!ELEMENT mot (#PCDATA)>
<!ELEMENT symbole (#PCDATA)>
]>
Sections conditionnelles
Les sections conditionnelles, utilisées conjointement avec la répartition des déclarations d'une
DTD entre section interne et section externe, offrent une méthode puissante pour créer une
DTD permettant de réaliser des documents dont le contenu diffère selon l'utilisation qui en est
faite.
Il sera donc possible de définir des sections devant être incluses dans le document et d'autres
ne devant pas l'être. Ce mécanisme se met en place au moyen des mots-clefs INCLUDE et
IGNORE.
Syntaxe :
<![ IGNORE [ déclarations ]]>
<![ INCLUDE [ déclarations ]]>
Les déclarations de la section conditionnelle débutant par INCLUDE seront prises en compte
par le processus traitant le fichier. Celles de la sections conditionnelle débutant par IGNORE
seront ignorées par ce même processus.
Ce mécanisme est d'autant plus efficace qu'il est associé à celui des entités paramètres.
Exemple :
<-- Dans une DTD externe -->
<!ENTITY % publique "IGNORE">
<!ENTITY % confidentielle "INCLUDE">
<!ELEMENT livre (titre, preface?, chapitre*);>
<![ %confidentielle [
<!ELEMENT chapitre (paragraphe | illustration | annotation)*>
]>
<![ %publique [
<!ELEMENT chapitre (paragraphe | illustration)*>
]>
Pour une version confidentielle on laissera la DTD telle quelle, la déclaration publique ne sera
pas incluse dans le document alors que la déclaration confidentielle le sera. Pour une
utilisation grand public on procèdera à la redéfinition des entités %publique et
%confidentielle.
Exemple :
<-- Dans la section interne -->
<!DOCTYPE livre [
<!ENTITY % dtdlivre SYSTEM "livre.dtd">
%dtdlivre;
<!ENTITY % publique "INCLUDE">
<!ENTITY % confidentielle "IGNORE">
]>
La déclaration publique sera alors incluse dans le document et la déclaration confidentielle ne

le sera pas.
Notons que les sections conditionnelles ne peuvent être déclarées que dans des entités
externes.
Les feuilles de style
Principes de base
Créer une feuille de style consiste à définir des règles de "mise en page" pour chaque type
d'élément apparaissant dans un document ou dans un ensemble de document. Ces propriétés
attachées à chaque élément du document formaté vont être décrites dans un fichier de
spécification, la feuille de style, sous forme d'un ensemble de déclaration exprimées dans la
syntaxe XML.
Un même document pourra ainsi être présenté de différentes façons. Seule la présentation
changera, le contenu restera le même.
Il existe actuellement différents formats de feuilles de styles :

• Viewport, fichiers d'extension .ssh
• Cascading Style Sheets, fichiers d'extention .css
• eXtensible Stylesheet Language, fichiers d'extension .xsl
Viewport est un format un peu à part. A l'origine c'est un mécanisme de feuilles de style,
inclus dans un moteur dénommé Viewport (présenté sous forme d'une boîte à outils pour
développeurs d'application SGML) développé par une société suedoise, Synex Information
AB. Ce moteur est utilisé par deux des principaux fournisseurs de visualisateurs SGML et de
fait la feuille de style Viewport est devenu un standard dans le monde SGML.
Les Cascading Style Sheets ont été initialement conçues pour le langage HTML. La première
version, CSS-1, à été publiée en 1996 suivi en 1998 de la version CSS-2. Les deux navigateurs
les plus répandus, Internet Exporer et Netscape, supportent les feuilles de style CSS-1 depuis
leur version 4. CSS-1 et CSS-2 s'appliquent parfaitement à XML.
eXtensible Stylesheet Language est un langage permettant de spécifier une feuille de style. Il
est construit sur des principes profondément différents de ceux de CSS et il offre par rapport à
ce formalisme des possibilités nouvelles trés puissantes. XSL procède par reconstruction d'un
arbre à partir de l'arbre XML. Ce nouvel arbre peut avoir un ordre différent de l'arbre source
et de nouveaux éléments peuvent y être introduit. Des traitement spécifique peuvent même
être mis en place au moment de sa construction. XSL est donc un langage de feuille de style
avec des possibilités de traitement assez puissantes.
Références
Bibliographie
Alain Michard – XML, Langage et applications, 1999, Edition Eyrolles.
Sites internet
W3C
http://www.w3.org
XML.COM
http://www.xml.com/
XML SOFTWARE
http://www.xmlsoftware.com/
<XML>fr
http://www.xmlfr.org/

Le XML

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Le XML

Hochgeladen von

Copyright:

Verfügbare Formate

Département ASI Mercredi 10 mai 2000

Monsieur et Madame W3C ont un fils…

Fichier country.dat (extrait)

Les documents XML

XML est un langage de description et d’échange de documents structurés. Comme SGML

Documents bien formés et documents valides

Notons dès maintenant que :

Structure d’un document

Elle indique au programme qui va traiter le document :

Déclaration de type de document

Syntaxe : <!DOCTYPE nom_type [ déclarations ]>

La DTD peut aussi être définie dans un fichier externe.

Syntaxe : <!DOCTYPE nom_type SYSTEM "fichier.dtd" [ déclarations ]>

Notons que la déclaration de type de document :

Syntaxe :

Notons qu’une syntaxe simplifiée existe pour les éléments vides :

Quelques règles importantes :

Contenu d’un élément

Référence à des caractères ou à des idéogrammes

Par exemple &#38; ou &#x2267; correspond au caractère et commercial &.

Référence à des entités prédéfinies

Référence à des entités internes

Entités externes adressées par URL

Syntaxe : <!ENTITY nom SYSTEM url>

Entités externes adressées par identificateur public (FPI)

Syntaxe : <!ENTITY nom PUBLIC fpi url>

Syntaxe : <!NOTATION nom_format SYSTEM url>

Attention : ne jamais référencer une telle entité en utilisant la construction &nom_entité;

DTD : Document Type Definition.

Les documents valides se conforment à une structure type prédéfinie. La définition de

Les DTD présentent plusieurs intérêts :

Utilisation des DTD

DTD en partie externe

Contenu d'une DTD

nom doit respecter les règles d'écriture des éléments.

Le modèle de contenu permet la création d'éléments contenant :

Signification des suffixes d'élément :

Le suffixe peut s'appliquer à un ensemble d'éléments :

Attention ceci n'a pas la même signification que :

Enfin il est possible d'imposer un nombre d'éléments fils du même type :

L'étoile * est obligatoire à la suite de la déclaration du modèle de l'élément. Le type #PCDATA

Syntaxe : <!ELEMENT nom_élément ANY>

Déclaration de liste d'attributs

Il est possible de définir un nombre arbitraire d'attributs pour un élément donné.

La déclaration de défaut peut prendre quatre formes :

Attribut ENTITY ou ENTITIES

<-- Dans une instance de document -->

<-- Dans le corps du document -->

Attributs NMTOKEN ou NMTOKENS

<-- Dans le corps du document -->

<livre genre="technique">Ce livre parle du XML…</livre>

<!ELEMENT definition (#PCDATA)>

<-- Dans le corps du document -->

La déclaration publique sera alors incluse dans le document et la déclaration confidentielle ne

Il existe actuellement différents formats de feuilles de styles :

Alain Michard – XML, Langage et applications, 1999, Edition Eyrolles.

Das könnte Ihnen auch gefallen

Par exemple & ou ≧ correspond au caractère et commercial &.