La syntaxe complétée

On présente plusieurs opérateurs qu'on ajoute à la syntaxe concrète : on construit alors la syntaxe complétée, qui à son tour pourra être complétée par de nouvelles définitions :

• l'opérateur fct : il simplifie l'insertion d'une expression Lisp ;
• les opérateurs lst-init, lst, tst, lst-env : ils permettent la manipulation de listes de textes ;
• les opérateurs lst2-init, lst2, tst2, atm1, atm2 : ils permettent le parcours simultané de deux listes de textes ;
• les opérateurs deft, reft, uset : ils servent à typer les textes, à leur définition et à leur emploi.

1. Opérateur de S-expression simple

2. Opérateurs de liste

3. Opérateurs de listes doubles

4. Opérateurs de typage des textes

5. Résumé : la syntaxe complétée

3. Opérateurs de listes doubles

syntaxe

atm ::= atm | lst2-init | lst2 | tst2 | atm1 | atm2
    lst2-init ::= env env env rep
    lst2      ::= ε | atm lst2
    tst2      ::= ε | sex tst2
    atm1      ::= ε | atm atm1
    atm2      ::= ε | atm atm2

sémantique

opérateur lst2-init

Il permet le parcours simultané de deux listes :

• le premier champ d'environnement définit la première liste d'environnements ;
• le deuxième définit la deuxième liste ;
• le troisième définit les cas d'erreur ; il doit nécessairement contenir la définition des textes :
  • miss1 : on a épuisé la première liste, sans avoir épuisé la deuxième ;
  • miss2 : on a épuisé la deuxième liste, sans avoir épuisé la première.
  De plus, il sert d'environnement local pour l'évaluation des représentations : les définitions présentes dans cet environnement pourront donc être utilisées dans le champ rep.
• Le champ rep de représentation est, comme pour lst-init, la représentation qui sera évaluée pour chaque paire d'environnements lors du parcours des listes.

opérateur lst2

Il se définit comme lst, mais en parcourant les deux listes d'environnements.

opérateur tst2

Il se définit comme tst, le test portant sur la première liste.

opérateur atm1

Il permet d'exprimer, dans une représentation, qu'on désire voir évaluer ce qui suit dans le contexte construit avec la première liste d'environnements. Les atomes atm qui n'apparaissent pas sous atm1 (ou atm2) sont évalués dans le contexte de départ.

opérateur atm2

C'est le symétrique de atm1, avec la deuxième liste.

exemple

On définit le texte affiche, qui permet l'affichage des indices d'un tableau "A". Pour cet affichage, on contrôle le type de chacun des indices utilisés par rapport au type déclaré.
Le paramètre l-int fait référence à la liste des types déclarés.
Le paramètre l-ind fait référence à la liste des types utilisés.
Dans l'environnement local, on définit :
- les deux textes nécessaires miss1 et miss2,
- deux textes auxiliaires test et erreur.

(def affiche
 = "A" "["
   (lst2-init
      (env (l-int))
      (env (l-ind))
      (env
         (def test
            = (atm2 (exp))
              (fct unless (= (atm1 (type))
                             (atm2 (type)))
                   (rep "(erreur de type: " (atm1 (type)) ")")))
         (def miss1
            (def occ = (exp))
            = "(trop de parametres)" (erreur))
         (def miss2
            (def occ = (type))
            = "(trop de parametres)" (erreur))
         (def erreur
            = (occ) (lst "," (occ))))
      = (test) (lst2 "," (test)) "]")

On remarque que pour erreur on n'utilise plus l'opérateur lst2 mais l'opérateur lst : l'évaluation de lst2-init ou de lst2 garantit que, si l'on épuise une des listes et non l'autre, alors on se retrouve "à l'intérieur" d'une évaluation virtuelle de l'opérateur lst-init où la liste parcourue est la liste qu'on n'a pas encore épuisée, à la hauteur où on est dans cette liste au moment où l'erreur est détectée.

On définit la liste l-int des types des indices, et le texte decla de déclaration de la variable "A".

(def l-int
   (lst-env
      (env (def type = "jour"))
      (env (def type = "1..31"))))

(def decla
 = "A : ARRAY "
   (lst-init
      (env (l-int))
      (rep "[" (type) (lst "," (type)) "]"))
   " OF horaire;")

On définit la liste l-ind des expressions exp et types type des indices utilisés.

(def l-ind
   (lst-env
      (env (def exp  = "dimanche")
           (def type = "jour"))
      (env (def exp  = "20")
           (def type = "1..31"))))

On représente l'évaluation des textes decla et affiche, en tenant compte de toutes les déclarations faites jusqu'ici.

(use decla) :
   A : ARRAY [jour,1..31] OF horaire;

(use affiche) :
   A[dimanche,20]

On présente divers cas d'utilisation de affiche, en simplifiant la présentation. La colonne de gauche montre ce qu'on s'attend à obtenir, considérant qu'on donne, à chaque ligne, une nouvelle définition de l-ind. La colonne de droite montre ce qu'on obtient à l'utilisation du texte affiche.

On notera que, dans tous les cas d'erreur, il n'est indiqué qu'un message d'avertissement : l'évaluation de affiche signale les cas d'erreur, mais ne le refuse pas.