Le langage XML

Cinq caractères spéciaux

< > & " '

échappement

X = &X;

< = &lt;
> = &gt;
& = &amp;
" = &quot;
' = &apos;

Un document XML est composé d'éléments et d'attributs, équivalents à des sous-éléments. Il possède un élément racine. Un élément possède un nom, peut contenir des attributs, d'autres éléments et une valeur alphanumérique (possiblement entrelacée avec les sous-éléments). Un attribut possède un nom et une valeur alphanumérique.

Elément défini par une balise X

<X>...</X>

• Ouverture et fermeture (comme des parenthèses)
• Cas particulier : élément vide <X/>
• Contenu d'un élément : d'autres éléments, des attributs, du contenu alphanumérique

Attribut associé à un élément X

<X id=val>

• id : nom de l'attribut associé à l'élément X
• val : chaîne alphanumérique entre guillemets ("…") ou apostrophes ('…')

Un espace de nommage sert à ranger des noms d'éléments, d'attributs ou de types. Le nom complet d'un élément ou d'un attribut est formé de celui de son espace, suivi de son nom propre. Ainsi les espaces de nommage permettent d'éviter les conflits de nommage, qui surviennent quand le même nom peut désigner plusieurs entités. Pour résoudre ces conflits, il suffit de placer les entités homonymes dans des espaces différents.

A chaque espace de nommage, le langage XML associe

• une valeur, appelée l'identifiant de l'espace, donnée par une URI (pure convention, l'URI n'étant pas nécessairement associé à une ressource),
• un ensemble d'entités définies dans un schéma.

Lorsque l'espace de nommage est utilisé, un nom d'usage (éventuellement vide) lui est aussi associé. Il est conseillé de ne pas utiliser un nom préfixé par xml (en minuscule ou en majuscule) pour éviter les conflits avec des noms réservés (comme xmlns). La définition du nom d'usage se fait à l'intérieur d'un élément, en utilisant un attribut appartenant à un espace de nommage prédéfini et nommé xmlns.

<A  xmlns:nom="URI1" >
    xmlns="URI2" <!-- nom vide --> >

Exemple

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
            xmlns:jxb="http://java.sun.com/xml/ns/jaxb"
            jxb:version="2.0">

Le préfixe xmlns s'interprète comme une directive particulière.

xmlns = xml name space = espace de nommage xml

Le nom suivant les deux points sert de nom d'usage (cf. xsd et jxb), à l'intérieur de l'élément où la directive est placée : il peut alors servir de préfixe de noms d'éléments ou d'attributs. Les noms deviennent qualifiés.

Exemple : élément schema dans l'espace xsd et attribut version de l'espace jxb

xsd:schema 
jxb:version

L'URI qui termine la définition identifie l'espace de nommage.

Le nom d'usage vide ne peut être utilisé que pour des éléments. En pratique, on l'utilise pour simplifier l'écriture pour l'espace de nommage le plus utilisé dans un document.

En l'absence d'une définition xmlns=nom, les noms non qualifiés n'appartiennent à aucun espace de nommage : cette situation doit être distinguée de celle où un espace de nommage est utilisé anonymement (avec un nom vide), puisqu'il est alors possible d'associer un espace bien réel.

Pour définir et peupler de noms un espace de nommage, on utilise un schéma : cf. infra la section Espaces de nommage.

Il est possible de valider un document relativement à un schéma : on parlerait en programmation de vérification du typage.

L'algorithme peut être décrit ainsi.

1. Programme principal :
   • recherche dans les définitions globales du schéma d'une déclaration pour l'élément racine
   • vérification de l'élément racine relativement à sa déclaration
2. Sous-Programmes
   • vérification d'un élément relativement à sa déclaration
     • recherche du type du contenu à partir du nom du type, soit spécifié dans le document par l'attribut xsi:type de l'espace "http://www.w3.org/2001/XMLSchema-instance", qui doit avoir pour valeur un sous-type du type spécifié par la déclaration, soit en l'absence de cet attribut, spécifié directement par la déclaration de l'élément dans le schéma
   • vérification du contenu de l'élément relativement à la définition du type dans le schéma
     • décomposition (nécessairement unique) du contenu en une suite d'attributs, de valeurs alphanumériques et de sous-éléments en correspondance avec les déclarations définies dans le type
     • vérification des attributs, des valeurs alphanumériques et des sous-éléments relativement aux déclarations associées dans le type
   • vérification d'un attribut relativement à sa déclaration
     • vérification de la valeur relativement au type (simple) indiqué dans la déclaration
   • vérification d'une valeur alphanumérique relativement à sa déclaration

