afficher >><< masquer ]
SAMPI - Editeur structuré
1. Le Problème et la Proposition
2. Le Langage Primitif de Représentation Textuelle
2.1. Présentation de la Syntaxe Concrète
2.2. Notations
2.3. Exemple de structuration des données
2.4. Exemple de structuration des traitements
2.4.1. La pile
2.4.11.1. Généricité en LTR3
2.4.11.2. La forme générique de la pile
2.4.11.3. Les deux instanciations
2.4.11.4. Conclusion
2.4.11.5. La représentation « textuelle »
2.4.2. Les lecteurs-écrivains
2.4.3. La racine carrée
2.5. Exemple de structurations connexes
3. Le Langage Complété pour la Structuration des Textes
3.1. Présentation de la Syntaxe Complétée
3.2. Etude quantitative de l'évolution des programmes
3.3. L'édition syntaxique
3.4. étude de cas : le langage LTR3 et l'atelier ENTREPRISE
4. L'Enrichissement du Langage par de Nouveaux Concepts
4.1. Présentation de la Syntaxe Abstraite
4.2. Les difficultés
4.3. Compléter la Syntaxe
5. La Formalisation des Solutions Techniques
5.1. L'évaluation fonctionnelle
5.2. La structuration par les objets
5.3. Modèle sémantique comparé de l'évaluateur
5.4. Comparaison critique
5.5. Construction de la Syntaxe Abstraite
6. Les Comparaisons avec d'autres Approches
7. Les Perspectives
8. Les Editeurs
8.0. brisé sur la barrière de la complexité (une fois de plus)
8.1. L'éditeur ligne : Manuel de l'utilisateur
8.2. L'éditeur page : Guide de l'utilisateur
9. Les Aspects d'Implantation
9.1. Contexte d'évaluation
9.2. La Syntaxe Abstraite : Manuel du concepteur
9.3. L'éditeur page : Guide de l'implanteur
Références
Rubrique Perl-Javascript

La pile

Le domaine d'intérêt des travaux touchant le Génie Logiciel, il paraît bien naturel de présenter l'exemple de la pile. On s'intéresse cependant plus ici au mode d'implantation de la pile qu'à sa qualité de type abstrait de données générique.

1. Généricité en LTR3

2. La forme générique de la pile

3. Les deux instanciations

4. Conclusion

5. La représentation « textuelle »

2. La forme générique de la pile

On identifie les propriétés exportés par le type pile :

INTERFACE OF pile_générique;
   USE pile_paramètres;
   TYPE pile:RECORD rep:pileRep; END RECORD;
   PROCEDURE Initialiser( p:INOUT pile );
   PROCEDURE Mettre( p:INOUT pile; e:IN element );
   PROCEDURE Prendre( p:INOUT pile; e:OUT element );
END INTERFACE;

On peut remarquer en particulier que (1) le type des éléments n'est pas spécifié (ce sera un paramètre de généricité) et (2) la représentation du type pile n'est pas non plus donné (le type est défini comme un type dérivé de la représentation du type pileRep, lequel sera aussi un paramètre de généricité).

La "spécification" du corps

On identifie des « traitements de bas niveau », indépendants du choix de la représentation :

BODY OF pile_générique;

   USE pile_paramètres;

   PROCEDURE Initialiser( p:INOUT pile );
   BEGIN
      annuler-pointeur(p.rep);
   END;

   PROCEDURE Mettre( p:INOUT pile; e:IN element );
   BEGIN
      incrémenter-pointeur(p.rep);
      écrire-valeur(p.rep, e);
   END;

   PROCEDURE Prendre( p:INOUT pile; e:OUT element );
   BEGIN
      lire-valeur(p.rep, e);
      décrémenter-pointeur(p.rep);
   END;

END BODY;

Entre Mettre et Prendre on observe la classique symétrie dans l'ordre des « traitements de bas niveau ».

La "spécification" du module des paramètres

On donne ici la déclaration du type pileRep qui doit définir la représentation de la pile et les différentes procédures dont il faudra écrire le corps à l'instanciation du module :

INTERFACE OF pile_paramètres;
   TYPE element;
   TYPE pileRep;
   PROCEDURE annuler-pointeur( p:INOUT pileRep );
   PROCEDURE incrémenter-pointeur( p:INOUT pileRep );
   PROCEDURE décrémenter-pointeur( p:INOUT pileRep );
   PROCEDURE écrire-valeur( p:INOUT pileRep; e:IN element );
   PROCEDURE lire-valeur( p:INOUT pileRep; e:OUT element );
END INTERFACE;

On attend en plus la définition du type des éléments element.