Première étape : le modèle générique

Dans cette première étape, on ne retient que les deux premiers types de structures de données : [1] et [2]. Reconnaissant, malgré la distance entre ces deux types, qu'on va devoir écrire deux fois le même "genre" de modules, on peut souhaiter paramétrer un module générique unique puis instancier chaque cas avec ses particularités.

1. Les structures de données

2. Les contextes d'utilisation

3. Les traitements simples

4. Les traitements complexes

3. Les traitements simples

On peut maintenant construire les procédures génériques Lire_Objet et Ecrire_Objet :

(def Lire ()
   ("* Lire_Objet: M:IN integer; {val((OBJ))}:OUT type_element
     100   {lect ((RANG)
                  (def RGLOG () ("M"))
                  (def VAL   () ("{val((OBJ))}")))}
           RETURN"))
(def Ecrire ()
   ("* Ecrire_Objet: M:IN integer; {val((OBJ))}:IN type_element
     110   {ecr ((RANG)
                 (def RGLOG () ("M"))
                 (def VAL   () ("{val((OBJ))}")))}
           RETURN"))

Lire et Ecrire sont paramétrés par  :

• un texte RANG, qui doit présenter respectivement les propriétés lect et ecr,
• un texte OBJ, qui doit présenter la propriété val.

Le choix des noms de textes permet de facilement générer le texte final :

Cas [1]
(Lire   ((ctx1)))
(Ecrire ((ctx1)))

Cas [2]
(Lire   ((ctx2)))
(Ecrire ((ctx2)))

Dans les deux cas, on utilise le schéma Lire ou Ecrire en fournissant le contexte de décompilation, ctx1 ou ctx2.

On obtient (en annexe, on donne les étapes de cette évaluation) :

Cas [1]

* Lire_Objet: M:IN integer; X1:OUT type_element
100   H=RG1(M)
      SEARCH=1,H:X1
      RETURN
* Ecrire_Objet: M:IN integer; X1:IN type_element
110   H=RG1(M)
      MODIF=1,H:X1
      RETURN

Cas [2]

* Lire_Objet: M:IN integer; X2:OUT type_element
100   X2=TX2(M)
      RETURN
* Ecrire_Objet: M:IN integer; X2:IN type_element
110   TX2(M)=X2
      RETURN