Un schéma utilise l'espace de nommage prédéfini, http://www.w3.org/2001/XMLSchema. Il commence par une balise schema, et définit en utilisant l'attribut targetNamespace l'espace de nommage cible auquel appartiendront toutes les entités définies dans le schéma.

<?xml version="1.0"?>

<xs:schema 
   xmlns:xs="http://www.w3.org/2001/XMLSchema" <!-- espace de nommage prédéfini pour les schémas --> 
   targetNamespace="URI" <!-- espace de nommage cible pour les entités définies --> 
   ...
>
  ...
</xs:schema>

Très souvent, on utilise l'espace de nommage cible à l'intérieur du schéma, ce qui donne la structure suivante.

<schema xmlns="http://www.w3.org/2001/XMLSchema"
        xmlns:tns="URI"
        targetNamespace="URI"
        ...
>

L'espace cible reçoit ainsi tns pour nom d'usage.

Exemple : une école de type EPA, avec une tutelle et un nom

<schema xmlns="http://www.w3.org/2001/XMLSchema"
        xmlns:emn="http://www.mines-nantes.fr"
        targetNamespace="http://www.mines-nantes.fr"
>

  <element name="ecole" type="emn:EPA" />

  <complexType name="EPA">
    <sequence>
      <element name="tutelle" type="string" />
      <element name="nom" type="string" />
    </sequence>
  </complexType>

</schema>

Un schéma définit aussi une convention de nommage pour les éléments et les attributs. On utilise les attributs elementFormDefault et attributeFormDefault de l'élément schema, qui peuvent prendre la valeur qualified ou unqualified.

elementFormDefault="qualified"

Tous les éléments doivent être qualifiés.

elementFormDefault="unqualified"

Seuls les éléments globaux du schéma doivent être qualifiés. Les éléments locaux du schémas ne doivent pas être qualifiés.

attributeFormDefault="qualified"

Tous les attributs doivent être qualifiés.

attributeFormDefault="unqualified"

Seuls les attributs globaux du schéma doivent être qualifiés. Les attributs locaux du schémas ne doivent pas être qualifiés.

Par défaut, ces attributs valent unqualified.

Une bonne pratique est

• de requérir la qualification de tous les éléments (ce qui permet de transformer des définitions locales en globales, et réciproquement, sans avoir à modifier les documents valides) et

• de requérir la qualification des seuls attributs globaux.

  elementFormDefault="qualified"
  attributeFormDefault="unqualified"
  

