Manipulation symbolique

La première étape consiste à faire de la manipulation symbolique de textes. Au lieu d'utiliser des chaînes de caractères, on définit des textes, qu'on utilise ensuite symboliquement en les nommant au lieu de leur représentation.

Tout de suite on introduit la notion de module : on ne peut guère considérer toutes les définitions de textes placées au même niveau, où tout le monde verrait tout le monde ; on comprend qu'on se heurterait alors rapidement à de franches difficultés pour retrouver une définition de texte, pour inventer un nouveau nom de texte, ...

La deuxième étape consiste à faire de la manipulation symbolique de symboles. Ceci tient à diverses raisons :

• le problème des zones communes (par exemple une déclaration de variable commune à deux textes) ;
• le souhait d'une contruction progressive, du plus général vers le plus spécifique ; par exemple :

  def x def y = def x complété def z = def y complété

  def z    def y       def x    ...

  la traduction de la notion de « forme complétée de texte » a pour conséquence de masquer alors la visibilité des textes x et y – qui sont des cas généraux qu'on pourrait souhaiter utiliser plusieurs fois.

Un symbole a alors deux valeurs :

• une valeur d'environnement,
• une valeur de représentation,

La manipulation symbolique des textes s'intéresse à la valeur de représentation.
La manipulation symbolique des symboles s'intéresse à la valeur d'environnement.

Note :
On peut rapprocher du propos précédent le type d'interprétation qu'on donne aux environnements locaux d'utilisation :
(use a
   (def x ...)
   (def y ...))
on définit un nouveau symbole de manipulation des symboles : $, qui est tel que :
- l'environnement de $ est composé des textes x et y,
- la représentation de $ est, par défaut : (use a).
La représentation est alors évaluée dans le contexte de définition du symbole $, ce qui correspond bien à ce qu'on souhaite.

Exemple 1

définition des variables

def var
   def decla = "VAR " (use nom) ":" (use type) ";"
   def util  = (use nom)

définition d'une variable

def varA
   def nom = "A"
   def type = "integer"
   (ref var)

• nom et type sont des symboles de textes.
• varA lui est un symbole de symboles : en particulier on ne lui associe aucune valeur de représentation significative. varA concentre la déclaration et l'utilisation de la variable "A" de type "integer".

varA admet les propriétés :
nom, type, decla, util

La déclaration textuelle de "A" est :
(use decla (ref varA))

L'utilisation textuelle de "A" est :
(use util (ref varA))

Mais aussi, par exemple : le type de "A" – qui est un contrôle non textuel – est :
(use type (ref varA))

Exemple 2

définition des tableaux

def tab
   def utiltab = (use nom) "[" (use index) "]"
   def type  = "ARRAY[1.." (use taille) "] OF " (use typeelt) ";"
   (ref var)

définition d'une variable tableau

def tabB
   def nom = "B"
   def taille = "100"
   def typeelt = "real"
   (ref tab)

Dans tab :
- on ajoute la propriété : utiltab,
- on masque le paramètre type en l'instanciant.
Les paramètres sont alors : nom, taille et typeelt.

L'utilisation textuelle de "B" peut s'intéresser au tableau global ou au tableau indicé :

le tableau global :
(use util (ref tabB))

le tableau indicé :
(use utiltab
   (def index = "I")
   (ref tabB))

tabB concentre ces deux sortes d'utilisation du même objet "B" dans deux perspectives différentes – deux types différents.