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.1.1. Les intentions
2.1.11.1. L'objectif
2.1.11.2. La réponse
2.1.11.3. L'éditeur syntaxique
2.1.11.4. L'état de la science dans le domaine
2.1.11.5. L'expression de besoin
2.1.11.6. Le choix de la Représentation Interne
2.1.11.7. La réponse au problème
2.1.11.8. La référence
2.1.2. Eléments du langage
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.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

Les intentions

1. L'objectif

2. La réponse

3. L'éditeur syntaxique

4. L'état de la science dans le domaine

5. L'expression de besoin

6. Le choix de la Représentation Interne

7. La réponse au problème

8. La référence

6. Le choix de la Représentation Interne

Pour spécifier la Représentation Interne (R.I.) on a défini un Langage de Construction de Langage (LCL). Ce langage est bien à différencier d'un Langage de Description de Langage (LDL) tel qu'on en trouve classiquement dans un éditeur syntaxique. Un LDL permet de définir les opérateurs et les phyla d'un langage, avec de plus ou moins riches compléments sémantiques. Mais le schéma traditionnel d'un tel langage :
-> édition d'un programme en LDL
-> compilation
-> interprétation du code objet (c'est-à-dire session sous l'éditeur syntaxique)
ne permet pas de retour immédiat au source LDL initial. On peut cependant noter que l'étape de compilation permet d'assurer un grand nombre de contrôles concernant le bien-fondé de la syntaxe définie.

Le LCL à l'opposé n'offre guère de contrôles de cohérence mais il permet une interprétation du texte qui définit le langage, c'est-à-dire une construction incrémentale de la syntaxe du langage édité.

La différence porte donc plutôt sur la mise en œuvre du langage que sur le langage lui-même ; mais l'une entraîne l'autre puisqu'on adopte une représentation « graphique » et non syntaxique des concepts des langages utilisés, ce qui nécessite alors une grande simplicité des notions introduites – afin d'éviter une trop importante diversité des formes graphiques définies.

Au départ, on définit les deux opérateurs principaux :

Un opérateur d'arité non nulle est une définition de texte def pour laquelle on trouve dans sa représentation des utilisations d'opérateurs use.

Comment va travailler l'éditeur ? il évalue les termes du langage (LCL). Une définition est évaluée identiquement à elle-même. Pour une utilisation d'un nom <nom>, on commencera par chercher une définition du nom <nom> : si on en trouve une, alors l'utilisation sera « visuellement » remplacée par la représentation associée ; si on n'en trouve pas, un affichage spécifique indiquera à l'utilisateur l'absence d'une définition visible de cet opérateur. « Visuellement » signifie qu'un outil interactif doit afficher à l'écran la forme décompilée des arbres syntaxiques manipulés, même si dans sa R.I. il ne conserve pas le texte affiché mais le nom de l'opérateur utilisé.

La notion de « recherche de définition » introduit celle de « contexte d'évaluation » : s'il faut rechercher, où la rechercher ? Pour cela on s'inspire des mécanismes utilisés dans les langages à structure de bloc.

Une définition se présente en fait sous la forme :

La recherche d'un opérateur <nom> s'effectue alors en construisant le contexte d'évaluation relatif à l'utilisation, puis en recherchant, dans l'ordre des environnements, la première définition de nom <nom>.

Par exemple :

def txt1
  env: def a
         env: def u
              def v
         rep: ...
       def b
         ...
  rep: ...
def txt2
  ...
def txt3
  ...

Dans la représentation de u, une utilisation de nom sera recherchée dans le contexte :

Contexte d'évaluation

Au sommet on a alors l'« environnement global » qui est la liste de tous les opérateurs globalement définis, ou encore de tous les tampons en cours d'édition sous l'éditeur.