Il a été vu au chapitre sur la syntaxe que les éléments d'un document XML sont reliés par des liens de parenté. Un élément est le parent d'un autre élément s'il le contient. Ces relations de parenté constituent l'arbre des éléments. Cette structure d'arbre est étendue à tous les constituants d'un document pour former l'arbre du document qui inclut les éléments 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 nœuds de différentes sortes qui correspondent aux différents constituants du document. Ces sortes de nœuds sont les suivantes.

Afin d'illustrer ces sortes de nœuds, voici ci-dessous un document XML très simple ainsi que son arbre.

<?xml version="1.0" encoding="iso-8859-1"?>
<!-- Time-stamp: "tree.xml  14 Feb 2008 09:29:00" -->
<?xml-stylesheet href="tree.xsl" type="text/xsl"?> 
<list type="technical">
 <item key="id001" lang="fr">
   XML &amp; Co
 </item>
 <item>
   <!-- Un commentaire inutile -->
   Du texte
 </item>
 et encore du texte à la fin.
</list>

Dans la figure ci-dessous, chaque nœud de l'arbre est représenté par un rectangle contenant trois informations. La première information est la sorte du nœud, la deuxième est le nom éventuel du nœud et la troisième est la valeur textuelle du nœud.

Figure 6.1. Arbre d'un document XML

Tous les nœuds d'un document XML sont classés suivant un ordre appelé ordre du document. Pour les éléments, cet ordre est celui du parcours préfixe de l'arbre du document. Ceci correspond à l'ordre des balises ouvrantes dans le document. Un élément est toujours placé après ses ancêtres et ses frères gauches et avant ses enfants et ses frères droits. Les attributs et les déclarations d'espaces de noms sont placés juste après leur élément et avant tout autre élément. Les déclarations d'espaces de noms sont placées avant les attributs. L'ordre relatif des déclarations 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 opérateurs XPath << et >>. Il intervient aussi de façon implicite dans l'évaluation de certains opérateurs, comme par exemple /, qui ordonnent les nœuds de leur résultat suivant cet ordre.

Les expressions XPath manipulent des valeurs qui sont soit des nœuds de l'arbre d'un document XML, soit des valeurs atomiques. Les principales valeurs atomiques sont les entiers, les nombres flottants et les chaînes de caractères. La donnée universelle de XPath est la liste de valeurs. Ces listes ne peuvent pas être imbriquées. 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 ordonnées et chaque valeur a une position allant de 1 (et non pas 0) pour la première valeur à la longueur de la liste pour la dernière valeur.

Les listes peuvent être construites explicitement avec l'opérateur XPath ',' (virgule). L'opérateur XSLT xsl:sequence permet également de construire explicitement des séquences. Beaucoup d'opérateurs et de fonctions XPath retournent des listes comme valeurs.

Toute valeur est considérée par XPath comme une liste de longueur 1. Inversement, toute liste de longueur 1 est assimilée à l'unique valeur qu'elle contient.

Les valeurs atomiques comprennent les chaînes de caractères, les entiers, les nombres flottants et tous les types de base des schémas XML. Les types pour les valeurs atomiques sont les suivants.

L'évaluation d'une expression XPath se fait dans un contexte qui est fourni par le langage hôte. Le contexte se décompose en le contexte statique et le contexte dynamique. Cette distinction prend du sens lorsque les programmes du langage hôte sont susceptibles d'être compilé. Le contexte statique comprend tout ce qui peut être déterminé par une analyse statique du programme hôte. Tout ce qui dépend du document fait, au contraire, partie du contexte dynamique.

Les expressions XPath sont beaucoup utilisées 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 déterminer beaucoup d'information.

Les expressions de cheminement permettent de se déplacer dans l'arbre d'un document en passant d'un nœud à d'autres nœuds. Une expression de cheminement a la forme axe::type. Elle retourne l'ensemble des nœuds du type type qui sont reliés au nœud courant par la relation axe. Parmi tous les nœuds, l'axe effectue une première sélection basée sur la position des nœuds dans l'arbre par rapport au nœud courant. Le type raffine ensuite cette sélection en se basant sur le type et le nom des nœuds. La sélection peut encore être affinée par des filtres. Si l'objet courant n'est pas un nœud, l'évaluation d'une telle expression provoque une erreur. Les différents types correspondent aux différents nœuds pouvant apparaître dans l'arbre d'un document. Les relations entre le nœud courant et les nœuds retournés sont appelées axes dans la terminologie XML.

