On illustre la démarche par un exemple.
2. La syntaxe abstraite et les schémas de décompilation
3. La représentation textuelle
4. La concentration des variables
5. La concentration des propriétés
En fait dans le choix précédent de représentation on reste encore trop près du langage et de ses spécificités : ici on sait que dans le langage on représente de la même façon une variable utilisée soit pour accéder à sa valeur soit pour en affecter la valeur.
Le problème des répétitions dans le texte n'est pas encore pleinement résolu, mais les répétitions sont maintenant plus diffuses. Par exemple une déclaration de variable utilise toujours les propriétés nom et typ de la variable déclarée : l'affectation ne s'intéresse pas tant au nom d'une variable qu'à sa possible propriété de se voir affecter une valeur, etc.
Figure 6.a : grammaire
On définit donc un modèle pour les variables :
(def var
((def lect () ((NOM)))
(def ecr () ((NOM)))
(def init () ((INIT)))))
Le texte var :
- est paramétré par trois textes : NOM, TYP, INIT,
- définit pour les variables les propriétés : lect, ecr, init.
Figure 6.a : grammaire [ << masquer ]
(def pgme ()
((PGME-DECLA)
(PGME-INSTR)))
(def pgme-decla ()
((lst-init ((DECLA*))
("VAR " (rep (DECLA) (lst (DECLA)))))))
(def pgme-instr ()
((lst-init ((INSTR*))
((INSTR)))))
(def decla ()
((NOM((VAR))) ":" (TYP((VAR))) "^M"))
(def affect ()
((NOM) ":=" (EXP) "^M"))
(def affiche ()
("write(" (EXP) ")" "^M"))
(def cond ()
("if " (EXP-COND) "^M"
(THEN-CLAUSE)
(ELSE-CLAUSE)
"endif" "^M"))
(def exp-egal ()
((EXP1) "=" (EXP2)))
(def exp-diff ()
((EXP1) "<>" (EXP2)))
(def then-clause ()
("then" "^M"
(lst-init ((INSTR*))
(" " (rep (INSTR) (lst (INSTR)))))))
(def else-clause ()
("else" "^M"
(lst-init ((INSTR*))
(" " (rep (INSTR) (lst (INSTR)))))))
(def var
((def lect () ((NOM)))
(def ecr () ((NOM)))
(def init () ((INIT)))))
Figure 6.b : arbre syntaxique
Chaque variable est alors déclarée en référence à ce modèle, et les opérateurs de la grammaire peuvent exploiter ce point – ils savent d'une part quelles sont les propriétés des « variables », ils savent d'autre part quels paramètres elles ont définis à leur déclaration.
Par exemple :
(def VAR-x
((def NOM () ("x"))
(def TYP () ("integer"))
(def INIT () ("0"))
(var)))
(def INSTR
((def VAR ((var-x)) ((ecr)))
(def EXP ((var-y)) ((lect))))
((affect)))
La variable "x" : VAR-x est construite sur le modèle var.
A l'utilisation de affect, on utilise les propriétés des variables :
- la propriété d'écriture ecr de la variable VAR-x,
- la propriété de lecture lect de la variable VAR-y.
Figure 6.b : arbre syntaxique [ << masquer ]
(def VAR-x
((def NOM () ("x"))
(def TYP () ("integer"))
(def INIT () ("0"))
(var)))
(def VAR-y
((def NOM () ("y"))
(def TYP () ("real"))
(def INIT () ("1.0"))
(var)))
(def PGME
((def PGME-DECLA
((def DECLA*
(lst-env
((def DECLA
((def VAR ((VAR-x))))
((decla))))
(def DECLA
((def VAR ((VAR-y))))
((decla)))))))
((pgme-decla)))
(def PGME-INSTR
((def INSTR*
(lst-env
((def INSTR
((def VAR ((VAR-x)) ((ecr)))
(def EXP ((VAR-x)) ((init))))
((affect))))
(def INSTR
((def VAR ((VAR-y)) ((ecr)))
(def EXP ((VAR-y)) ((init))))
((affect))))
(def INSTR
((def EXP-COND
((def EXP1 ((VAR-x)) ((lect)))
(def EXP2 ((VAR-y)) ((lect))))
((exp-egal)))
(def THEN-CLAUSE
((def INSTR*
(lst-env
((def INSTR
((def EXP () ("'Ok'")))
((affiche)))))))
((then-clause)))
(def ELSE-CLAUSE
((def INSTR*
(lst-env
((def INSTR
((def VAR ((VAR-x)) ((ecr)))
(def EXP ((VAR-y)) ((lect))))
((affect))))
(def INSTR
((def EXP () ("'Erreur'")))
((affiche)))))))
((else-clause))))
((cond))))
(def INSTR
((def EXP () ("'fin'")))
((affiche)))))))
((pgme-instr))))
((pgme)))