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

2. Opérateurs de liste

syntaxe

atm ::= atm | lst-init | lst | tst
    lst-init ::= env rep
    lst      ::= ε | atm lst
    tst      ::= ε | sex tst

env ::= env | lst-env
    lst-env ::= ε | env lst-env

sémantique

opérateur lst-init

Il permet d'initialiser le parcours d'une liste d'environnements. Le champ d'environnement est un environnement prioritaire placé dans le contexte d'évaluation pour la construction de la liste des environnements à parcourir. Le champ de représentation est la représentation qui sera évaluée pour chaque nouvelle construction d'un contexte – pour la construction du contexte, voir l'opérateur lst-env.

opérateur lst

Il permet, à l'intérieur d'un opérateur lst-init, de spécifier une autre représentation à évaluer pour le parcours du reste de la liste d'environnements. La liste sera parcourue jusqu'à épuisement à l'intérieur de l'opérateur lst, et ne sera alors plus parcourue par l'opérateur lst-init, ou par d'autres opérateurs lst englobants.
Note : à l'entrée dans lst, on commence par avancer d'un rang dans la liste des environnements.

opérateur tst

Il permet de tester le nombre d'environnements restant dans la liste à parcourir, et de spécifier une certaine représentation à évaluer en fonction de ce nombre. La syntaxe est plus sévère qu'il n'y paraît. La syntaxe d'emploi correcte, à respecter mais non contrôlée, est celle du selectq de Lisp (le 'case of' de Pascal).

forme entrée :
   (tst
      (0 (rep ...))
      (1 (rep ...))
       ...
      (T (rep ...)))

forme Lisp :
   (selectq <nombre d'environnements restant dans la liste>
      (0 (rep ...))
      (1 (rep ...))
       ...
      (T (rep ...)))

Note : dans le nombre d'environnements restants, on compte l'environnement dans lequel on est en train d'évaluer.

opérateur lst-env

Il permet de définir, "proprement", une liste d'environnements. Le parcours de liste s'effectue en deux étapes :

• première étape : initialisation.
  On construit le contexte formé de l'environnement de lst-init puis du contexte courant d'évaluation. Le premier environnement rencontré dans le contexte évalué est alors l'environnement de liste :
  • s'il s'agit d'un opérateur lst-env, on aura bien une liste d'environnements ;
  • s'il s'agit d'un environnement ordinaire, cet environnement sera vu comme une liste d'environnements composée d'un seul élément.
  Cette possibilité permet de préserver la compatibilité entre des textes qui utiliseraient un certain texte txt qui n'était pas un texte de liste, et des textes qui utilisent ce même texte txt qui a été transformé en un texte de liste.
  
  
• deuxième étape : parcours.
  Pour chaque élément de la liste d'environnements :
  • on évalue cet environnement dans le contexte ctx auquel est attachée la liste d'environnements ;
  • on évalue la représentation de lst-init ou de lst dans le contexte formé de cet environnement évalué et du contexte ctx ;
  • on avance d'un pas dans la liste et on réitère le procédé, jusqu'à épuisement de la liste.

exemple

lst-param : le texte est paramétré par une liste de paramètres l-param ; c'est la décompilation des indices de tableau.

def lst-param
 = (lst-init
      (env (l-param))
      (rep "[" (nom) (lst "," (nom)) "]")))

lst-tab : le texte est paramétré par une liste de déclarations l-tab ; c'est la décompilation des déclarations de variables, dans une syntaxe du type de la syntaxe de Pascal.

def lst-tab
 = "VAR" "^M"
   (lst-init
      (env (l-tab))
      (rep "   " (nom) ":" (type) ";" "^M"))

decla : le texte est défini par trois variables "X", "Y" et "Z", elles-mêmes définies comme des tableaux – "Z" est un tableau sans indice : le texte l-param a un environnement vide.

(def decla
   (def l-tab
      (lst-env
         (env
            (def nom
               (def l-param
                  (lst-env
                     (def nom = "a"))
                     (def nom = "b"))
                     (def nom = "c"))))
               = "X" (lst-param))
            (def type
               = "tab_X"))
         (env
            (def nom
               (def l-param
                  (lst-env
                     (def nom = "u"))
                     (def nom = "v"))))
               = "Y" (lst-param))
            (def type
               = "tab_Y"))
         (env
            (def nom
               (def l-param)
               = "Z" (lst-param))
            (def type
               = "tab_Z"))))
   = (lst-tab))

On peut ainsi représenter l'arbre abstrait associé à la définition de ces trois variables :

La forme évaluée de l'utilisation du texte decla est alors :

VAR
   X[a,b,c]:tab_X;
   Y[u,v]:tab_Y;
   Z:tab_Z;