L'axe par défaut est l'axe child qui sélectionne les enfants du nœud courant.

6.2.1.1. Axes

Chacun des axes donne une relation qui relie les nœuds sélectionnés par rapport au nœud courant. Les axes qu'il est possible d'utiliser dans les expressions XPath sont les suivants.

self

Le nœud lui-même (égalité)

child

Fils direct

parent

Parent

attribute

Attribut du nœud

descendant

Descendant strict

descendant-or-self

Descendant ou le nœud lui-même

ancestor

Ancêtre strict

ancestor-or-self

Ancêtre ou le nœud lui-même

preceding-sibling

Frère gauche (fils du même parent)

following-sibling

Frère droit (fils du même parent)

preceding

À gauche

following

À droite

namespace

Espace de noms du nœud

L'axe namespace est un héritage de XPath 1.0 qui doit être considéré comme obsolète. Il est conseillé d'utiliser les fonctions XPath pour accéder aux espaces de noms d'un nœud.

Les axes self, parent, child, preceding-sibling et following-sibling permettent de sélectionner le nœud lui-même et les nœuds proches comme le montre la figure ci-dessous.

Figure 6.2. Nœuds proches

Les cinq axes self, ancestor, preceding, descendant et following partitionnent l'ensemble de tous les éléments du document en cinq parties comme le montre la figure ci-dessous.

Figure 6.3. Partitionnement des éléments selon les cinq axes

Les filtres permettent de sélectionner dans une liste les objets qui satisfont une condition. Ils apparaissent beaucoup dans les expressions de chemin pour restreindre le résultat d'une expression de cheminement. Nous donnons ici quelques exemples d'utilisation de ces filtres.

L'opérateur '/' permet de composer des expressions de cheminement pour créer de véritables chemins dans un arbre XML. C'est un des opérateurs clé de XPath. Sa sémantique est proche du même opérateur '/' des shell Unix mais il est plus général et pas toujours facile à appréhender

Une expression de la forme expr1/expr2 est évaluée de la façon suivante. L'expression expr1 est d'abord évaluée pour donner une liste d'objets. Pour chacun des objets de cette liste, l'expression expr2 est évaluée en modifiant dynamiquement le focus de la façon suivante. L'objet courant est fixé à l'objet choisi dans la liste, la position dans le contexte est fixée la position de cet objet dans la liste et la taille du contexte est également fixée à la taille de la liste. Les listes retournées par chacune des évaluations de expr2, sont fusionnées pour donner une liste de nœuds dans l'ordre du document et avec au plus une occurrence de chaque nœud dans la liste. Cette liste est alors le résultat 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, après l'évaluation, sa valeur initiale.

Supposons, par exemple, que l'expression expr1 retourne la liste (n1, n2, n3) formée de trois nœuds. L'expression expr2 est donc évaluée trois fois. Elle est évaluée une première fois en prenant le nœud courant égal à n1, la position du contexte égale à 1 et la taille du contexte égale à 3. Elle est évaluée une deuxième fois en prenant le nœud courant égal à n2, la position du contexte égale à 2 et la taille du contexte égale à 3. Elle est évaluée une troisième et dernière fois en prenant le nœud 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 résultat de l'évaluation est la liste (n0, n1, n2, n4, n5, n6).

L'opérateur '/' peut être cascadé et il est associatif à gauche. Une expression de la forme expr1/expr2/expr3 est implicitement parenthésée (expr1/expr2)/expr3. Ce parenthésage est très souvent inutile car l'opérateur '/' est associatif à l'exception de quelques cas pathologiques.

L'opérateur '/' peut aussi être employé dans des expressions de la forme /expr2 qui sont l'analogue des chemins absolus dans les systèmes de fichiers.

Une expression de la forme /expr2 est évaluée de la façon suivante. L'expression expr2 est évaluée en ayant, au préalable, fixé le nœud courant à la racine de l'arbre contenant le nœud 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 paramètre.

Le nœud courant appartient très souvent à l'arbre d'un document XML. Dans ce cas, la racine de cet arbre est un nœud de la sorte document node. Il est également possible que le nœud courant appartienne à un fragment de document et que la racine de cet arbre soit un nœud 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 complètement absolues car la racine choisie dépend du nœud courant. La racine choisie est celle de l'arbre contenant le nœud courant.

