[ 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.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.3.1. Définition d'un langage
3.3.11.1. La grammaire du langage
3.3.11.2. La syntaxe abstraite et les schémas de décompilation
3.3.11.3. La représentation textuelle
3.3.11.4. La concentration des variables
3.3.11.5. La concentration des propriétés
3.3.11.6. La paramétrisation des propriétés
3.3.11.7. Le poids sémantique des propriétés
3.3.2. Information de contexte
3.3.3. Exécution
3.3.4. Définition de propriétés
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

Définition d'un langage

On illustre la démarche par un exemple.

1. La grammaire du langage

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

6. La paramétrisation des propriétés

7. Le poids sémantique des propriétés

2. La syntaxe abstraite et les schémas de décompilation

Figure 2.a : syntaxe abstraite

On définit la syntaxe abstraite du langage qui va permettre de définir un éditeur spécifique à ce langage. La syntaxe choisie est voisine de celle définie par le langage Metal, utilisé par Mentor : les phyla sont des identificateurs écrits en majuscule, les opérateurs en minuscule. Les phyla « prédéfinis » correspondent à des terminaux instanciables pour lesquels on ne précisent pas davantage la définition.

Par exemple : l'affectation

INSTR ::= affect affiche cond

Le phylum INSTR (des instructions) regroupe les opérateurs affect (affectation), affiche (affichage) et cond (phrase conditionnelle).

affect ::= VAR EXP

L'opérateur affect est défini par deux opérateurs, lesquels doivent appartenir aux phyla VAR (les variables) et EXP (les expressions) respectivement.

Figure 2.a : syntaxe abstraite [ afficher >><< masquer ]

Notations :

::= : le phylum (à gauche) contient les opérateurs (à droite)
-> : l'opérateur (à gauche) est défini par les phyla (à droite)
cas particulier des listes : *... signifie que l'opérateur est défini par une liste d'opérateurs éléments du phylum
PGME ::= pgme
  pgme -> PGME-DECLA PGME-INSTR
PGME-DECLA ::= pgme-decla
  pgme-decla -> DECLA*...
PGME-INSTR ::= pgme-instr
  pgme-instr -> INSTR*...

DECLA ::= decla
  decla -> NOM TYP
INSTR ::= affect affiche cond
  affect  -> VAR EXP
  affiche -> EXP
  cond    -> EXP-COND THEN-CLAUSE ELSE-CLAUSE

EXP-COND ::= exp-egal exp-diff
  exp-egal -> EXP EXP
  exp-diff -> EXP EXP
THEN-CLAUSE ::= then-clause
  then-clause -> INSTR*...
ELSE-CLAUSE ::= else-clause
  else-clause -> INSTR*...

NOM TYP VAR EXP ::= prédéfini

Figure 2.b : schémas de décompilation

La définition précédente de la syntaxe abstraite est insuffisante pour réaliser l'affichage d'un programme ; on donne donc, en plus de celle-ci, les schémas de décompilation des opérateurs.

Par exemple : l'affectation

affect(VAR,EXP) = VAR := EXP

L'opérateur affect, paramétré par deux termes symbolisés ici par les méta-variables VAR et EXP se décompile en :
- la forme décompilée du paramètre VAR,
- le symbole ":=",
- la forme décompilée du paramètre EXP.

Figure 2.b : schémas de décompilation [ afficher >><< masquer ]

Chaque opérateur est défini par :

  • la liste des paramètres formels (qu'on nomme par les noms de phyla associés),
  • le schéma de décompilation (à droite de =).
    cas particulier des listes : le paramètre formel noté NOM*, et la répétition d'un schéma de décompilation est symbolisée par des accolades.
pgme (PGME-DECLA,PGME-INSTR)
 = PGME-DECLA
   PGME-INSTR
pgme-decla (DECLA*) = VAR { DECLA }
pgme-instr (INSTR*) = { INSTR }

decla (NOM,TYP)  = NOM : TYP
affect (VAR,EXP) = VAR := EXP
affiche (EXP)    = write( EXP )
cond (EXP-COND,THEN-CLAUSE,ELSE-CLAUSE)
 = if EXP-COND
   THEN-CLAUSE
   ELSE-CLAUSE
   endif

exp-egal (EXP1,EXP2) = EXP1 = EXP2
exp-diff (EXP1,EXP2) = EXP1 <> EXP2
then-clause (INSTR*) = then { INSTR }
else-clause (INSTR*) = else { INSTR }

Figure 2.c : arbre syntaxique

On donne l'arbre syntaxique associé au programme précédent.

Par exemple : l'affectation

INSTR = affect
        VAR = "x"
        EXP = "y"

On choisit dans le phylum INSTR l'opérateur affect, en fournissant les "paramètres" :
- VAR, un terminal instanciable auquel on donne la valeur "x",
- EXP, avec la valeur "y".

Figure 2.c : arbre syntaxique [ afficher >><< masquer ]

PGME = pgme
       PGME-DECLA = <pgme-decla>
       PGME-INSTR = <pgme-instr>
 signifie qu'on définit son programme PGME sur l'opérateur pgme, en instanciant les paramètres PGME-DECLA par <pgme-decla> et PGME-INSTR par <pgme-instr>.

PGME = pgme
       PGME-DECLA = pgme-decla
            DECLA* ->
               DECLA = decla
                       NOM = "x"
                       TYP = "integer"
               DECLA = decla
                       NOM = "y"
                       TYP = "real"
       PGME-INSTR = pgme-instr
            INSTR* ->
               INSTR = affect
                       VAR = "x"
                       EXP = "0"
               INSTR = affect
                       VAR = "y"
                       EXP = "1.0"
               INSTR = cond
                       EXP-COND = exp-egal
                                  EXP1 = "x"
                                  EXP2 = "y"
                       THEN-CLAUSE = then-clause
                            INSTR* ->
                               INSTR = affiche
                                       EXP = "'Ok'"
                       ELSE-CLAUSE = else-clause
                            INSTR* ->
                               INSTR = affect
                                       VAR = "x"
                                       EXP = "y"
                               INSTR = affiche
                                       EXP = "'Erreur'"
               INSTR = affiche
                       EXP = "'fin'"