Ainsi, si dans le document on utilise un espace de nommage anonyme (de nom d'usage vide), tout élément non qualifié appartient alors à cet espace de nommage et tout attribut non qualifié appartient à l'espace de nommage de l'élément le contenant.

Un schéma est défini dans un seul fichier. Il est cependant possible d'inclure les définitions globales de schémas définis dans d'autres fichiers.

On utilise une directive d'inclusion si :

• les entités définies dans le schéma importé appartiennent au même espace cible,

• les entités définies dans le schéma importé n'appartiennent à aucun espace cible, ce qui a pour effet de les placer dans l'espace cible du schéma réalisant l'importation.

  <xs:schema ... >
    <xs:include schemaLocation="URL"/>
  

(URL est l'adresse du fichier .xsd définissant le schéma.)

Sinon, on doit utiliser une directive d'importation.

<xs:schema ... >
 <xs:import namespace="URI" schemaLocation="URL"/>

(URI est l'espace de nommage cible du schéma importé, URL est l'adresse du fichier .xsd définissant le schéma.)

Un schéma est composé de définitions globales, qui peuvent contenir des définitions locales. Toute définition locale peut contenir elle-même d'autres définitions locales. La portée d'une définition est celle de l'élément la contenant. Ainsi, les définitions globales, situées immédiatement sous l'élément schema ont pour portée l'ensemble du schéma. On peut s'y référer dans tout le schéma par une simple indirection :

• pour les éléments ou les attributs, utiliser l'attribut ref,
• pour les types, utiliser l'attribut type,

et à chaque fois, lui donner pour valeur le nom de l'entité globale réutilisée. Les définitions globales sont donc réutilisables. Les définitions locales ont une portée limitée et ne sont pas réutilisables. La limitation de la portée est utile lorsque des conflits de noms peuvent survenir. Typiquement, les attributs sont souvent définis localement plutôt que globalement.

Remarque : il est impossible de réutiliser une définition locale. C'est une limitation du langage des schémas. Une construction plus régulière aurait permis de factoriser à tous les niveaux, et pas seulement au niveau global. Cf. la construction let x = … in … des langages fonctionnels ML.

Exemple

<xs:schema ...>
  <!-- Définitions globales -->
  <xs:element name="classe" type="Personne"/> <!-- Référence à la définition globale du type-->
  <xs:complexType name="Personne">
    ...
  </xs:complexType>
  ...
      <xs:element ref="classe"/>  <!-- Référence à la définition globale de l'élément -->
  ...
</xs:schema>

Les définitions globales déclarent non seulement des éléments, des attributs et des types, mais aussi des groupes d'éléments, correspondant à des séquences, des ensembles ou des alternatives d'éléments (cf. infra, la définition d'un schéma), et des groupes d'attributs.

Exemple

<xs:schema ...>
  <!-- Définition globale d'un groupe d'éléments-->
  <xs:group name="collection">
    <xs:sequence>
      ... <!-- Séquence, ensemble ou alternative  -->
    </xs:sequence>
  </xs:group>

  <!-- Définition globale d'un groupe d'attributs -->
  <xs:attributeGroup name="attributs">
    <xs:attribute name="attribut_1" ... />
    ... <!-- Autres attributs -->
  </xs:attributeGroup>


  ...
      <xs:group ref="collection"/>  <!-- Référence à la définition globale -->
      ...
      <xs:attributeGroup ref="attributs"/> <!-- Référence à la définition globale -->
  ...
</xs:schema>

Forme générale d'un document : élément racine ayant un contenu

<racine>contenu</racine>

Notation :

• ^* : répétition zéro ou plusieurs fois
• ^+ : répétition une ou plusieurs fois
• ? : optionnel
• . : séquence

contenu ::= attributs.(texte | éléments | mélange | vide)
attributs ::= attribut^*
attribut ::= (id = "texte")
texte ::= Chaîne de caractères alphanumériques
éléments ::= élement^+
élement ::= (<Balise>contenu</Balise) (remarque : <Balise></Balise> noté aussi <Balise/>) 
mélange ::= (éléments.texte)^+.éléments? | (texte.éléments)^+.texte?
vide ::= Chaîne vide

(Par la suite, on interprétera les termes à gauche suivant l'expression à droite.)

Un schéma permet de représenter la structure commune d'un ensemble de documents construits suivant la grammaire précédente.

Dans la suite, on suppose que l'espace de nommage associé aux schémas, soit "http://www.w3.org/2001/XMLSchema", a pour nom xs.

On décrit les constituants principaux d'un schéma :

• les éléments, qui ont un contenu typé,
• les attributs, qui ont une valeur typée,
• les types de valeur, des types simples, ou de contenu, soit des types simples, soit des types complexes.

Voici un résumé de la grammaire décrivant les types utilisés dans les schémas. Nous la détaillons ci-dessous.

type ::= typePrédéfini | typeUtilisateur
typeUtilisateur ::= typeSimple | typeComplexe
typeSimple ::= Restriction^+(typePrédéfini) 
              | Liste(typeSimple) 
              | Union(typeSimple^+)
typeComplexe ::= typeContenuSimple | typeContenuComplexe
typeContenuSimple ::= Extension(attribut^+, typeSimple)) 
                    | Restriction(typeContenuSimple)
typeContenuComplexe ::= ElementVide(attribut^*)
                      | groupementElements
                      | contenuMixte      
                      | dérivation                  
groupementElements ::= séquence | ensemble | alternative
séquence ::= Séquence((élément | alternative)^+) 
ensemble ::= Ensemble(élément^+) 
alternative ::= Alternative((élement | groupementElements)^+)