Les opérateurs sur les ensembles réalisent les opérations d'union, d'intersection et de différences sur les ensembles de nœuds représentés par des listes classées dans l'ordre du document. L'opérateur d'union est très souvent utilisé alors que les deux autres opérateurs le sont plus rarement. Ces opérateurs fonctionnent uniquement avec des ensembles de nœuds. Ils ne fonctionnent pas avec des listes contenant des valeurs atomiques.

L'opérateur d'union est noté par le mot clé union ou par le caractère '|'. Les opérateurs d'intersection et de différence sont notés respectivement par les mots clé intersect et except.

Bien que les listes manipulées par XPath peuvent contenir des nœuds et des valeurs atomiques, les opérations ensemblistes ne peuvent être utilisées que sur des listes contenant uniquement des nœuds.

Le type booléen contient les deux valeurs true et false. Ces deux valeurs sont retournées par les fonctions true() et false() sans paramètre. Les parenthèses sont obligatoires car l'expression XPath true donne les éléments true enfants du nœud courant.

Les valeurs booléennes peuvent être manipulées à l'aide des opérateurs and et or et de la fonction not().

Les valeurs des autres types peuvent être converties explicitement en des valeurs booléennes par la fonction xsd:boolean. Elles sont aussi converties implicitement dès qu'une valeur booléenne est requise. C'est le cas, par exemple, des filtres et de la structure de contrôle if. Les règles qui s'appliquent alors sont les suivantes.

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 schémas XML.

Les chaînes de caractères XPath contiennent, comme les documents XML, des caractères Unicode.

Une chaîne littérale est délimitée par une paire d'apostrophes ''' ou une paire de guillemets '"'. Lorsqu'elle est délimitée par une paire d'apostrophes, les guillemets sont autorisés à l'intérieur et les apostrophes sont incluses en les doublant. Lorsqu'elle est, au contraire, délimitée par une paire de guillemes, les apostrophes sont autorisées à l'intérieur et les guillemets sont inclus en les doublant.

Les expressions XPath sont très souvent utilisées commme valeurs d'attributs d'un dialecte XML comme les schemas XML ou XSLT. Dans ce cas, les apostrophes ou les guillemets qui délimitent la valeur de l'attribut doivent être introduits avec les entités prédéfinies que cela soit comme délimiteur ou à l'intérieur d'une chaîne.

