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

4. Les traitements complexes

Il s'agit de définir les trois autres procédures : Inserer_Objet, Supprimer_Objet et Rechercher_Objet. Pour ne pas allonger démesurément l'exemple, on ne traitera ici que la dernière, Rechercher_Objet.

Le traitement étant plus complexe, on introduit un intermédiaire dans la définition du texte : le texte schema, qui donne le schéma de décompilation, paramétré localement par des textes :

(def Rechercher
   ((def schema
       ...représentation...)
    ...paramètres locaux...))

Pour utiliser le texte, il faut alors accéder à la valeur schema du texte Rechercher :

(schema ((Rechercher)))

Le schéma

Le schéma de recherche est le suivant (sans s'effrayer de la densité de GOTO qui apparaissent) :

(def schema
   ((def fin ()
       ("MEN={CR}
         RETURN")))
   ("140   {CLE}=0
     145   IF {CLE}={borne((RANG))} GOTO 147
           {CLE}={CLE}+1
           {lect ((RANG)
                  (def RGLOG () ("{CLE}"))
                  (def VAL   () ("{aux((OBJ))}")))}
           IF {test((aux((OBJ))))}<{test((val((OBJ))))} GOTO 145
           IF {test((aux((OBJ))))}>{test((val((OBJ))))} GOTO 148
           {fin ((def CR () ("0")))}
     147   {CLE}={CLE}+1
     148   {fin ((def CR () ("1")))}"))

dans schema :

• on utilise le texte local fin :
  • paramétré par CR,
  • utilisé avec, pour CR, la valeur "0" ou "1".
• les paramètres sont :
  • CLE : c'est le rang logique utilisé pour l'itération ;
  • RANG : qui offre les propriétés :
    • borne : borne supérieure des clés,
    • lect : lecture, paramétrée comme précédemment par RGLOG et VAL.
  • OBJ : qui offre les propriétés :
    • val : la variable courante du type des éléments,
    • aux : la variable auxiliaire de ce type,
    • val et aux offrant eux-mêmes la nouvelle propriété : test.

Les contextes

On reprend donc légèrement la définition du contexte ctx1 :

(def ctx1
   ((def NOM () ("1"))
    (def RANG
       ((def borne () ("LM1"))
        ...))
    (def OBJ
       ((def val
           ((def test () ("X1C")))
           ("X1"))
        (def aux
           ((def test () ("Y1C")))
           ("Y1"))
       ))))

Pour ctx2, on définit :

(def borne () ("LM2"))

et la valeur de test étant, par définition, la valeur totale :

(def val
   ((def test () ("{val}")))
   ("X2"))

et de même pour aux.

Enfin, on reprend la définition de Rechercher :
le paramètre CLE est pris, par défaut, égal à "M".

(def Rechercher
   ((def schema ...)
    (def CLE () ("M"))))

L'utilisation du texte

En se plaçant dans le contexte ctx1 :

(schema
   ((ctx1)
    (Rechercher)))

on obtient (...) le texte attendu :

140   M=0
145   IF M=LM1 GOTO 147
      M=M+1
      H=RG1(M)
      SEARCH=1,H:Y1
      IF Y1C<X1C GOTO 145
      IF Y1C>X1C GOTO 148
      MEN=0
      RETURN
147   M=M+1
148   MEN=1
      RETURN

Dans le contexte ctx2, on a l'utilisation similaire :

(schema
   ((ctx2)
    (Rechercher)))