Balise

Balise [AIS 96] est un environnement de développement d’applications do-cumentaires basées sur les standards SGML et XML. Cet environnement comprend un langage de programmation. Il est développé par la société AIS Berger−Levrault. Le langage Balise permet de manipuler la représentation ar-borescente des documents à travers des fonctions d’accès et de modification de la structure. Ces fonctions permettent soit de modifier la structure d’un

document existant, comme montré ci−dessous, soit de générer un nouveau do-cument en insérant les éléments créés dans une nouvelle arborescence comme le montre le deuxième exemple. Les instructions de contrôle du langage Balise sont les mêmes que celles d’un langage de programmation impératif classique (Pascal, C).

Ce langage fournit également des primitives de création et de copie d’élé-ments. Ces fonctions permettent de programmer un grand nombre de transfor-mations. Une fonction transformant des documents mail en message s’écrit :

function Mail2Message (doc) {

var elem = root (doc); // accès à l’élément racine changeGI (elem, "message"); // change le type du noeud // mail

var reg = attr ("ref", elem); // accès à l’attribut ref var newelem = Move (soc, "référence", ref);

insertSubTree (elem, 1, newelem); //cree l’élément ref elem = firstChild (elem); // accès à l’élément date addAttr (root(doc), date, content (elem));

elem = rightSibling (elem); // accès à l’élément recipient

changeGI (elem, "destinataire");

elem = rightSibling (elem); // accès à l’élément sender changeGI (elem, "expéditeur");

CutSubTree (elem); // déplace l’élément // expéditeur

insertSubTree (root(doc), 1, elem);

elem = rightSibling (elem); // accès à l’élément title changeGI (elem, "titre");

var body = rightSibling (elem); //accès à l’élément textbody

cutSubtree (elem); // déconnecte le nœud titre insertSubtree (body, 0, elem); // insère titre avant le // 1er fils de body

changeGI (body, "contenu"); // change body en contenu elem = Node (doc, "corps"); // crée le noeud corps insertSubtree (body, 1, elem); // insère corps après le // 1er fils de contenu var elpar = rightSibling (body);

while (elpar != nothing) { // parcourt les éléments p cutSubtree (elpar); // déplace chaque p dans insertSubtree (elpar, −1, body) // l’élément corps changeGI (elpar, Para);

for elem in searchElemNodes (elpar, "cite") {

// génère les guillemets changeContent (elem, format ("«%s»", content(elem))); flattenSubTree (elem); // retire les éléments cite }

} }

L’algorithme utilisé dans cet exemple parcourt le document source en appli-quant des traitements spécifiques aux éléments rencontrés. Ces traitements permettent d’implémenter les six aspects énoncés dans l’exemple. La nature

impérative du langage Balise impose une description complète de la transfor-mation. En particulier, pour ignorer les éléments cite, il faut explicitement les retirer (fonction flattenSubTree) ou rechercher leur contenu d’une manière spécifique.

Balise permet également de spécifier des transformations dirigées par la source. Pour cela, Balise permet d’associer des traitements aux événements de l’analyseur XML intégré. Des traitements sont associés aux événements de début et de fin pour les éléments, des clauses contextuelles peuvent être ajou-tées à cette définition (par exemple : début des éléments de type p se trouvant à l’intérieur d’un élément textbody). Pour limiter l’occupation de la mémoire lors de la transformation, le contexte est restreint aux ancêtres et aux voisins pré-cédents de l’élément concerné par l’événement. Nous donnons ci−dessous un extrait d’une transformation dirigée par la source exprimée dans le langage Ba-lise. Cette spécification utilise le style déclaratif pour associer des traitements aux événements de l’analyseur, ces traitements utilisant un langage procédural pour générer l’arborescence du document cible.

//initialisation main {

eventLookAhead(true); }

// transformation de l’élément mail element mail {

on start {

changeGI ("message"); var root = Elem ("mail"); }

}

// transformation de l’élément date en attribut element date {

on start {

var ladate = content (currentNode()); AddAttr (root, "date", ladate);

} }

// transformation de l’élément recipient element recipient {

on start {

changeGI ("destinataire");

// insère expéditeur comme premier fils de body cutTree (currentNode());

insertSubTree (root, 0, currentNode()); }

}

// transformation de l’élément sender element sender {

on start {

changeGI ("expéditeur");

// insère expéditeur comme premier fils de body cutTree (currentNode());

insertSubTree (root, 0, currentNode()); }

}

element suject { on start {

changeGI ("titre"); // crée l’élément contenu

// et l’insère comme dernier fils de body var elcontenu = Node ("contenu");

insertSubTree (root, −1, elcontenu); // insere titre dans contenu

insertSubTree (elcontenu, 0, currentNode()); // crée l’élément corps

// et l’insère comme dernier fils de contenu var elcorps = Node ("corps");

insertSubTree (elcontenu, −1, elcorps); }

}

// transformation des éléments para element p {

on end {

changeGI ("para");

cutTree (currentNode());

insertSubTree (elcontenu, −1, currentNode()); }

// élimination des éléments cite, génération des guillemets element cite {

on begin {

changeContent (currentNode(), format ("«%s»", content(currentNode())));

flattenSubTree(); }

}

Balise, avec l’approche dirigée par la source, se différencie du langage de script d’IDM par le fait que la génération ne se fait plus de manière linéaire, mais par la construction d’une structure arborescente du document. Cette approche fournit une souplesse accrue dans la façon de placer les éléments cibles. De plus elle n’impose pas la génération des balises de début et de fin d’élément. En contrepartie, elle ne permet de produire que des documents structurés au format SGML ou XML. De plus, ce mode de génération nécessite la représentation en mémoire de l’arbre du document cible qui peut être importante.

La combinaison de la transformation dirigée par la source avec la modifica-tion de la structure du document source peut produire des effets de bord néga-tifs : le traitement d’un événement peut entraîner des modifications dans la structure du document et conduire à l’omission de sous−arbres entiers lors de la transformation. C’est pour éviter ces effets de bord que Balise permet de du-pliquer préalablement la structure du document source (avec la fonction DumpSubTree) pour obtenir une instance servant à la génération du document, l’autre étant modifiée par les traitements de ces événements.

En conclusion, comme pour IDM, la composante impérative du langage Balise nécessite une connaissance de la programmation. Par contre, son approche dé-clarative permet la spécification de transformations plus complexes que celles

d’IDM grâce à la possibilité de sélectionner des ancêtres lors de l’association d’une règle à un type d’élément et à la génération arborescente.