Il existe de nombreuses fonctions permettant de manipuler les chaînes de caractères. Dans les exemples ci-dessous, les chaînes apparaissant dans les valeurs des expressions sont écrites avec délimiteurs ''' bien que ceux-ci ne fassent pas partie des chaînes.

L'opérateur essentiel de construction de listes est ',' (virgule) qui permet de concaténer, 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 concaténer les résultats d'autres expressions. Contrairement aux opérateurs de chemins, l'opérateur ',' ne réordonne pas les éléments des listes et ne supprime pas les doublons. Le résultat de l'expression expr1,expr2 est la nouvelle liste formée des valeurs du résultat de expr1 suivis des valeurs du résultat l'expression expr2. Si une valeur apparaît dans les deux résultats, elle a plusieurs occurrences dans le résultat final. Par exemple, le résultat 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 assimilée à 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 crée pas d'ambiguïté car les listes XPath ne peuvent pas être imbriquées. Il n'y a pas de différence entre les deux expressions ((1),(2)) et (1,2).

L'opérateur to permet de créer une liste contenant une suite d'entiers consécutifs. L'expression n1 to n2 donne la liste n1,n1+1,n1+2,…,n2-1,n2 des entiers de n1 à n2 compris. Cet opérateur est surtout utile avec l'opérateur for pour itérer sur une liste d'entiers.

Un filtre permet de sélectionner dans une liste les objets qui satisfont une condition. Un filtre se présente comme une expression entre des crochets '[' et ']' placée après la liste à filtrer.

Une expression de la forme expr1[expr2] est évaluée de la façon suivante. L'expression expr1 est d'abord évaluée pour donner une liste l d'objets. Pour chaque objet o de la liste l, l'expression expr2 est évaluée en modifiant, au préalable, le focus de la manière suivante. L'objet courant est fixé à l'objet o, la position du contexte est fixée à la position de l'objet o dans la liste l et la taille du contexte est fixée à la taille de l. Le résultat de cette évaluation est ensuite converti en une valeur booléenne en utilisant les règles de conversion. Le résultat final de l'évaluation de expr1[expr2] est la liste des objets de l pour lesquels expr2 s'est évaluée en la valeur true. Les objets sélectionnés restent bien sûr dans l'ordre de la liste l. La liste résultat 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 contexte qui est retourné par '.' prend les valeurs successives 1, 2, 3, 4 et 5. Seules les valeurs paires satisfont la condition et sont conservées.

Les filtres sont beaucoup utilisés dans les expression de chemin pour sélectionner des nœuds.

Plusieurs conditions peuvent être combinées à l'aide des opérateurs booléens and et or. Les filtres peuvent aussi être enchaînés en les mettant l'un après l'autre.

Le second exemple montre que les filtres peuvent être enchaînés. Il ne donne pas le même résultat que le premier exemple car les positions retournées par la fonction position() du second filtre sont celles dans la liste obtenue après le premier filtre. Comme le premier enfant text a été supprimé, il y a un décalage d'une unité.

Il existe des fonctions XPath permettant de manipuler les listes.

Les opérateurs pour les valeurs atomiques sont les opérateurs 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 même type. L'ordre pour les entiers et les flottants est l'ordre naturel alors que l'ordre pour les chaînes de caractères est l'ordre lexicographique du dictionnaire. Cet ordre lexicographique prend en compte les collations.

Les opérateurs pour les valeurs atomiques sont les opérateurs =, !=, <, <=, > et >=. Ils permettent respectivement de tester l'égalité, la non-égalité, l'ordre strict et l'ordre large de deux valeurs de types quelconques.

L'opérateur is compare deux nœuds et retourne true s'il s'agit du même nœud. C'est donc plus un test d'identité que d'égalité. Il s'apparente plus à l'opéateur == de Java qu'à la méthode equals.

Les deux opérateurs << et >> permettent de tester si un nœud se trouve avant ou après un autre nœud dans l'ordre du document.

L'opérateur if permet d'effectuer un test. Sa syntaxe est la suivante.

if (test) then expr1 else expr2

La sémantique est celle de if dans tous les langages de programmation. L'expression test est évaluée et le résultat est converti en une valeur booléenne. Si cette valeur booléenne est true, l'expression expr1 est évaluée et le résultat est celui de l'expression globale. Sinon, l'expression expr2 est évaluée et le résultat est celui de l'expression globale.

La partie else expr2 est obligatoire et ne peut pas être omise. Lorsque cette seconde partie est inutile, on met simplement else ().

L'opérateur 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].

L'opérateur for permet de parcourir des listes pour construire une nouvelle liste. Il ne s'agit pas d'une structure de contrôle pour des itérations quelconques comme le for des langages C ou Java. Il s'apparente plus à l'opérateur map des langages fonctionnels comme Caml qui permet d'appliquer une fonction à chacun des objets d'une liste.

La syntaxe de l'opérateur for est la suivante.

for var in expr1 return expr2

L'évaluation d'une telle expression est réalisée de la façon suivante. L'expression expr1 est d'abord évaluée pour donner une liste de valeurs. Pour chacune de ces valeurs, celle-ci est affectée à la variable var et l'expression expr2 est évaluée. Le résultat global est la liste obtenue en concaténant les listes obtenues pour chacune des évaluations de l'expression expr2.

Le résultat de l'expression expr2 est une liste qui peut donc contribuer à plusieurs valeurs de la liste finale. Si, au contraire, ce résultat est la liste vide, il n'y a aucune contribution à la liste finale.

La variable var introduite par l'opérateur for est une variable muette. Sa portée est réduite à l'expression expr2 après le mot clé return. Aucune valeur ne peut lui être affectée directement.

Il est possible d'imbriquer plusieurs opérateurs for. Il y a d'ailleurs une syntaxe étendue qui permet une écriture concise de ces itérations imbriquées. 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 première syntaxe.

for var1 in expr1 return for  …  return for varN in exprN return expr0

L'opérateur some permet de vérifier qu'au moins un des objets d'une liste satisfait une condition. Sa syntaxe est la suivante.

some var in expr1 satisfies expr2

L'évaluation d'une telle expression est réalisée de la façon suivante. L'expression expr1 est d'abord évaluée pour donner une liste de valeurs. Pour chacune de ces valeurs, celle-ci est affectée à la variable var et l'expression expr2 est évaluée. Le résultat 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.

L'opérateur every permet de vérifier que tous les objets d'une liste satisfont une condition. Sa syntaxe est la suivante.

every var in expr1 satisfies expr2

L'évaluation d'une telle expression est réalisée de la façon suivante. L'expression expr1 est d'abord évaluée pour donner une liste de valeurs. Pour chacune de ces valeurs, celle-ci est affectée à la variable var et l'expression expr2 est évaluée. Le résultat 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.